Storage - move AtomicStorage to a new package

escrow/control_service_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/singnet/snet-daemon/authutils"
 	"github.com/singnet/snet-daemon/config"
+	"github.com/singnet/snet-daemon/storage"
 	"github.com/stretchr/testify/suite"
 	"math/big"
 	"strings"
@@ -82,7 +83,7 @@ func (suite *ControlServiceTestSuite) SetupSuite() {
 	println("suite.orgMetaData.GetPaymentAddress().Hex() " + suite.orgMetaData.GetPaymentAddress().Hex())
 	println("suite.receiverAddress.Hex()" + suite.receiverAddress.Hex())
 
-	memoryStorage := NewMemStorage()
+	memoryStorage := storage.NewMemStorage()
 	suite.storage = NewPaymentChannelStorage(memoryStorage)
 	suite.paymentStorage = NewPaymentStorage(memoryStorage)
 	suite.channelService = NewPaymentChannelService(

escrow/escrow_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/singnet/snet-daemon/config"
+	"github.com/singnet/snet-daemon/storage"
 	"math/big"
 	"testing"
 
@@ -85,7 +86,7 @@ type PaymentChannelServiceSuite struct {
 	signerAddress      common.Address
 	recipientAddress   common.Address
 	mpeContractAddress common.Address
-	memoryStorage      *memoryStorage
+	memoryStorage      *storage.MemoryStorage
 	storage            *PaymentChannelStorage
 	paymentStorage     *PaymentStorage
 
@@ -99,7 +100,7 @@ func (suite *PaymentChannelServiceSuite) SetupSuite() {
 	suite.signerAddress = crypto.PubkeyToAddress(suite.signerPrivateKey.PublicKey)
 	suite.recipientAddress = crypto.PubkeyToAddress(GenerateTestPrivateKey().PublicKey)
 	suite.mpeContractAddress = blockchain.HexToAddress("0xf25186b5081ff5ce73482ad761db0eb0d25abfbf")
-	suite.memoryStorage = NewMemStorage()
+	suite.memoryStorage = storage.NewMemStorage()
 	suite.storage = NewPaymentChannelStorage(suite.memoryStorage)
 	suite.paymentStorage = NewPaymentStorage(suite.memoryStorage)
 

etcddb/etcddb_test.go → escrow/etcddb_test.go

@@ -1,10 +1,13 @@
-package etcddb
+package escrow
 
 import (
 	"context"
 	"fmt"
 	"github.com/singnet/snet-daemon/blockchain"
-	"github.com/singnet/snet-daemon/escrow"
+	"github.com/singnet/snet-daemon/config"
+	"github.com/singnet/snet-daemon/etcddb"
+	"github.com/singnet/snet-daemon/storage"
+	"github.com/spf13/viper"
 	"math/big"
 	"os"
 	"strconv"
@@ -20,8 +23,8 @@ import (
 
 type EtcdTestSuite struct {
 	suite.Suite
-	client   *EtcdClient
-	server   *EtcdServer
+	client   *etcddb.EtcdClient
+	server   *etcddb.EtcdServer
 	metaData *blockchain.OrganizationMetaData
 }
 
@@ -55,7 +58,7 @@ func (suite *EtcdTestSuite) BeforeTest(suiteName string, testName string) {
 
 	t := suite.T()
 	vip := readConfig(t, confJSON)
-	server, err := GetEtcdServerFromVip(vip)
+	server, err := etcddb.GetEtcdServerFromVip(vip)
 
 	assert.Nil(t, err)
 	assert.NotNil(t, server)
@@ -64,17 +67,34 @@ func (suite *EtcdTestSuite) BeforeTest(suiteName string, testName string) {
 	err = server.Start()
 	assert.Nil(t, err)
 
-	client, err := NewEtcdClientFromVip(vip, suite.metaData)
+	client, err := etcddb.NewEtcdClientFromVip(vip, suite.metaData)
 
 	assert.Nil(t, err)
 	assert.NotNil(t, client)
 	suite.client = client
 
 }
+func readConfig(t *testing.T, configJSON string) (vip *viper.Viper) {
+	vip = viper.New()
+	config.SetDefaultFromConfig(vip, config.Vip())
+
+	err := config.ReadConfigFromJsonString(vip, configJSON)
+	assert.Nil(t, err)
+	return
+}
+
+func removeWorkDir(t *testing.T, workDir string) {
+
+	dir, err := os.Getwd()
+	assert.Nil(t, err)
+
+	err = os.RemoveAll(dir + "/" + workDir)
+	assert.Nil(t, err)
+}
 
 func (suite *EtcdTestSuite) AfterTest(suiteName string, testName string) {
 
-	workDir := suite.server.conf.DataDir
+	workDir := suite.server.GetConf().DataDir
 	defer removeWorkDir(suite.T(), workDir)
 
 	if suite.client != nil {
@@ -198,13 +218,13 @@ func (suite *EtcdTestSuite) TestEtcdTransaction() {
 	assertGet(suite, key2, expect2)
 
 	ok, err := client.Transaction(
-		[]EtcdKeyValue{
-			EtcdKeyValue{key: key1, value: expect1},
-			EtcdKeyValue{key: key2, value: expect2},
+		[]etcddb.EtcdKeyValue{
+			etcddb.NewEtcdKeyValue(key1, expect1),
+			etcddb.NewEtcdKeyValue(key2, expect2),
 		},
-		[]EtcdKeyValue{
-			EtcdKeyValue{key: key2, value: update2},
-			EtcdKeyValue{key: key3, value: update3},
+		[]etcddb.EtcdKeyValue{
+			etcddb.NewEtcdKeyValue(key2, update2),
+			etcddb.NewEtcdKeyValue(key3, update3),
 		},
 	)
 	assert.Nil(t, err)
@@ -215,13 +235,13 @@ func (suite *EtcdTestSuite) TestEtcdTransaction() {
 	assertGet(suite, key3, update3)
 
 	ok, err = client.Transaction(
-		[]EtcdKeyValue{
-			EtcdKeyValue{key: key1, value: expect1},
-			EtcdKeyValue{key: key2, value: expect2},
+		[]etcddb.EtcdKeyValue{
+			etcddb.NewEtcdKeyValue(key1, expect1),
+			etcddb.NewEtcdKeyValue(key2, expect2),
 		},
-		[]EtcdKeyValue{
-			EtcdKeyValue{key: key2, value: update2},
-			EtcdKeyValue{key: key3, value: update3},
+		[]etcddb.EtcdKeyValue{
+			etcddb.NewEtcdKeyValue(key2, update2),
+			etcddb.NewEtcdKeyValue(key3, update3),
 		},
 	)
 	assert.Nil(t, err)
@@ -232,13 +252,13 @@ func (suite *EtcdTestSuite) TestEtcdTransaction() {
 	assertGet(suite, key3, update3)
 
 	ok, err = client.Transaction(
-		[]EtcdKeyValue{
-			EtcdKeyValue{key: key1, value: expect1},
-			EtcdKeyValue{key: key2, value: update2},
-			EtcdKeyValue{key: key3, value: update3},
+		[]etcddb.EtcdKeyValue{
+			etcddb.NewEtcdKeyValue(key1, expect1),
+			etcddb.NewEtcdKeyValue(key2, update2),
+			etcddb.NewEtcdKeyValue(key3, update3),
 		},
-		[]EtcdKeyValue{
-			EtcdKeyValue{key: key2, value: expect2},
+		[]etcddb.EtcdKeyValue{
+			etcddb.NewEtcdKeyValue(key2, expect2),
 		},
 	)
 	assert.Nil(t, err)
@@ -306,8 +326,8 @@ func (suite *EtcdTestSuite) TestPutIfAbsentTransactionFailsAfterConcurrentPut()
 	assert.Nil(t, err)
 
 	// then
-	ok, err = client.CompleteTransaction(transaction, []escrow.KeyValueData{
-		escrow.KeyValueData{
+	ok, err = client.CompleteTransaction(transaction, []storage.KeyValueData{
+		storage.KeyValueData{
 			Key:     key,
 			Value:   "transaction-value",
 			Present: true,
@@ -332,7 +352,7 @@ func (suite *EtcdTestSuite) TestEtcdMutex() {
 
 	runWithLock := func(i int) {
 
-		client, err := NewEtcdClient(suite.metaData)
+		client, err := etcddb.NewEtcdClient(suite.metaData)
 		assert.Nil(t, err)
 		defer client.Close()
 
@@ -396,42 +416,33 @@ func getKeyValuesWithPrefix(keyPrefix string, valuePrefix string, count int) (ke
 	return
 }
 
-func removeWorkDir(t *testing.T, workDir string) {
-
-	dir, err := os.Getwd()
-	assert.Nil(t, err)
-
-	err = os.RemoveAll(dir + "/" + workDir)
-	assert.Nil(t, err)
-}
-
 func (suite *EtcdTestSuite) TestExecuteTransaction() {
 	t := suite.T()
 
 	channelId := big.NewInt(1)
 	price := big.NewInt(2)
-	storage := escrow.NewPrepaidStorage(suite.client)
-	service := escrow.NewPrePaidService(storage, nil, func() (bytes [32]byte, e error) {
+	storage := NewPrepaidStorage(suite.client)
+	service := NewPrePaidService(storage, nil, func() (bytes [32]byte, e error) {
 		return [32]byte{123}, nil
 	})
 
-	err := service.UpdateUsage(channelId, big.NewInt(10), escrow.PLANNED_AMOUNT)
+	err := service.UpdateUsage(channelId, big.NewInt(10), PLANNED_AMOUNT)
 	assert.Nil(t, err)
-	value, ok, err := service.GetUsage(escrow.PrePaidDataKey{ChannelID: channelId, UsageType: escrow.PLANNED_AMOUNT})
+	value, ok, err := service.GetUsage(PrePaidDataKey{ChannelID: channelId, UsageType: PLANNED_AMOUNT})
 	assert.Nil(t, err)
 	assert.True(t, ok)
 	assert.Equal(t, value.Amount, big.NewInt(10))
 
-	err = service.UpdateUsage(channelId, price, escrow.USED_AMOUNT)
+	err = service.UpdateUsage(channelId, price, USED_AMOUNT)
 	assert.Nil(t, err)
-	value, ok, err = service.GetUsage(escrow.PrePaidDataKey{ChannelID: channelId, UsageType: escrow.USED_AMOUNT})
+	value, ok, err = service.GetUsage(PrePaidDataKey{ChannelID: channelId, UsageType: USED_AMOUNT})
 	assert.Nil(t, err)
 	assert.True(t, ok)
 	assert.Equal(t, value.Amount, price)
 
-	err = service.UpdateUsage(channelId, price, escrow.REFUND_AMOUNT)
+	err = service.UpdateUsage(channelId, price, REFUND_AMOUNT)
 	assert.Nil(t, err)
-	value, ok, err = service.GetUsage(escrow.PrePaidDataKey{ChannelID: channelId, UsageType: escrow.REFUND_AMOUNT})
+	value, ok, err = service.GetUsage(PrePaidDataKey{ChannelID: channelId, UsageType: REFUND_AMOUNT})
 	assert.Nil(t, err)
 	assert.True(t, ok)
 	assert.Equal(t, value.Amount, price)

escrow/free_call_payment_handler_test.go

@@ -5,6 +5,7 @@ import (
 	"crypto/ecdsa"
 	"fmt"
 	"github.com/singnet/snet-daemon/blockchain"
+	"github.com/singnet/snet-daemon/storage"
 	"math/big"
 	"strconv"
 	"testing"
@@ -27,7 +28,7 @@ type FreeCallPaymentHandlerTestSuite struct {
 	privateKey     *ecdsa.PrivateKey
 	key            *FreeCallUserKey
 	data           *FreeCallUserData
-	memoryStorage  *memoryStorage
+	memoryStorage  *storage.MemoryStorage
 	storage        *FreeCallUserStorage
 	metadata       *blockchain.ServiceMetadata
 }
@@ -40,11 +41,11 @@ func (suite *FreeCallPaymentHandlerTestSuite) getKey(userId string) *FreeCallUse
 func (suite *FreeCallPaymentHandlerTestSuite) SetupSuite() {
 
 	suite.privateKey = GenerateTestPrivateKey()
-	suite.memoryStorage = NewMemStorage()
+	suite.memoryStorage = storage.NewMemStorage()
 	suite.storage = NewFreeCallUserStorage(suite.memoryStorage)
 	orgMetadata, _ := blockchain.InitOrganizationMetaDataFromJson(testJsonOrgGroupData)
 	suite.metadata, _ = blockchain.InitServiceMetaDataFromJson(testJsonData)
-	suite.data = &FreeCallUserData{FreeCallsMade:12,UserId:"user1"}
+	suite.data = &FreeCallUserData{FreeCallsMade: 12, UserId: "user1"}
 	suite.key = suite.getKey("user1")
 	suite.paymentHandler = freeCallPaymentHandler{
 		orgMetadata:     orgMetadata,

escrow/free_call_state_service_test.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/singnet/snet-daemon/blockchain"
 	"github.com/singnet/snet-daemon/config"
+	"github.com/singnet/snet-daemon/storage"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"math/big"
@@ -24,7 +25,7 @@ type FreeCallStateServiceSuite struct {
 	serviceMetaData          *blockchain.ServiceMetadata
 	orgMetaData              *blockchain.OrganizationMetaData
 	stateService             *FreeCallStateService
-	memoryStorage            *memoryStorage
+	memoryStorage            *storage.MemoryStorage
 	storage                  *FreeCallUserStorage
 	service                  FreeCallUserService
 	request                  *FreeCallStateRequest
@@ -49,7 +50,7 @@ func (suite *FreeCallStateServiceSuite) SetupSuite() {
 
 	suite.orgMetaData, _ = blockchain.InitOrganizationMetaDataFromJson(testJsonOrgGroupData)
 	suite.serviceMetaData, _ = blockchain.InitServiceMetaDataFromJson(testJsonData)
-	suite.memoryStorage = NewMemStorage()
+	suite.memoryStorage = storage.NewMemStorage()
 	suite.storage = NewFreeCallUserStorage(suite.memoryStorage)
 	suite.service = NewFreeCallUserService(suite.storage,
 		NewEtcdLocker(suite.memoryStorage), func() ([32]byte, error) { return suite.orgMetaData.GetGroupId(), nil },

escrow/free_call_storage.go

@@ -1,17 +1,24 @@
 package escrow
 
 import (
+	"github.com/singnet/snet-daemon/storage"
 	"reflect"
 )
 
 type FreeCallUserStorage struct {
-	delegate TypedAtomicStorage
+	delegate storage.TypedAtomicStorage
 }
 
-func NewFreeCallUserStorage(atomicStorage AtomicStorage) *FreeCallUserStorage {
-	return &FreeCallUserStorage{
-		delegate: &TypedAtomicStorageImpl{
-			atomicStorage: &PrefixedAtomicStorage{
+func NewFreeCallUserStorage(atomicStorage storage.AtomicStorage) *FreeCallUserStorage {
+	prefixedStorage := storage.NewPrefixedAtomicStorage(atomicStorage, "/free-call-user/storage")
+	storage := storage.NewTypedAtomicStorageImpl(
+		prefixedStorage, serializeFreeCallKey, reflect.TypeOf(FreeCallUserKey{}), serialize, deserialize,
+		reflect.TypeOf(FreeCallUserData{}),
+	)
+	return &FreeCallUserStorage{delegate: storage}
+	/*	return &FreeCallUserStorage{
+		delegate: &storage.TypedAtomicStorageImpl{
+			atomicStorage: &storage.PrefixedAtomicStorage{
 				delegate:  atomicStorage,
 				keyPrefix: "/free-call-user/storage",
 			},
@@ -21,7 +28,7 @@ func NewFreeCallUserStorage(atomicStorage AtomicStorage) *FreeCallUserStorage {
 			valueDeserializer: deserialize,
 			valueType:         reflect.TypeOf(FreeCallUserData{}),
 		},
-	}
+	}*/
 }
 
 func serializeFreeCallKey(key interface{}) (serialized string, err error) {

escrow/free_call_storage_test.go

@@ -1,20 +1,21 @@
 package escrow
 
 import (
+	"github.com/singnet/snet-daemon/storage"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"testing"
 )
 
 type FreeCallUserStorageSuite struct {
 	suite.Suite
-	memoryStorage *memoryStorage
+	memoryStorage *storage.MemoryStorage
 	storage       *FreeCallUserStorage
 }
 
 func (suite *FreeCallUserStorageSuite) SetupSuite() {
 
-	suite.memoryStorage = NewMemStorage()
+	suite.memoryStorage = storage.NewMemStorage()
 
 	suite.storage = NewFreeCallUserStorage(suite.memoryStorage)
 }

escrow/free_call_test.go

@@ -1,6 +1,7 @@
 package escrow
 
 import (
+	"github.com/singnet/snet-daemon/storage"
 	"testing"
 
 	"github.com/singnet/snet-daemon/blockchain"
@@ -11,7 +12,7 @@ import (
 
 type FreeCallServiceSuite struct {
 	suite.Suite
-	memoryStorage *memoryStorage
+	memoryStorage *storage.MemoryStorage
 	storage       *FreeCallUserStorage
 	service       FreeCallUserService
 	metadata      *blockchain.ServiceMetadata
@@ -31,7 +32,7 @@ func (suite *FreeCallServiceSuite) SetupSuite() {
 	metadata, err := blockchain.InitServiceMetaDataFromJson(testJsonData)
 	assert.Nil(suite.T(), err, "Unexpected error: %v", err)
 	suite.metadata = metadata
-	suite.memoryStorage = NewMemStorage()
+	suite.memoryStorage = storage.NewMemStorage()
 	suite.groupId = [32]byte{123}
 	suite.storage = NewFreeCallUserStorage(suite.memoryStorage)
 	suite.service = NewFreeCallUserService(suite.storage,