LogDog: Project READ access for user endpoints.

appengine/logdog/coordinator/endpoints/services/terminateStream.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"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/appengine/logdog/coordinator"
+        "github.com/luci/luci-go/appengine/logdog/coordinator/endpoints"
         "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"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
         "golang.org/x/net/context"
         "google.golang.org/grpc/codes"
 )
 
 // TerminateStream is an idempotent stream state terminate operation.
 func (s *server) TerminateStream(c context.Context, req *logdog.TerminateStreamRequest) (*google.Empty, error) {
         log.Fields{
                 "project":       req.Project,
                 "id":            req.Id,
                 "terminalIndex": req.TerminalIndex,
         }.Infof(c, "Request to terminate log stream.")
 
         if req.TerminalIndex < 0 {
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Negative terminal index.")
         }
 
         id := coordinator.HashID(req.Id)
         if err := id.Normalize(); err != nil {
                 return nil, grpcutil.Errf(codes.InvalidArgument, "Invalid ID (%s): %s", id, err)
         }
 
+        // Load our service and project configs.
         svc := coordinator.GetServices(c)
         cfg, err := svc.Config(c)
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to load configuration.")
                 return nil, grpcutil.Internal
         }
 
+        pcfg, err := coordinator.CurrentProjectConfig(c)
+        if err != nil {
+                log.WithError(err).Errorf(c, "Failed to load current project configuration.")
+                return nil, grpcutil.Internal
+        }
+
+        // Initialize our archival parameters.
+        params := coordinator.ArchivalParams{
+                RequestID:      info.Get(c).RequestID(),
+                SettleDelay:    cfg.Coordinator.ArchiveSettleDelay.Duration(),
+                CompletePeriod: endpoints.MinDuration(cfg.Coordinator.ArchiveDelayMax, pcfg.MaxStreamAge),
+        }
+
         ap, err := svc.ArchivalPublisher(c)
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to get archival publisher instance.")
                 return nil, grpcutil.Internal
         }
 
         // Initialize our log stream state.
         di := ds.Get(c)
         lst := coordinator.NewLogStreamState(di, id)
 
-        // Initialize our archival parameters.
-        params := coordinator.ArchivalParams{
-                RequestID:      info.Get(c).RequestID(),
-                SettleDelay:    cfg.Coordinator.ArchiveSettleDelay.Duration(),
-                CompletePeriod: cfg.Coordinator.ArchiveDelayMax.Duration(),
-        }
-
         // Transactionally validate and update the terminal index.
         err = di.RunInTransaction(func(c context.Context) error {
                 di := ds.Get(c)
 
                 if err := di.Get(lst); err != nil {
                         if err == ds.ErrNoSuchEntity {
                                 log.Debugf(c, "Log stream state not found.")
                                 return grpcutil.Errf(codes.NotFound, "Log stream %q is not registered", id)
                         }
 
@@ skipping 61 matching lines @@
         }, nil)
         if err != nil {
                 log.Fields{
                         log.ErrorKey: err,
                 }.Errorf(c, "Failed to update LogStream.")
                 return nil, err
         }
 
         return &google.Empty{}, nil
 }