LogDog: BigTable batching schema.

server/logdog/storage/archive/storage.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 archive implements a storage.Storage instance that retrieves logs
 // from a Google Storage archive.
 //
 // This is a special implementation of storage.Storage, and does not fully
 // conform to the API expecations. Namely:
 //      - It is read-only. Mutation methods will return storage.ErrReadOnly.
@@ skipping 40 matching lines @@
         // StreamURL is the Google Storage URL for the stream's entries.
         StreamURL string
 
         // Client is the HTTP client to use for authentication.
         //
         // Closing this Storage instance does not close the underlying Client.
         Client gs.Client
 }
 
 type storageImpl struct {
+        *Options
         context.Context
-        *Options
 
         streamBucket string
         streamPath   string
         indexBucket  string
         indexPath    string
 
         indexMu     sync.Mutex
         index       *logpb.LogIndex
         closeClient bool
 }
 
 // New instantiates a new Storage instance, bound to the supplied Options.
-func New(c context.Context, o Options) (storage.Storage, error) {
+func New(ctx context.Context, o Options) (storage.Storage, error) {
         s := storageImpl{
-                Context: c,
                 Options: &o,
+                Context: ctx,
         }
 
         s.indexBucket, s.indexPath = splitGSURL(o.IndexURL)
         if s.indexBucket == "" || s.indexPath == "" {
                 return nil, errors.New("invalid index URL")
         }
 
         s.streamBucket, s.streamPath = splitGSURL(o.StreamURL)
         if s.streamBucket == "" || s.streamPath == "" {
                 return nil, errors.New("invalid stream URL")
         }
         return &s, nil
 }
 
 func (s *storageImpl) Close() {
         if s.closeClient {
-                if err := s.Client.Close(); err != nil {
-                        log.WithError(err).Errorf(s, "Failed to close client.")
-                }
+                _ = s.Client.Close()
         }
 }
 
-func (s *storageImpl) Config(storage.Config) error   { return storage.ErrReadOnly }
-func (s *storageImpl) Put(*storage.PutRequest) error { return storage.ErrReadOnly }
+func (s *storageImpl) Config(storage.Config) error  { return storage.ErrReadOnly }
+func (s *storageImpl) Put(storage.PutRequest) error { return storage.ErrReadOnly }
 
-func (s *storageImpl) Get(req *storage.GetRequest, cb storage.GetCallback) error {
+func (s *storageImpl) Get(req storage.GetRequest, cb storage.GetCallback) error {
         idx, err := s.getIndex()
         if err != nil {
                 return err
         }
 
         // Identify the byte offsets that we want to fetch from the entries stream.
-        st := s.buildGetStrategy(req, idx)
+        st := s.buildGetStrategy(&req, idx)
         if st.lastIndex == -1 || req.Index > st.lastIndex {
                 // No records to read.
                 return nil
         }
 
         r, err := s.Client.NewReader(s.streamBucket, s.streamPath, gs.Options{
                 From: st.from,
                 To:   st.to,
         })
         if err != nil {
@@ skipping 66 matching lines @@
                 if max > 0 {
                         max--
                         if max == 0 {
                                 break
                         }
                 }
         }
         return nil
 }
 
-func (s *storageImpl) Tail(types.StreamPath) ([]byte, types.MessageIndex, error) {
+func (s *storageImpl) Tail(path types.StreamPath) ([]byte, types.MessageIndex, error) {
         idx, err := s.getIndex()
         if err != nil {
                 return nil, 0, err
         }
 
         // Get the offset of the last record.
         if len(idx.Entries) == 0 {
                 return nil, 0, nil
         }
         lle := idx.Entries[len(idx.Entries)-1]
@@ skipping 119 matching lines @@
         ui := uint64(i)
         s := sort.Search(len(entries), func(i int) bool {
                 return entries[i].StreamIndex > ui
         })
 
         // The returned index is the one immediately after the index that we want. If
         // our search returned 0, the first index entry is > our search entry, and we
         // will return nil.
         return s - 1
 }