github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/tm-db/remotedb/remotedb.go (about)

     1  package remotedb
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  
     7  	"github.com/fibonacci-chain/fbc/libs/tm-db/common"
     8  	"github.com/pkg/errors"
     9  
    10  	db "github.com/fibonacci-chain/fbc/libs/tm-db"
    11  	"github.com/fibonacci-chain/fbc/libs/tm-db/remotedb/grpcdb"
    12  	protodb "github.com/fibonacci-chain/fbc/libs/tm-db/remotedb/proto"
    13  )
    14  
    15  type RemoteDB struct {
    16  	ctx context.Context
    17  	dc  protodb.DBClient
    18  	common.PlaceHolder
    19  }
    20  
    21  func NewRemoteDB(serverAddr string, serverKey string) (*RemoteDB, error) {
    22  	return newRemoteDB(grpcdb.NewClient(serverAddr, serverKey))
    23  }
    24  
    25  func newRemoteDB(gdc protodb.DBClient, err error) (*RemoteDB, error) {
    26  	if err != nil {
    27  		return nil, err
    28  	}
    29  	return &RemoteDB{dc: gdc, ctx: context.Background()}, nil
    30  }
    31  
    32  type Init struct {
    33  	Dir  string
    34  	Name string
    35  	Type string
    36  }
    37  
    38  func (rd *RemoteDB) InitRemote(in *Init) error {
    39  	_, err := rd.dc.Init(rd.ctx, &protodb.Init{Dir: in.Dir, Type: in.Type, Name: in.Name})
    40  	return err
    41  }
    42  
    43  var _ db.DB = (*RemoteDB)(nil)
    44  
    45  // Close is a noop currently
    46  func (rd *RemoteDB) Close() error {
    47  	return nil
    48  }
    49  
    50  func (rd *RemoteDB) Delete(key []byte) error {
    51  	if _, err := rd.dc.Delete(rd.ctx, &protodb.Entity{Key: key}); err != nil {
    52  		return errors.Errorf("remoteDB.Delete: %v", err)
    53  	}
    54  	return nil
    55  }
    56  
    57  func (rd *RemoteDB) DeleteSync(key []byte) error {
    58  	if _, err := rd.dc.DeleteSync(rd.ctx, &protodb.Entity{Key: key}); err != nil {
    59  		return errors.Errorf("remoteDB.DeleteSync: %v", err)
    60  	}
    61  	return nil
    62  }
    63  
    64  func (rd *RemoteDB) Set(key, value []byte) error {
    65  	if _, err := rd.dc.Set(rd.ctx, &protodb.Entity{Key: key, Value: value}); err != nil {
    66  		return errors.Errorf("remoteDB.Set: %v", err)
    67  	}
    68  	return nil
    69  }
    70  
    71  func (rd *RemoteDB) SetSync(key, value []byte) error {
    72  	if _, err := rd.dc.SetSync(rd.ctx, &protodb.Entity{Key: key, Value: value}); err != nil {
    73  		return errors.Errorf("remoteDB.SetSync: %v", err)
    74  	}
    75  	return nil
    76  }
    77  
    78  func (rd *RemoteDB) Get(key []byte) ([]byte, error) {
    79  	res, err := rd.dc.Get(rd.ctx, &protodb.Entity{Key: key})
    80  	if err != nil {
    81  		return nil, errors.Errorf("remoteDB.Get error: %v", err)
    82  	}
    83  	return res.Value, nil
    84  }
    85  
    86  func (rd *RemoteDB) GetUnsafeValue(key []byte, processor db.UnsafeValueProcessor) (interface{}, error) {
    87  	v, err := rd.Get(key)
    88  	if err != nil {
    89  		return nil, err
    90  	}
    91  	return processor(v)
    92  }
    93  
    94  func (rd *RemoteDB) Has(key []byte) (bool, error) {
    95  	res, err := rd.dc.Has(rd.ctx, &protodb.Entity{Key: key})
    96  	if err != nil {
    97  		return false, err
    98  	}
    99  	return res.Exists, nil
   100  }
   101  
   102  func (rd *RemoteDB) ReverseIterator(start, end []byte) (db.Iterator, error) {
   103  	dic, err := rd.dc.ReverseIterator(rd.ctx, &protodb.Entity{Start: start, End: end})
   104  	if err != nil {
   105  		return nil, fmt.Errorf("RemoteDB.Iterator error: %w", err)
   106  	}
   107  	return makeReverseIterator(dic), nil
   108  }
   109  
   110  func (rd *RemoteDB) NewBatch() db.Batch {
   111  	return newBatch(rd)
   112  }
   113  
   114  // TODO: Implement Print when db.DB implements a method
   115  // to print to a string and not db.Print to stdout.
   116  func (rd *RemoteDB) Print() error {
   117  	return errors.New("remoteDB.Print: unimplemented")
   118  }
   119  
   120  func (rd *RemoteDB) Stats() map[string]string {
   121  	stats, err := rd.dc.Stats(rd.ctx, &protodb.Nothing{})
   122  	if err != nil {
   123  		panic(fmt.Sprintf("RemoteDB.Stats error: %v", err))
   124  	}
   125  	if stats == nil {
   126  		return nil
   127  	}
   128  	return stats.Data
   129  }
   130  
   131  func (rd *RemoteDB) Iterator(start, end []byte) (db.Iterator, error) {
   132  	dic, err := rd.dc.Iterator(rd.ctx, &protodb.Entity{Start: start, End: end})
   133  	if err != nil {
   134  		return nil, fmt.Errorf("RemoteDB.Iterator error: %w", err)
   135  	}
   136  	return makeIterator(dic), nil
   137  }