Move "common/config" common types into cfgtypes.

logdog/client/coordinator/stream.go

 // Copyright 2015 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 coordinator
 
 import (
         "errors"
         "fmt"
         "time"
 
-        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/logdog/api/endpoints/coordinator/logs/v1"
         "github.com/luci/luci-go/logdog/api/logpb"
         "github.com/luci/luci-go/logdog/common/types"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
         "golang.org/x/net/context"
 )
 
 // StreamState represents the client-side state of the log stream.
 //
 // It is a type-promoted version of logdog.LogStreamState.
 type StreamState struct {
         // Created is the time, represented as a UTC RFC3339 string, when the log
         // stream was created.
         Created time.Time
@@ skipping 21 matching lines @@
         ArchiveDataURL string
 
         // Purged indicates the purged state of a log. A log that has been purged is
         // only acknowledged to administrative clients.
         Purged bool
 }
 
 // LogStream is returned metadata about a log stream.
 type LogStream struct {
         // Project is the log stream's project.
-        Project config.ProjectName
+        Project cfgtypes.ProjectName
         // Path is the path of the log stream.
         Path types.StreamPath
 
         // Desc is the log stream's descriptor.
         Desc logpb.LogStreamDescriptor
 
         // State is the stream's current state.
         State StreamState
 }
 
 func loadLogStream(proj string, path types.StreamPath, s *logdog.LogStreamState, d *logpb.LogStreamDescriptor) (
         *LogStream, error) {
         switch {
         case s == nil:
                 return nil, errors.New("missing required log state")
         case d == nil:
                 return nil, errors.New("missing required descriptor")
         }
 
         ls := LogStream{
-                Project: config.ProjectName(proj),
+                Project: cfgtypes.ProjectName(proj),
                 Path:    path,
                 Desc:    *d,
                 State: StreamState{
                         Created:       s.Created.Time(),
                         TerminalIndex: types.MessageIndex(s.TerminalIndex),
                         Purged:        s.Purged,
                 },
         }
         if a := s.Archive; a != nil {
                 ls.State.Archived = true
                 ls.State.ArchiveIndexURL = a.IndexUrl
                 ls.State.ArchiveStreamURL = a.StreamUrl
                 ls.State.ArchiveDataURL = a.DataUrl
         }
         return &ls, nil
 }
 
 // Stream is an interface to Coordinator stream-level commands. It is bound to
 // and operates on a single log stream path.
 type Stream struct {
         // c is the Coordinator instance that this Stream is bound to.
         c *Client
 
         // project is this stream's project.
-        project config.ProjectName
+        project cfgtypes.ProjectName
         // path is the log stream's prefix.
         path types.StreamPath
 }
 
 // State fetches the LogStreamDescriptor for a given log stream.
 func (s *Stream) State(ctx context.Context) (*LogStream, error) {
         req := logdog.GetRequest{
                 Project:  string(s.project),
                 Path:     string(s.path),
                 State:    true,
@@ skipping 199 matching lines @@
         }
 
         ls, err := loadLogStream(resp.Project, resp.Desc.Path(), resp.State, resp.Desc)
         if err != nil {
                 return fmt.Errorf("failde to load stream state: %v", err)
         }
 
         *stateP = *ls
         return nil
 }