passed project first

kv/server/raw_api.go

@@ -2,6 +2,8 @@ package server
 
 import (
 	"context"
+
+	"github.com/pingcap-incubator/tinykv/kv/storage"
 	"github.com/pingcap-incubator/tinykv/proto/pkg/kvrpcpb"
 )
 
@@ -11,26 +13,89 @@ import (
 // RawGet return the corresponding Get response based on RawGetRequest's CF and Key fields
 func (server *Server) RawGet(_ context.Context, req *kvrpcpb.RawGetRequest) (*kvrpcpb.RawGetResponse, error) {
 	// Your Code Here (1).
-	return nil, nil
+	reader, err := server.storage.Reader(req.Context)
+	if err != nil {
+		return nil, err
+	}
+	val, err := reader.GetCF(req.Cf, req.Key)
+	if err != nil {
+		return nil, err
+	}
+	resp := &kvrpcpb.RawGetResponse{
+		Value:    val,
+		NotFound: false,
+	}
+	if val == nil {
+		resp.NotFound = true
+	}
+	return resp, nil
 }
 
 // RawPut puts the target data into storage and returns the corresponding response
 func (server *Server) RawPut(_ context.Context, req *kvrpcpb.RawPutRequest) (*kvrpcpb.RawPutResponse, error) {
 	// Your Code Here (1).
 	// Hint: Consider using Storage.Modify to store data to be modified
-	return nil, nil
+	put := storage.Put{
+		Key:   req.Key,
+		Value: req.Value,
+		Cf:    req.Cf,
+	}
+	batch := storage.Modify{Data: put}
+	err := server.storage.Write(req.Context, []storage.Modify{batch})
+	if err != nil {
+		return nil, err
+
+	}
+	return &kvrpcpb.RawPutResponse{}, nil
 }
 
 // RawDelete delete the target data from storage and returns the corresponding response
 func (server *Server) RawDelete(_ context.Context, req *kvrpcpb.RawDeleteRequest) (*kvrpcpb.RawDeleteResponse, error) {
 	// Your Code Here (1).
 	// Hint: Consider using Storage.Modify to store data to be deleted
-	return nil, nil
+	del := storage.Delete{
+		Key: req.Key,
+		Cf:  req.Cf,
+	}
+	batch := storage.Modify{Data: del}
+	err := server.storage.Write(req.Context, []storage.Modify{batch})
+	if err != nil {
+		return nil, err
+	}
+	return &kvrpcpb.RawDeleteResponse{}, nil
 }
 
 // RawScan scan the data starting from the start key up to limit. and return the corresponding result
 func (server *Server) RawScan(_ context.Context, req *kvrpcpb.RawScanRequest) (*kvrpcpb.RawScanResponse, error) {
 	// Your Code Here (1).
 	// Hint: Consider using reader.IterCF
-	return nil, nil
+	reader, err := server.storage.Reader(req.Context)
+	if err != nil {
+		return nil, err
+	}
+	var Kvs []*kvrpcpb.KvPair
+	limit := req.Limit
+
+	iter := reader.IterCF(req.Cf)
+	defer iter.Close()
+
+	for iter.Seek(req.StartKey); iter.Valid(); iter.Next() {
+		item := iter.Item()
+		key := item.Key()
+		val, _ := item.Value()
+
+		Kvs = append(Kvs, &kvrpcpb.KvPair{
+			Key:   key,
+			Value: val,
+		})
+		limit--
+		if limit == 0 {
+			break
+		}
+	}
+
+	resp := &kvrpcpb.RawScanResponse{
+		Kvs: Kvs,
+	}
+	return resp, nil
 }

kv/storage/standalone_storage/standalone_storage.go

@@ -1,20 +1,35 @@
 package standalone_storage
 
 import (
+	"path"
+
+	"github.com/Connor1996/badger"
 	"github.com/pingcap-incubator/tinykv/kv/config"
 	"github.com/pingcap-incubator/tinykv/kv/storage"
+	"github.com/pingcap-incubator/tinykv/kv/util/engine_util"
 	"github.com/pingcap-incubator/tinykv/proto/pkg/kvrpcpb"
 )
 
 // StandAloneStorage is an implementation of `Storage` for a single-node TinyKV instance. It does not
 // communicate with other nodes and all data is stored locally.
 type StandAloneStorage struct {
 	// Your Data Here (1).
+	engine *engine_util.Engines
+	conf   *config.Config
 }
 
 func NewStandAloneStorage(conf *config.Config) *StandAloneStorage {
 	// Your Code Here (1).
-	return nil
+	dbPath := conf.DBPath
+	kvPath := path.Join(dbPath, "kv")
+	raftPath := path.Join(dbPath, "raft")
+	kvDB := engine_util.CreateDB(kvPath, false)
+	raftDB := engine_util.CreateDB(raftPath, true)
+
+	return &StandAloneStorage{
+		engine: engine_util.NewEngines(kvDB, raftDB, kvPath, raftPath),
+		conf:   conf,
+	}
 }
 
 func (s *StandAloneStorage) Start() error {
@@ -24,15 +39,54 @@ func (s *StandAloneStorage) Start() error {
 
 func (s *StandAloneStorage) Stop() error {
 	// Your Code Here (1).
-	return nil
+	return s.engine.Close()
 }
 
 func (s *StandAloneStorage) Reader(ctx *kvrpcpb.Context) (storage.StorageReader, error) {
 	// Your Code Here (1).
-	return nil, nil
+	txn := s.engine.Kv.NewTransaction(false)
+	return NewStandAloneStorageReader(txn), nil
+}
+
+type StandAloneStorageReader struct {
+	kvTxn *badger.Txn
+}
+
+func NewStandAloneStorageReader(txn *badger.Txn) *StandAloneStorageReader {
+	return &StandAloneStorageReader{
+		kvTxn: txn,
+	}
+}
+
+func (s *StandAloneStorageReader) GetCF(cf string, key []byte) ([]byte, error) {
+	val, err := engine_util.GetCFFromTxn(s.kvTxn, cf, key)
+	if err == badger.ErrKeyNotFound {
+		return nil, nil
+	}
+	return val, err
+}
+
+func (s *StandAloneStorageReader) IterCF(cf string) engine_util.DBIterator {
+	return engine_util.NewCFIterator(cf, s.kvTxn)
+}
+
+func (s *StandAloneStorageReader) Close() {
+	s.kvTxn.Discard()
 }
 
 func (s *StandAloneStorage) Write(ctx *kvrpcpb.Context, batch []storage.Modify) error {
 	// Your Code Here (1).
+	var err error
+	for _, m := range batch {
+		key, val, cf := m.Key(), m.Value(), m.Cf()
+		if _, ok := m.Data.(storage.Put); ok {
+			err = engine_util.PutCF(s.engine.Kv, cf, key, val)
+		} else {
+			err = engine_util.DeleteCF(s.engine.Kv, cf, key)
+		}
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }