LogDog: Project READ access for user endpoints.

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 (
         "time"
 
         "github.com/golang/protobuf/proto"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/luci-go/appengine/logdog/coordinator"
         "github.com/luci/luci-go/appengine/logdog/coordinator/hierarchy"
         "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/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"
+        "github.com/luci/luci-go/common/proto/logdog/svcconfig"
         "golang.org/x/net/context"
         "google.golang.org/grpc/codes"
 )
 
 func buildLogStreamState(ls *coordinator.LogStream, lst *coordinator.LogStreamState) *logdog.LogStreamState {
         st := logdog.LogStreamState{
                 ProtoVersion:  ls.ProtoVersion,
                 Secret:        lst.Secret,
                 TerminalIndex: lst.TerminalIndex,
                 Archived:      lst.ArchivalState().Archived(),
                 Purged:        ls.Purged,
         }
         if !lst.Terminated() {
                 st.TerminalIndex = -1
         }
         return &st
 }
 
+func resolveArchiveDelay(cfg *svcconfig.Coordinator, pcfg *svcconfig.ProjectConfig) (delay time.Duration) {
+        if d := cfg.ArchiveDelayMax.Duration(); d > 0 {
+                delay = d
+        }
+        if d := pcfg.MaxStreamAge.Duration(); d > 0 && d < delay {
+                delay = d
+        }
+        return
+}
+
 // RegisterStream is an idempotent stream state register operation.
 //
 // Successive operations will succeed if they have the correct secret for their
 // registered stream, regardless of whether the contents of their request match
 // the currently registered state.
 func (s *server) RegisterStream(c context.Context, req *logdog.RegisterStreamRequest) (*logdog.RegisterStreamResponse, error) {
         var path types.StreamPath
 
         // Unmarshal the serialized protobuf.
         var desc logpb.LogStreamDescriptor
@@ skipping 18 matching lines @@
         log.Fields{
                 "project": req.Project,
                 "path":    path,
         }.Infof(c, "Registration request for log stream.")
 
         if err := desc.Validate(true); err != nil {
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Invalid log stream descriptor: %s", err)
         }
         prefix, _ := path.Split()
 
-        // Load our config and archive expiration.
+        // Load our service and project configs.
         cfg, err := coordinator.GetServices(c).Config(c)
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to load configuration.")
                 return nil, grpcutil.Internal
         }
 
-        archiveDelayMax := cfg.Coordinator.ArchiveDelayMax.Duration()
-        if archiveDelayMax < 0 {
-                log.Fields{
-                        "archiveDelayMax": archiveDelayMax,
-                }.Errorf(c, "Must have positive maximum archive delay.")
+        pcfg, err := coordinator.CurrentProjectConfig(c)
+        if err != nil {
+                log.WithError(err).Errorf(c, "Failed to load current project configuration.")
                 return nil, grpcutil.Internal
         }
 
+        // Determine the archival expiration.
+        archiveDelayMax := resolveArchiveDelay(cfg.Coordinator, pcfg)
+
         // Register our Prefix.
         //
         // This will also verify that our request secret matches the registered one,
         // if one is registered.
         //
         // Note: This step will not be necessary once a "register prefix" RPC call is
         // implemented.
         lsp := logStreamPrefix{
                 prefix: string(prefix),
                 secret: req.Secret,
@@ skipping 137 matching lines @@
                         return nil, grpcutil.Internal
                 }
         }
 
         return nil, nil
 }
 
 func (m *registerStreamMutation) Root(c context.Context) *ds.Key {
         return ds.Get(c).KeyForObj(m.ls)
 }