LogDog: Add project namespace to service endpoint.

appengine/logdog/coordinator/endpoints/services/registerStream.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package services
 
 import (
         "crypto/subtle"
         "errors"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/appengine/logdog/coordinator"
         "github.com/luci/luci-go/appengine/logdog/coordinator/mutations"
         "github.com/luci/luci-go/appengine/tumble"
         "github.com/luci/luci-go/common/api/logdog_coordinator/services/v1"
         "github.com/luci/luci-go/common/clock"
+        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/grpcutil"
         "github.com/luci/luci-go/common/logdog/types"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/logdog/logpb"
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 )
 
 func matchesLogStream(r *logdog.RegisterStreamRequest, ls *coordinator.LogStream) error {
@@ skipping 13 matching lines @@
         if err != nil {
                 return errors.New("log stream has invalid descriptor value")
         }
         if !dv.Equal(r.Desc) {
                 return errors.New("descriptor protobufs do not match")
         }
 
         return nil
 }
 
-func loadLogStreamState(ls *coordinator.LogStream) *logdog.LogStreamState {
+func loadLogStreamState(project config.ProjectName, ls *coordinator.LogStream) *logdog.LogStreamState {
         st := logdog.LogStreamState{
+                Project:       string(project),
                 Path:          string(ls.Path()),
                 ProtoVersion:  ls.ProtoVersion,
                 TerminalIndex: ls.TerminalIndex,
                 Archived:      ls.Archived(),
                 Purged:        ls.Purged,
         }
         if !ls.Terminated() {
                 st.TerminalIndex = -1
         }
         return &st
 }
 
 // RegisterStream is an idempotent stream state register operation.
 func (s *server) RegisterStream(c context.Context, req *logdog.RegisterStreamRequest) (*logdog.RegisterStreamResponse, error) {
         log.Fields{
-                "path": req.Path,
+                "project": req.Project,
+                "path":    req.Path,
         }.Infof(c, "Registration request for log stream.")
 
         path := types.StreamPath(req.Path)
         if err := path.Validate(); err != nil {
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Invalid path (%s): %s", path, err)
         }
 
         switch {
         case req.ProtoVersion == "":
                 return nil, grpcutil.Errf(codes.InvalidArgument, "No protobuf version supplied.")
         case req.ProtoVersion != logpb.Version:
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Unrecognized protobuf version.")
-        case len(req.Secret) != types.StreamSecretLength:
-                return nil, grpcutil.Errf(codes.InvalidArgument, "Invalid secret length (%d != %d)",
-                        len(req.Secret), types.StreamSecretLength)
         case req.Desc == nil:
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Missing log stream descriptor.")
         }
 
+        secret := types.PrefixSecret(req.Secret)
+        if err := secret.Validate(); err != nil {
+                return nil, grpcutil.Errf(codes.InvalidArgument, "Invalid prefix secret: %s", err)
+        }
+
         prefix, name := path.Split()
         if err := req.Desc.Validate(true); err != nil {
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Invalid log stream descriptor: %s", err)
         }
         switch {
         case req.Desc.Prefix != string(prefix):
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Descriptor prefix does not match path (%s != %s)",
                         req.Desc.Prefix, prefix)
         case req.Desc.Name != string(name):
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Descriptor name does not match path (%s != %s)",
@@ skipping 38 matching lines @@
                         }.Errorf(c, "Failed to register LogStream.")
                         return nil, filterError(err)
                 }
 
         default:
                 log.WithError(err).Errorf(c, "Failed to check for log stream.")
                 return nil, grpcutil.Internal
         }
 
         return &logdog.RegisterStreamResponse{
-                State:  loadLogStreamState(ls),
+                State:  loadLogStreamState(coordinator.Project(c), ls),
                 Secret: ls.Secret,
         }, nil
 }
 
 func filterError(err error) error {
         switch {
         case err == nil:
                 return nil
         case grpc.Code(err) == codes.Unknown:
                 return grpcutil.Internal
@@ skipping 73 matching lines @@
         return []tumble.Mutation{
                 &mutations.PutHierarchyMutation{
                         Path: m.Path(),
                 },
         }, nil
 }
 
 func (m registerStreamMutation) Root(c context.Context) *ds.Key {
         return ds.Get(c).KeyForObj(m.LogStream)
 }