[errors] Greatly simplify common/errors package.

logdog/common/storage/archive/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 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 98 matching lines @@
 
         switch err := s.getLogEntriesIter(st, cb); errors.Unwrap(err) {
         case nil, io.EOF:
                 // We hit the end of our log stream.
                 return nil
 
         case cloudStorage.ErrObjectNotExist, cloudStorage.ErrBucketNotExist:
                 return storage.ErrDoesNotExist
 
         default:
-                return errors.Annotate(err).Reason("failed to read log stream").Err()
+                return errors.Annotate(err, "failed to read log stream").Err()
         }
 }
 
 // getLogEntriesImpl retrieves log entries from archive until complete.
 func (s *storageImpl) getLogEntriesIter(st *getStrategy, cb storage.GetCallback) error {
         // Get our maximum byte limit. If we are externally constrained via MaxBytes,
         // apply that limit too.
         // Get an archive reader.
         var (
                 offset = st.startOffset
                 length = st.length()
         )
 
         log.Fields{
                 "offset": offset,
                 "length": length,
                 "path":   s.Stream,
         }.Debugf(s, "Creating stream reader for range.")
         storageReader, err := s.Client.NewReader(s.Stream, int64(offset), length)
         if err != nil {
                 log.WithError(err).Errorf(s, "Failed to create stream Reader.")
-                return errors.Annotate(err).Reason("failed to create stream Reader").Err()
+                return errors.Annotate(err, "failed to create stream Reader").Err()
         }
         defer func() {
                 if tmpErr := storageReader.Close(); tmpErr != nil {
                         // (Non-fatal)
                         log.WithError(tmpErr).Warningf(s, "Error closing stream Reader.")
                 }
         }()
 
         // Count how many bytes we've read.
         cr := iotools.CountingReader{Reader: storageReader}
 
         // Iteratively update our strategy's start offset each time we read a complete
         // frame.
         var (
                 rio       = recordio.NewReader(&cr, maxStreamRecordSize)
                 buf       bytes.Buffer
                 remaining = st.count
         )
         for {
                 // Reset the count so we know how much we read for this frame.
                 cr.Count = 0
 
                 sz, r, err := rio.ReadFrame()
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to read frame").Err()
+                        return errors.Annotate(err, "failed to read frame").Err()
                 }
 
                 buf.Reset()
                 buf.Grow(int(sz))
 
                 switch amt, err := buf.ReadFrom(r); {
                 case err != nil:
                         log.Fields{
                                 log.ErrorKey:  err,
                                 "frameOffset": offset,
                                 "frameSize":   sz,
                         }.Errorf(s, "Failed to read frame data.")
-                        return errors.Annotate(err).Reason("failed to read frame data").Err()
+                        return errors.Annotate(err, "failed to read frame data").Err()
 
                 case amt != sz:
                         // If we didn't buffer the complete frame, we hit a premature EOF.
-                        return errors.Annotate(io.EOF).Reason("incomplete frame read").Err()
+                        return errors.Annotate(io.EOF, "incomplete frame read").Err()
                 }
 
                 // If we read from offset 0, the first frame will be the log stream's
                 // descriptor, which we can discard.
                 discardFrame := (offset == 0)
                 offset += uint64(cr.Count)
                 if discardFrame {
                         continue
                 }
 
                 // Punt this log entry to our callback, if appropriate.
                 entry := storage.MakeEntry(buf.Bytes(), -1)
                 switch idx, err := entry.GetStreamIndex(); {
                 case err != nil:
                         log.Fields{
                                 log.ErrorKey:  err,
                                 "frameOffset": offset,
                                 "frameSize":   sz,
                         }.Errorf(s, "Failed to get log entry index.")
-                        return errors.Annotate(err).Reason("failed to get log entry index").Err()
+                        return errors.Annotate(err, "failed to get log entry index").Err()
 
                 case idx < st.startIndex:
                         // Skip this entry, as it's before the first requested entry.
                         continue
                 }
 
                 // We want to punt this entry, but we also want to re-use our Buffer. Clone
                 // its data so it is independent.
                 entry.D = make([]byte, len(entry.D))
                 copy(entry.D, buf.Bytes())
@@ skipping 107 matching lines @@
                 if indexData != nil {
                         cached = true
                 }
         }
 
         if indexData == nil {
                 // No cache, or no cached entry. Load from storage.
                 r, err := client.NewReader(path, 0, -1)
                 if err != nil {
                         log.WithError(err).Errorf(c, "Failed to create index Reader.")
-                        return nil, errors.Annotate(err).Reason("failed to create index Reader").Err()
+                        return nil, errors.Annotate(err, "failed to create index Reader").Err()
                 }
                 defer func() {
                         if err := r.Close(); err != nil {
                                 log.WithError(err).Warningf(c, "Error closing index Reader.")
                         }
                 }()
 
                 if indexData, err = ioutil.ReadAll(r); err != nil {
                         log.WithError(err).Errorf(c, "Failed to read index.")
-                        return nil, errors.Annotate(err).Reason("failed to read index").Err()
+                        return nil, errors.Annotate(err, "failed to read index").Err()
                 }
         }
 
         index := logpb.LogIndex{}
         if err := proto.Unmarshal(indexData, &index); err != nil {
                 log.WithError(err).Errorf(c, "Failed to unmarshal index.")
-                return nil, errors.Annotate(err).Reason("failed to unmarshal index").Err()
+                return nil, errors.Annotate(err, "failed to unmarshal index").Err()
         }
 
         // If the index is valid, but wasn't cached previously, then cache it.
         if cache != nil && !cached {
                 putCachedLogIndexData(c, cache, path, indexData)
         }
 
         return &index, nil
 }
 
@@ skipping 109 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
 }