Move "common/config" common types into cfgtypes.

logdog/common/storage/bigtable/storage.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 bigtable
 
 import (
         "bytes"
         "errors"
         "fmt"
 
-        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/data/recordio"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/storage/caching"
         "github.com/luci/luci-go/logdog/common/types"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
 
         "cloud.google.com/go/bigtable"
         "golang.org/x/net/context"
         "google.golang.org/api/option"
 )
 
 var (
         // StorageScopes is the set of OAuth scopes needed to use the storage
         // functionality.
         StorageScopes = []string{
@@ skipping 267 matching lines @@
         switch err {
         case nil, errStop:
                 return nil
 
         default:
                 log.WithError(err).Errorf(ctx, "Failed to retrieve row range.")
                 return err
         }
 }
 
-func (s *btStorage) Tail(project config.ProjectName, path types.StreamPath) (*storage.Entry, error) {
+func (s *btStorage) Tail(project cfgtypes.ProjectName, path types.StreamPath) (*storage.Entry, error) {
         ctx := log.SetFields(s, log.Fields{
                 "project": project,
                 "path":    path,
         })
 
         // Load the "last tail index" from cache. If we have no cache, start at 0.
         var startIdx int64
         if s.Cache != nil {
                 startIdx = getLastTailIndex(s, s.Cache, project, path)
         }
@@ skipping 87 matching lines @@
 
         // If we have exceeded our threshold, report a failure.
         appended = (w.buf.Len() <= w.threshold)
         if appended {
                 w.count++
         }
         return
 }
 
 func (w *rowWriter) flush(ctx context.Context, raw btTable, index types.MessageIndex,
-        project config.ProjectName, path types.StreamPath) (int, error) {
+        project cfgtypes.ProjectName, path types.StreamPath) (int, error) {
         flushCount := w.count
         if flushCount == 0 {
                 return 0, nil
         }
 
         // Write the current set of buffered rows to the table. Index on the LAST
         // row index.
         lastIndex := int64(index) + int64(flushCount) - 1
         rk := newRowKey(string(project), string(path), lastIndex, int64(w.count))
 
         log.Fields{
                 "rowKey":    rk,
                 "project":   project,
                 "path":      path,
                 "index":     index,
                 "lastIndex": lastIndex,
                 "count":     w.count,
                 "size":      w.buf.Len(),
         }.Debugf(ctx, "Adding entries to BigTable.")
         if err := raw.putLogData(ctx, rk, w.buf.Bytes()); err != nil {
                 return 0, err
         }
 
         // Reset our buffer state.
         w.buf.Reset()
         w.count = 0
         return flushCount, nil
 }