LogDog: Update to archival V2.

appengine/logdog/coordinator/endpoints/logs/get.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 logs
 
 import (
         "net/url"
         "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/config"
         "github.com/luci/luci-go/common/api/logdog_coordinator/logs/v1"
         "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/retry"
         "github.com/luci/luci-go/server/logdog/storage"
         "github.com/luci/luci-go/server/logdog/storage/archive"
         "golang.org/x/net/context"
         "google.golang.org/grpc/codes"
@@ skipping 20 matching lines @@
 func (s *Server) Tail(c context.Context, req *logdog.TailRequest) (*logdog.GetResponse, error) {
         r := logdog.GetRequest{
                 Path:  req.Path,
                 State: req.State,
         }
         return s.getImpl(c, &r, true)
 }
 
 // getImpl is common code shared between Get and Tail endpoints.
 func (s *Server) getImpl(c context.Context, req *logdog.GetRequest, tail bool) (*logdog.GetResponse, error) {
+        svc := s.GetServices()
+
         // Fetch the log stream state for this log stream.
         u, err := url.Parse(req.Path)
         if err != nil {
                 log.Fields{
                         log.ErrorKey: err,
                         "path":       req.Path,
                 }.Errorf(c, "Could not parse path URL.")
                 return nil, grpcutil.Errf(codes.InvalidArgument, "invalid path encoding")
         }
         ls, err := coordinator.NewLogStream(u.Path)
         if err != nil {
                 log.Fields{
                         log.ErrorKey: err,
                         "path":       u.Path,
                 }.Errorf(c, "Invalid path supplied.")
                 return nil, grpcutil.Errf(codes.InvalidArgument, "invalid path value")
         }
 
         // If this log entry is Purged and we're not admin, pretend it doesn't exist.
         err = ds.Get(c).Get(ls)
         switch err {
         case nil:
                 if ls.Purged {
-                        if authErr := config.IsAdminUser(c); authErr != nil {
+                        if authErr := coordinator.IsAdminUser(c, svc); authErr != nil {
                                 log.Fields{
                                         log.ErrorKey: authErr,
                                 }.Warningf(c, "Non-superuser requested purged log.")
                                 return nil, grpcutil.Errf(codes.NotFound, "path not found")
                         }
                 }
 
         case ds.ErrNoSuchEntity:
                 log.Fields{
                         "path": u.Path,
@@ skipping 21 matching lines @@
                 var err error
                 resp.Desc, err = ls.DescriptorValue()
                 if err != nil {
                         log.WithError(err).Errorf(c, "Failed to deserialize descriptor protobuf.")
                         return nil, grpcutil.Internal
                 }
         }
 
         // Retrieve requested logs from storage, if requested.
         if tail || req.LogCount >= 0 {
-                resp.Logs, err = s.getLogs(c, req, tail, ls)
+                resp.Logs, err = s.getLogs(c, svc, req, tail, ls)
                 if err != nil {
                         log.Fields{
                                 log.ErrorKey: err,
                                 "path":       path,
                         }.Errorf(c, "Failed to get logs.")
                         return nil, grpcutil.Internal
                 }
         }
 
         log.Fields{
                 "logCount": len(resp.Logs),
         }.Debugf(c, "Get request completed successfully.")
         return &resp, nil
 }
 
-func (s *Server) getLogs(c context.Context, req *logdog.GetRequest, tail bool, ls *coordinator.LogStream) (
+func (s *Server) getLogs(c context.Context, svc coordinator.Services, req *logdog.GetRequest, tail bool,
+        ls *coordinator.LogStream) (
         []*logpb.LogEntry, error) {
         var st storage.Storage
         if !ls.Archived() {
                 log.Debugf(c, "Log is not archived. Fetching from intermediate storage.")
 
                 // Logs are not archived. Fetch from intermediate storage.
                 var err error
-                st, err = s.Storage(c)
+                st, err = svc.IntermediateStorage(c)
                 if err != nil {
                         return nil, err
                 }
         } else {
                 log.Debugf(c, "Log is archived. Fetching from archive storage.")
                 var err error
-                gs, err := s.GSClient(c)
+                gs, err := svc.GSClient(c)
                 if err != nil {
                         log.WithError(err).Errorf(c, "Failed to create Google Storage client.")
                         return nil, err
                 }
                 defer func() {
                         if err := gs.Close(); err != nil {
                                 log.WithError(err).Warningf(c, "Failed to close Google Storage client.")
                         }
                 }()
 
@@ skipping 118 matching lines @@
                         log.ErrorKey: err,
                         "delay":      delay,
                 }.Warningf(c, "Transient error while fetching tail log; retrying.")
         })
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to fetch tail log.")
                 return nil, err
         }
         return [][]byte{data}, err
 }