Move "common/config" common types into cfgtypes.

logdog/server/archivist/archivist.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package archivist
 
 import (
         "bytes"
         "encoding/hex"
         "fmt"
         "io"
         "time"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
-        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/sync/parallel"
         "github.com/luci/luci-go/common/tsmon/distribution"
         "github.com/luci/luci-go/common/tsmon/field"
         "github.com/luci/luci-go/common/tsmon/metric"
         tsmon_types "github.com/luci/luci-go/common/tsmon/types"
         "github.com/luci/luci-go/logdog/api/endpoints/coordinator/services/v1"
         "github.com/luci/luci-go/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/common/archive"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/types"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
 )
 
 const (
         tsEntriesField = "entries"
         tsIndexField   = "index"
         tsDataField    = "data"
 
         // If the archive dispatch is within this range of the current time, we will
         // avoid archival.
         dispatchThreshold = 5 * time.Minute
@@ skipping 101 matching lines @@
         IndexStreamRange int
         // IndexPrefixRange is the maximum number of prefix indexes in between index
         // entries. See archive.Manifest for more information.
         IndexPrefixRange int
         // IndexByteRange is the maximum number of stream data bytes in between index
         // entries. See archive.Manifest for more information.
         IndexByteRange int
 }
 
 // SettingsLoader returns archival Settings for a given project.
-type SettingsLoader func(context.Context, config.ProjectName) (*Settings, error)
+type SettingsLoader func(context.Context, cfgtypes.ProjectName) (*Settings, error)
 
 // Archivist is a stateless configuration capable of archiving individual log
 // streams.
 type Archivist struct {
         // Service is the client to use to communicate with Coordinator's Services
         // endpoint.
         Service logdog.ServicesClient
 
         // SettingsLoader loads archival settings for a specific project.
         SettingsLoader SettingsLoader
@@ skipping 36 matching lines @@
 
 // archiveTaskImpl performs the actual task archival.
 //
 // Its error return value is used to indicate how the archive failed. isFailure
 // will be called to determine if the returned error value is a failure or a
 // status error.
 func (a *Archivist) archiveTaskImpl(c context.Context, task Task) error {
         at := task.Task()
 
         // Validate the project name.
-        if err := config.ProjectName(at.Project).Validate(); err != nil {
+        if err := cfgtypes.ProjectName(at.Project).Validate(); err != nil {
                 task.Consume()
                 return fmt.Errorf("invalid project name %q: %s", at.Project, err)
         }
 
         // Get the local time. If we are within the dispatchThreshold, retry this
         // archival later.
         if ad := at.DispatchedAt.Time(); !ad.IsZero() {
                 now := clock.Now(c)
                 delta := now.Sub(ad)
                 if delta < 0 {
@@ skipping 76 matching lines @@
         age := ls.Age.Duration()
         if age < at.SettleDelay.Duration() {
                 log.Fields{
                         "age":         age,
                         "settleDelay": at.SettleDelay.Duration(),
                 }.Infof(c, "Log stream is younger than the settle delay. Returning task to queue.")
                 return statusErr(errors.New("log stream is within settle delay"))
         }
 
         // Load archival settings for this project.
-        settings, err := a.loadSettings(c, config.ProjectName(at.Project))
+        settings, err := a.loadSettings(c, cfgtypes.ProjectName(at.Project))
         if err != nil {
                 log.Fields{
                         log.ErrorKey: err,
                         "project":    at.Project,
                 }.Errorf(c, "Failed to load settings for project.")
                 return err
         }
 
         ar := logdog.ArchiveStreamRequest{
                 Project: at.Project,
                 Id:      at.Id,
         }
 
         // Build our staged archival plan. This doesn't actually do any archiving.
-        staged, err := a.makeStagedArchival(c, config.ProjectName(at.Project), settings, ls, task.UniqueID())
+        staged, err := a.makeStagedArchival(c, cfgtypes.ProjectName(at.Project), settings, ls, task.UniqueID())
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create staged archival plan.")
                 return err
         }
 
         // Are we required to archive a complete log stream?
         if age <= at.CompletePeriod.Duration() {
                 // If we're requiring completeness, perform a keys-only scan of intermediate
                 // storage to ensure that we have all of the records before we bother
                 // streaming to storage only to find that we are missing data.
@@ skipping 77 matching lines @@
                 return err
         }
 
         // Archival is complete and acknowledged by Coordinator. Consume the archival
         // task.
         task.Consume()
         return nil
 }
 
 // loadSettings loads and validates archival settings.
-func (a *Archivist) loadSettings(c context.Context, project config.ProjectName) (*Settings, error) {
+func (a *Archivist) loadSettings(c context.Context, project cfgtypes.ProjectName) (*Settings, error) {
         if a.SettingsLoader == nil {
                 panic("no settings loader configured")
         }
 
         st, err := a.SettingsLoader(c, project)
         switch {
         case err != nil:
                 return nil, err
 
         case st.GSBase.Bucket() == "":
                 log.Fields{
                         log.ErrorKey: err,
                         "gsBase":     st.GSBase,
                 }.Errorf(c, "Invalid storage base.")
                 return nil, errors.New("invalid storage base")
 
         case st.GSStagingBase.Bucket() == "":
                 log.Fields{
                         log.ErrorKey:    err,
                         "gsStagingBase": st.GSStagingBase,
                 }.Errorf(c, "Invalid storage staging base.")
                 return nil, errors.New("invalid storage staging base")
 
         default:
                 return st, nil
         }
 }
 
-func (a *Archivist) makeStagedArchival(c context.Context, project config.ProjectName,
+func (a *Archivist) makeStagedArchival(c context.Context, project cfgtypes.ProjectName,
         st *Settings, ls *logdog.LoadStreamResponse, uid string) (*stagedArchival, error) {
 
         sa := stagedArchival{
                 Archivist: a,
                 Settings:  st,
                 project:   project,
 
                 terminalIndex: types.MessageIndex(ls.State.TerminalIndex),
         }
 
@@ skipping 22 matching lines @@
 
                 sa.data = sa.makeStagingPaths(fmt.Sprintf("data.%s", bext), uid)
         }
         return &sa, nil
 }
 
 type stagedArchival struct {
         *Archivist
         *Settings
 
-        project config.ProjectName
+        project cfgtypes.ProjectName
         path    types.StreamPath
         desc    logpb.LogStreamDescriptor
 
         stream stagingPaths
         index  stagingPaths
         data   stagingPaths
 
         finalized     bool
         terminalIndex types.MessageIndex
         logEntryCount int64
@@ skipping 295 matching lines @@
         return e.inner
 }
 
 func isFailure(err error) bool {
         if err == nil {
                 return false
         }
         _, ok := err.(*statusErrorWrapper)
         return !ok
 }