LogDog: Add log rendering view.

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 35 matching lines @@
 // Path parameters in requests will be ignored in favor of the Google Storage
 // URLs.
 type Options struct {
         // IndexURL is the Google Storage URL for the stream's index.
         IndexURL string
         // 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.
+        // Closing this Storage instance will close the underlying Client.
         Client gs.Client
 }
 
 type storageImpl struct {
         context.Context
         *Options
 
         streamBucket string
         streamPath   string
         indexBucket  string
         indexPath    string
 
-        indexMu     sync.Mutex
-        index       *logpb.LogIndex
-        closeClient bool
+        indexMu sync.Mutex
+        index   *logpb.LogIndex
 }
 
 // New instantiates a new Storage instance, bound to the supplied Options.
 func New(c context.Context, o Options) (storage.Storage, error) {
         s := storageImpl{
                 Context: c,
                 Options: &o,
         }
 
         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")
         }
 
         if s.Client == nil {
                 var err error
                 s.Client, err = gs.NewProdClient(c)
                 if err != nil {
                         return nil, err
                 }
-
-                s.closeClient = true
         }
 
         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.")
-                }
+        if err := s.Client.Close(); err != nil {
+                log.WithError(err).Errorf(s, "Failed to close client.")
         }
 }
 
 func (s *storageImpl) Put(*storage.PutRequest) error { return storage.ErrReadOnly }
 func (s *storageImpl) Purge(types.StreamPath) error  { return storage.ErrReadOnly }
 
 func (s *storageImpl) Get(req *storage.GetRequest, cb storage.GetCallback) error {
         idx, err := s.getIndex()
         if err != nil {
                 return err
@@ skipping 194 matching lines @@
         le := idx.Entries[startIdx]
         st.from = int64(le.Offset)
 
         // If we have a limit, and we have enough index entries to upper-bound our
         // stream based on that limit, use that.
         //
         // Note that this may overshoot if the index and/or stream is sparse. We know
         // for sure that we have one LogEntry per index entry, so that's the best we
         // can do.
         if req.Limit > 0 {
-                if ub := startIdx + req.Limit; ub < len(idx.Entries) {
+                if ub := int64(startIdx) + req.Limit; ub < int64(len(idx.Entries)) {
                         st.to = int64(idx.Entries[ub].Offset)
                 }
         }
         return &st
 }
 
 // indexEntryFor identifies the log index entry closest (<=) to the specified
 // index.
 //
 // If the first index entry is greater than our search index, -1 will be
 // returned. This should never happen in practice, though, since our index
 // construction always indexes log entry #0.
 //
 // It does this by performing a binary search over the index entries.
 func indexEntryFor(entries []*logpb.LogIndex_Entry, i types.MessageIndex) int {
         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
 }