Fix GS client breakage, remove offset hacks.

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.
 //      - Storage methods ignore the supplied Path argument, instead opting for
 //        the archive configured in its Options.
 package archive
 
 import (
         "bytes"
+        "encoding/hex"
         "errors"
+        "fmt"
         "io"
         "io/ioutil"
         "sort"
         "strings"
         "sync"
 
         "golang.org/x/net/context"
 
         "github.com/golang/protobuf/proto"
         "github.com/luci/luci-go/common/gcloud/gs"
@@ skipping 70 matching lines @@
 
 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 {
         idx, err := s.getIndex()
         if err != nil {
                 return err
         }
 
+        fmt.Println("GOT INDEX:", proto.MarshalTextString(idx))
+
         // Identify the byte offsets that we want to fetch from the entries stream.
         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,
@@ skipping 36 matching lines @@
                 buf.Reset()
                 buf.Grow(int(sz))
                 if _, err := buf.ReadFrom(r); err != nil {
                         log.Fields{
                                 log.ErrorKey: err,
                                 "offset":     offset,
                                 "frameSize":  sz,
                         }.Errorf(s, "Failed to read frame data.")
                         return err
                 }
+                fmt.Println(hex.EncodeToString(buf.Bytes()))
                 if err := proto.Unmarshal(buf.Bytes(), &le); err != nil {
                         log.Fields{
                                 log.ErrorKey: err,
                                 "offset":     offset,
                                 "frameSize":  sz,
                         }.Errorf(s, "Failed to unmarshal log data.")
                         return err
                 }
 
                 idx := types.MessageIndex(le.StreamIndex)
@@ skipping 152 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
 }