Merge pull request #14 from NearNodeFlash/feature/persistent

Persistent Storage API

pkg/controller.go

@@ -40,6 +40,7 @@ import (
 	nnf "github.com/NearNodeFlash/nnf-ec/pkg/manager-nnf"
 	nvme "github.com/NearNodeFlash/nnf-ec/pkg/manager-nvme"
 	telemetry "github.com/NearNodeFlash/nnf-ec/pkg/manager-telemetry"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -54,6 +55,7 @@ type Options struct {
 	cli         bool // Enable CLI commands instead of binary
 	persistence bool // Enable persistent object storage; used during crash/reboot recovery
 
+	json   string // Initialize the element controller with the provided json file
 	direct string // Enable direct management of NVMe devices matching this regexp pattern
 }
 
@@ -71,6 +73,7 @@ func BindFlags(fs *flag.FlagSet) *Options {
 	fs.BoolVar(&opts.mock, "mock", opts.mock, "Enable mock (simulated) environment.")
 	fs.BoolVar(&opts.cli, "cli", opts.cli, "Enable CLI interfaces with devices, instead of raw binary.")
 	fs.BoolVar(&opts.persistence, "persistence", opts.persistence, "Enable persistent object storage (used during crash/reboot recovery)")
+	fs.StringVar(&opts.json, "json", "", "Initialize database with provided json file")
 	fs.StringVar(&opts.direct, "direct", opts.direct, "Enable direct management of NVMe block devices matching this regexp pattern. Implies Mock.")
 
 	nvme.BindFlags(fs)
@@ -106,7 +109,10 @@ func NewController(opts *Options) *ec.Controller {
 		} else {
 			nnfCtrl = nnf.NewMockNnfController(opts.persistence)
 		}
+	}
 
+	if len(opts.json) != 0 {
+		persistent.StorageProvider = persistent.NewJsonFilePersistentStorageProvider(opts.json)
 	}
 
 	return &ec.Controller{

pkg/manager-nnf/file_share.go

@@ -24,7 +24,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	sf "github.com/NearNodeFlash/nnf-ec/pkg/rfsf/pkg/models"
 )
 
@@ -134,13 +134,13 @@ type fileShareRecoveryRegistry struct {
 	storageService *StorageService
 }
 
-func NewFileShareRecoveryRegistry(s *StorageService) kvstore.Registry {
+func NewFileShareRecoveryRegistry(s *StorageService) persistent.Registry {
 	return &fileShareRecoveryRegistry{storageService: s}
 }
 
 func (r *fileShareRecoveryRegistry) Prefix() string { return fileShareRegistryPrefix }
 
-func (r *fileShareRecoveryRegistry) NewReplay(id string) kvstore.ReplayHandler {
+func (r *fileShareRecoveryRegistry) NewReplay(id string) persistent.ReplayHandler {
 	ids := strings.SplitN(id, ":", 2)
 
 	return &fileShareRecoveryReplayHandler{

pkg/manager-nnf/file_system.go

@@ -26,8 +26,7 @@ import (
 
 	server "github.com/NearNodeFlash/nnf-ec/pkg/manager-server"
 	sf "github.com/NearNodeFlash/nnf-ec/pkg/rfsf/pkg/models"
-
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 )
 
 type FileSystem struct {
@@ -162,13 +161,13 @@ type fileSystemRecoveryRegistry struct {
 	storageService *StorageService
 }
 
-func NewFileSystemRecoveryRegistry(s *StorageService) kvstore.Registry {
+func NewFileSystemRecoveryRegistry(s *StorageService) persistent.Registry {
 	return &fileSystemRecoveryRegistry{storageService: s}
 }
 
 func (*fileSystemRecoveryRegistry) Prefix() string { return fileSystemRegistryPrefix }
 
-func (r *fileSystemRecoveryRegistry) NewReplay(id string) kvstore.ReplayHandler {
+func (r *fileSystemRecoveryRegistry) NewReplay(id string) persistent.ReplayHandler {
 	return &fileSystemRecoveryReplyHandler{
 		fileSystemId:   id,
 		storageService: r.storageService,

pkg/manager-nnf/manager.go

@@ -28,18 +28,21 @@ import (
 	"github.com/google/uuid"
 	log "github.com/sirupsen/logrus"
 
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
 	ec "github.com/NearNodeFlash/nnf-ec/pkg/ec"
 	event "github.com/NearNodeFlash/nnf-ec/pkg/manager-event"
 	fabric "github.com/NearNodeFlash/nnf-ec/pkg/manager-fabric"
 	msgreg "github.com/NearNodeFlash/nnf-ec/pkg/manager-message-registry/registries"
 	nvme "github.com/NearNodeFlash/nnf-ec/pkg/manager-nvme"
 	server "github.com/NearNodeFlash/nnf-ec/pkg/manager-server"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	openapi "github.com/NearNodeFlash/nnf-ec/pkg/rfsf/pkg/common"
 	sf "github.com/NearNodeFlash/nnf-ec/pkg/rfsf/pkg/models"
 )
 
-var storageService = StorageService{}
+var storageService = StorageService{
+	id:    DefaultStorageServiceId,
+	state: sf.DISABLED_RST,
+}
 
 func NewDefaultStorageService() StorageServiceApi {
 	return NewAerService(&storageService) // Wrap the default storage service with Advanced Error Reporting capabilities
@@ -51,7 +54,7 @@ type StorageService struct {
 	health sf.ResourceHealth
 
 	config                   *ConfigFile
-	store                    *kvstore.Store
+	store                    *persistent.Store
 	serverControllerProvider server.ServerControllerProvider
 	persistentController     PersistentControllerApi
 
@@ -74,7 +77,7 @@ func (s *StorageService) OdataIdRef(ref string) sf.OdataV4IdRef {
 	return sf.OdataV4IdRef{OdataId: fmt.Sprintf("%s%s", s.OdataId(), ref)}
 }
 
-func (s *StorageService) GetStore() *kvstore.Store {
+func (s *StorageService) GetStore() *persistent.Store {
 	return s.store
 }
 
@@ -424,12 +427,12 @@ func (*StorageService) Initialize(ctrl NnfControllerInterface) error {
 
 	// Create the key-value storage database
 	{
-		s.store, err = kvstore.Open("nnf.db", false)
+		s.store, err = persistent.Open("nnf.db", false)
 		if err != nil {
 			return err
 		}
 
-		s.store.Register([]kvstore.Registry{
+		s.store.Register([]persistent.Registry{
 			NewStoragePoolRecoveryRegistry(s),
 			NewStorageGroupRecoveryRegistry(s),
 			NewFileSystemRecoveryRegistry(s),

pkg/manager-nnf/persistent.go

@@ -20,7 +20,7 @@
 package nnf
 
 import (
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -37,8 +37,9 @@ func NewDefaultPersistentController() PersistentControllerApi {
 	return &DefaultPersistentController{}
 }
 
+// Persistent Store Provider provides an interface for supplying a Key-Value Store
 type PersistentStoreProvider interface {
-	GetStore() *kvstore.Store
+	GetStore() *persistent.Store
 }
 
 // Persistent Object API provides interface for creating or updating a persistent object.
@@ -107,7 +108,7 @@ func (*DefaultPersistentController) DeletePersistentObject(obj PersistentObjectA
 	return ledger.Close(true)
 }
 
-func executePersistentObjectTransaction(ledger *kvstore.Ledger, obj PersistentObjectApi, updateFunc func() error, startingState, endingState uint32) error {
+func executePersistentObjectTransaction(ledger *persistent.Ledger, obj PersistentObjectApi, updateFunc func() error, startingState, endingState uint32) error {
 
 	data, err := obj.GenerateStateData(startingState)
 	if err != nil {

pkg/manager-nnf/storage_group.go

@@ -25,8 +25,7 @@ import (
 
 	nvme "github.com/NearNodeFlash/nnf-ec/pkg/manager-nvme"
 	server "github.com/NearNodeFlash/nnf-ec/pkg/manager-server"
-
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	sf "github.com/NearNodeFlash/nnf-ec/pkg/rfsf/pkg/models"
 )
 
@@ -156,13 +155,13 @@ type storageGroupRecoveryRegistry struct {
 	storageService *StorageService
 }
 
-func NewStorageGroupRecoveryRegistry(s *StorageService) kvstore.Registry {
+func NewStorageGroupRecoveryRegistry(s *StorageService) persistent.Registry {
 	return &storageGroupRecoveryRegistry{storageService: s}
 }
 
 func (r *storageGroupRecoveryRegistry) Prefix() string { return storageGroupRegistryPrefix }
 
-func (r *storageGroupRecoveryRegistry) NewReplay(id string) kvstore.ReplayHandler {
+func (r *storageGroupRecoveryRegistry) NewReplay(id string) persistent.ReplayHandler {
 	return &storageGroupRecoveryReplyHandler{id: id, storageService: r.storageService}
 }
 

pkg/manager-nnf/storage_pool.go

@@ -25,7 +25,7 @@ import (
 
 	"github.com/google/uuid"
 
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	nvme2 "github.com/NearNodeFlash/nnf-ec/internal/switchtec/pkg/nvme"
 	nvme "github.com/NearNodeFlash/nnf-ec/pkg/manager-nvme"
 	sf "github.com/NearNodeFlash/nnf-ec/pkg/rfsf/pkg/models"
@@ -230,13 +230,13 @@ type storagePoolRecoveryRegistry struct {
 	storageService *StorageService
 }
 
-func NewStoragePoolRecoveryRegistry(s *StorageService) kvstore.Registry {
+func NewStoragePoolRecoveryRegistry(s *StorageService) persistent.Registry {
 	return &storagePoolRecoveryRegistry{storageService: s}
 }
 
 func (*storagePoolRecoveryRegistry) Prefix() string { return storagePoolRegistryPrefix }
 
-func (r *storagePoolRecoveryRegistry) NewReplay(id string) kvstore.ReplayHandler {
+func (r *storagePoolRecoveryRegistry) NewReplay(id string) persistent.ReplayHandler {
 	return &storagePoolRecoveryReplayHandler{storageService: r.storageService, storagePool: StoragePool{id: id}}
 }
 

pkg/manager-nvme/nvme_mock_persistence.go

@@ -24,7 +24,7 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 	"github.com/NearNodeFlash/nnf-ec/internal/switchtec/pkg/nvme"
 )
 
@@ -47,20 +47,20 @@ const (
 var errDeviceNotFound = errors.New("Device Not Found")
 
 type MockNvmePersistenceManager struct {
-	store   *kvstore.Store
+	store   *persistent.Store
 	replays []mockNvmePersistenceReplay
 }
 
 // Initialize the Mock NVMe Persistent Manager - This opens the key-value store for access and registers
 // the Mock NVMe Persistence Registry to handle any Replays in the database.
 func (mgr *MockNvmePersistenceManager) initialize() (err error) {
 
-	mgr.store, err = kvstore.Open("mock.db", false)
+	mgr.store, err = persistent.Open("mock.db", false)
 	if err != nil {
 		panic(err)
 	}
 
-	mgr.store.Register([]kvstore.Registry{newMockNvmePersistenceRegistry(mgr)})
+	mgr.store.Register([]persistent.Registry{newMockNvmePersistenceRegistry(mgr)})
 
 	if err := mgr.store.Replay(); err != nil {
 		panic(err)
@@ -202,15 +202,15 @@ type mockNvmePersistenceRegistry struct {
 	mgr *MockNvmePersistenceManager
 }
 
-func newMockNvmePersistenceRegistry(mgr *MockNvmePersistenceManager) kvstore.Registry {
+func newMockNvmePersistenceRegistry(mgr *MockNvmePersistenceManager) persistent.Registry {
 	return &mockNvmePersistenceRegistry{mgr: mgr}
 }
 
 func (reg *mockNvmePersistenceRegistry) Prefix() string {
 	return mockNvmePersistenceRegistryPrefix
 }
 
-func (reg *mockNvmePersistenceRegistry) NewReplay(id string) kvstore.ReplayHandler {
+func (reg *mockNvmePersistenceRegistry) NewReplay(id string) persistent.ReplayHandler {
 	reg.mgr.replays = append(reg.mgr.replays, mockNvmePersistenceReplay{id: id})
 	return &reg.mgr.replays[len(reg.mgr.replays)-1]
 }

internal/kvstore/debug/kvdebug.go → pkg/persistent/debug/kvdebug.go

@@ -23,21 +23,27 @@ import (
 	"flag"
 	"fmt"
 
-	"github.com/NearNodeFlash/nnf-ec/internal/kvstore"
+	"github.com/NearNodeFlash/nnf-ec/pkg/persistent"
 )
 
 func main() {
 	var path string
+	var json string
 	flag.StringVar(&path, "path", "nnf.db", "the kvstore database to display")
+	flag.StringVar(&json, "json", "", "json file to parse")
 	flag.Parse()
 
+	if len(json) != 0 {
+		persistent.StorageProvider = persistent.NewJsonFilePersistentStorageProvider(json)
+	}
+
 	fmt.Printf("Debug KVStore Tool. Path: '%s'\n", path)
-	store, err := kvstore.Open(path, true)
+	store, err := persistent.Open(path, true)
 	if err != nil {
 		panic(err)
 	}
 
-	store.Register([]kvstore.Registry{&debugRegistry{}})
+	store.Register([]persistent.Registry{&debugRegistry{}})
 
 	if err := store.Replay(); err != nil {
 		panic(err)
@@ -46,8 +52,10 @@ func main() {
 
 type debugRegistry struct{}
 
-func (*debugRegistry) Prefix() string                            { return "" }
-func (*debugRegistry) NewReplay(id string) kvstore.ReplayHandler { return &debugReplayHandler{id: id} }
+func (*debugRegistry) Prefix() string { return "" }
+func (*debugRegistry) NewReplay(id string) persistent.ReplayHandler {
+	return &debugReplayHandler{id: id}
+}
 
 type debugReplayHandler struct {
 	id string