Line data    Source code

       1             : // Copyright 2023 The LevelDB-Go and Pebble Authors. All rights reserved. Use
       2             : // of this source code is governed by a BSD-style license that can be found in
       3             : // the LICENSE file.
       4             : 
       5             : package remote
       6             : 
       7             : import (
       8             :         "context"
       9             :         "fmt"
      10             :         "io"
      11             :         "sort"
      12             : )
      13             : 
      14             : // WithLogging wraps the given Storage implementation and emits logs for various
      15             : // operations.
      16           0 : func WithLogging(wrapped Storage, logf func(fmt string, args ...interface{})) Storage {
      17           0 :         return &loggingStore{
      18           0 :                 logf:    logf,
      19           0 :                 wrapped: wrapped,
      20           0 :         }
      21           0 : }
      22             : 
      23             : // loggingStore wraps a remote.Storage implementation and emits logs of the
      24             : // operations.
      25             : type loggingStore struct {
      26             :         logf    func(fmt string, args ...interface{})
      27             :         wrapped Storage
      28             : }
      29             : 
      30             : var _ Storage = (*loggingStore)(nil)
      31             : 
      32           0 : func (l *loggingStore) Close() error {
      33           0 :         l.logf("close")
      34           0 :         return l.wrapped.Close()
      35           0 : }
      36             : 
      37             : func (l *loggingStore) ReadObject(
      38             :         ctx context.Context, objName string,
      39           0 : ) (_ ObjectReader, objSize int64, _ error) {
      40           0 :         r, size, err := l.wrapped.ReadObject(ctx, objName)
      41           0 :         l.logf("create reader for object %q: %s", objName, errOrPrintf(err, "%d bytes", size))
      42           0 :         if err != nil {
      43           0 :                 return nil, 0, err
      44           0 :         }
      45           0 :         return &loggingReader{
      46           0 :                 l:       l,
      47           0 :                 name:    objName,
      48           0 :                 wrapped: r,
      49           0 :         }, size, nil
      50             : }
      51             : 
      52             : type loggingReader struct {
      53             :         l       *loggingStore
      54             :         name    string
      55             :         wrapped ObjectReader
      56             : }
      57             : 
      58             : var _ ObjectReader = (*loggingReader)(nil)
      59             : 
      60           0 : func (l *loggingReader) ReadAt(ctx context.Context, p []byte, offset int64) error {
      61           0 :         if err := l.wrapped.ReadAt(ctx, p, offset); err != nil {
      62           0 :                 l.l.logf("read object %q at %d (length %d): error %v", l.name, offset, len(p), err)
      63           0 :                 return err
      64           0 :         }
      65           0 :         l.l.logf("read object %q at %d (length %d)", l.name, offset, len(p))
      66           0 :         return nil
      67             : }
      68             : 
      69           0 : func (l *loggingReader) Close() error {
      70           0 :         l.l.logf("close reader for %q", l.name)
      71           0 :         return l.wrapped.Close()
      72           0 : }
      73             : 
      74           0 : func (l *loggingStore) CreateObject(objName string) (io.WriteCloser, error) {
      75           0 :         l.logf("create object %q", objName)
      76           0 :         writer, err := l.wrapped.CreateObject(objName)
      77           0 :         if err != nil {
      78           0 :                 return nil, err
      79           0 :         }
      80           0 :         return &loggingWriter{
      81           0 :                 l:           l,
      82           0 :                 name:        objName,
      83           0 :                 WriteCloser: writer,
      84           0 :         }, nil
      85             : }
      86             : 
      87             : type loggingWriter struct {
      88             :         l            *loggingStore
      89             :         name         string
      90             :         bytesWritten int64
      91             :         io.WriteCloser
      92             : }
      93             : 
      94           0 : func (l *loggingWriter) Write(p []byte) (n int, err error) {
      95           0 :         n, err = l.WriteCloser.Write(p)
      96           0 :         l.bytesWritten += int64(n)
      97           0 :         return n, err
      98           0 : }
      99             : 
     100           0 : func (l *loggingWriter) Close() error {
     101           0 :         l.l.logf("close writer for %q after %d bytes", l.name, l.bytesWritten)
     102           0 :         return l.WriteCloser.Close()
     103           0 : }
     104             : 
     105           0 : func (l *loggingStore) List(prefix, delimiter string) ([]string, error) {
     106           0 :         l.logf("list (prefix=%q, delimiter=%q)", prefix, delimiter)
     107           0 :         res, err := l.wrapped.List(prefix, delimiter)
     108           0 :         if err != nil {
     109           0 :                 return nil, err
     110           0 :         }
     111           0 :         sorted := append([]string(nil), res...)
     112           0 :         sort.Strings(sorted)
     113           0 :         for _, s := range sorted {
     114           0 :                 l.logf(" - %s", s)
     115           0 :         }
     116           0 :         return res, nil
     117             : }
     118             : 
     119           0 : func (l *loggingStore) Delete(objName string) error {
     120           0 :         l.logf("delete object %q", objName)
     121           0 :         return l.wrapped.Delete(objName)
     122           0 : }
     123             : 
     124           0 : func (l *loggingStore) Size(objName string) (int64, error) {
     125           0 :         size, err := l.wrapped.Size(objName)
     126           0 :         l.logf("size of object %q: %s", objName, errOrPrintf(err, "%d", size))
     127           0 :         return size, err
     128           0 : }
     129             : 
     130           0 : func errOrPrintf(err error, format string, args ...interface{}) string {
     131           0 :         if err != nil {
     132           0 :                 return fmt.Sprintf("error: %v", err)
     133           0 :         }
     134           0 :         return fmt.Sprintf(format, args...)
     135             : }
     136             : 
     137           0 : func (l *loggingStore) IsNotExistError(err error) bool {
     138           0 :         return l.wrapped.IsNotExistError(err)
     139           0 : }