Move "common/config" common types into cfgtypes.

logdog/client/cli/main.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 cli
 
 import (
         "flag"
         "fmt"
         "os"
         "os/signal"
         "strings"
         "time"
 
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/client/authcli"
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/cli"
         "github.com/luci/luci-go/common/clock/clockflag"
-        "github.com/luci/luci-go/common/config"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/grpc/prpc"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
 )
 
 func init() {
         prpc.DefaultUserAgent = "logdog CLI"
 }
 
 // Parameters is the set of application parametesr that can be supplied.
 type Parameters struct {
         // Args is the command-line arguments. This should not include the command name,
         // args[0].
         Args []string
 
         // Host is the default host name.
         Host string
 }
 
 type application struct {
         cli.Application
         context.Context
 
         // p is the set of runtime parameters to use.
         p Parameters
 
         // project is the project name. This may either be a valid project name or
         // empty. Subcommands that support "unified" project-in-path paths should use
         // splitPath to get the project form the path. Those that don't should assert
         // that this is non-empty.
-        project   config.ProjectName
+        project   cfgtypes.ProjectName
         authFlags authcli.Flags
         insecure  bool
         timeout   clockflag.Duration
 
         coord *coordinator.Client
 }
 
 func (a *application) addToFlagSet(ctx context.Context, fs *flag.FlagSet) {
         fs.StringVar(&a.p.Host, "host", a.p.Host,
                 "The LogDog Coordinator [host][:port].")
         fs.BoolVar(&a.insecure, "insecure", false,
                 "Use insecure transport for RPC.")
         fs.Var(&a.project, "project",
                 "The log stream's project.")
 
         fs.Var(&a.timeout, "timeout",
                 "If >0, a duration string for the maximum amount of time to wait for a log entry "+
                         "before exiting with a 2. "+clockflag.DurationHelp)
 }
 
 // splitPath converts between a possible user-facing "unified" stream path
 // (e.g., "project/path...") to separate project/path values.
 //
 // If a project is supplied via command-line, the path is returned directly
 // along with the project. If no project is supplied, the first slash-delimited
 // component of "p" is used as the project name.
-func (a *application) splitPath(p string) (config.ProjectName, string, bool, error) {
+func (a *application) splitPath(p string) (cfgtypes.ProjectName, string, bool, error) {
         if a.project != "" {
                 return a.project, p, false, nil
         }
 
         parts := strings.SplitN(p, types.StreamNameSepStr, 2)
 
-        project := config.ProjectName(parts[0])
+        project := cfgtypes.ProjectName(parts[0])
         if err := project.Validate(); err != nil {
                 return "", "", false, fmt.Errorf("invalid project name %q: %v", project, err)
         }
 
         if len(parts) == 2 {
                 p = parts[1]
         } else {
                 p = ""
         }
         return project, p, true, nil
@@ skipping 96 matching lines @@
                 C:       httpClient,
                 Host:    a.p.Host,
                 Options: prpc.DefaultOptions(),
         }
         prpcClient.Options.Insecure = a.insecure
 
         a.coord = coordinator.NewClient(prpcClient)
         a.Context = ctx
         return subcommands.Run(&a, flags.Args())
 }