adding persistence to rpc.

pkg/rpc/configure.go

@@ -39,17 +39,29 @@ func configureTunnel() {
 
 func configureTunnelKey() {
 
-	if viper.GetString(tunKeyFlag) == "" {
+	log.I.Ln("looking for key in storage")
 
-		log.I.Ln("rpc tunnel key not provided, generating a new one.")
+	var err error
 
-		tunKey, _ = NewPrivateKey()
+	tunKey, err = o.store.GetKey()
 
-		viper.Set(tunKeyFlag, tunKey.Encode())
+	if err == nil {
+
+		log.I.Ln("rpc tunnel public key:")
+		log.I.Ln("-", tunKey.PubKey().Encode())
+
+		return
 	}
 
-	tunKey = &RPCPrivateKey{}
-	tunKey.Decode(viper.GetString(tunKeyFlag))
+	if err != ErrKeyNotExists {
+		return
+	}
+
+	log.I.Ln("key not provided, generating a new one.")
+
+	tunKey, _ = NewPrivateKey()
+
+	o.store.SetKey(tunKey)
 
 	log.I.Ln("rpc tunnel public key:")
 	log.I.Ln("-", tunKey.PubKey().Encode())

pkg/rpc/flags.go

@@ -37,12 +37,12 @@ func InitFlags(cmd *cobra.Command) {
 
 	viper.BindPFlag(tunEnableFlag, cmd.PersistentFlags().Lookup(tunEnableFlag))
 
-	cmd.Flags().StringVarP(&tunKeyRaw, tunKeyFlag, "",
-		"",
-		"the base58 encoded pre-shared key for accessing the rpc",
-	)
-
-	viper.BindPFlag(tunKeyFlag, cmd.Flags().Lookup(tunKeyFlag))
+	//cmd.Flags().StringVarP(&tunKeyRaw, tunKeyFlag, "",
+	//	"",
+	//	"the base58 encoded pre-shared key for accessing the rpc",
+	//)
+	//
+	//viper.BindPFlag(tunKeyFlag, cmd.Flags().Lookup(tunKeyFlag))
 
 	cmd.PersistentFlags().IntVarP(&tunnelPort, tunPortFlag, "",
 		tunnelPort,

pkg/rpc/keys.go

@@ -65,6 +65,10 @@ func (sk RPCPrivateKey) Encode() (key string) {
 	return
 }
 
+func (sk RPCPrivateKey) Bytes() []byte {
+	return sk[:]
+}
+
 func (sk RPCPrivateKey) HexString() string {
 	return hex.EncodeToString(sk[:])
 }
@@ -73,6 +77,10 @@ func (sk *RPCPrivateKey) Decode(key string) {
 	copy(sk[:], base58.Decode(key))
 }
 
+func (sk *RPCPrivateKey) DecodeBytes(key []byte) {
+	copy(sk[:], key)
+}
+
 func DecodePrivateKey(key string) RPCPrivateKey {
 
 	var pk RPCPrivateKey

pkg/rpc/server.go

@@ -7,6 +7,7 @@ import (
 
 var (
 	server *grpc.Server
+	o      *serverOptions
 )
 
 var (
@@ -23,10 +24,10 @@ func RunWith(r func(srv *grpc.Server), opts ...ServerOption) {
 
 	log.I.Ln("initializing the rpc server")
 
-	serverOpts := serverOptions{}
+	o = &serverOptions{false, &storeMem{}}
 
 	for _, opt := range opts {
-		opt.apply(&serverOpts)
+		opt.apply(o)
 	}
 
 	server = grpc.NewServer()

pkg/rpc/server_options.go

@@ -2,6 +2,7 @@ package rpc
 
 type serverOptions struct {
 	disableTunnel bool
+	store         Store
 }
 
 type ServerOption interface {
@@ -27,3 +28,9 @@ func WithDisableTunnel() ServerOption {
 		o.disableTunnel = true
 	})
 }
+
+func WithStore(store Store) ServerOption {
+	return newFuncServerOption(func(o *serverOptions) {
+		o.store = store
+	})
+}

pkg/rpc/store.go

@@ -0,0 +1,91 @@
+package rpc
+
+import (
+	"errors"
+	"github.com/dgraph-io/badger/v3"
+)
+
+var (
+	ErrKeyNotExists error = errors.New("key not found")
+)
+
+type Store interface {
+	Reset()
+
+	SetKey(key *RPCPrivateKey) error
+
+	GetKey() (*RPCPrivateKey, error)
+}
+
+type storeMem struct {
+	key *RPCPrivateKey
+}
+
+func (s *storeMem) Reset() {
+	s.key = nil
+}
+
+func (s *storeMem) SetKey(key *RPCPrivateKey) error {
+	s.key = key
+	return nil
+}
+
+func (s *storeMem) GetKey() (*RPCPrivateKey, error) {
+
+	if s.key == nil {
+		return nil, ErrKeyNotExists
+	}
+
+	if s.key.IsZero() {
+		return nil, ErrKeyNotExists
+	}
+
+	return s.key, nil
+}
+
+type BadgerStore struct {
+	*badger.DB
+}
+
+func (s *BadgerStore) Reset() {
+
+	s.Update(func(txn *badger.Txn) error {
+		txn.Delete([]byte(tunKeyFlag))
+
+		return nil
+	})
+}
+
+func (s *BadgerStore) SetKey(key *RPCPrivateKey) error {
+
+	s.Update(func(txn *badger.Txn) error {
+		err := txn.Set([]byte(tunKeyFlag), key.Bytes())
+		return err
+	})
+
+	return nil
+}
+
+func (s *BadgerStore) GetKey() (*RPCPrivateKey, error) {
+
+	var err error
+	var item *badger.Item
+
+	err = s.View(func(txn *badger.Txn) error {
+		item, err = txn.Get([]byte(tunKeyFlag))
+		return err
+	})
+
+	if err == badger.ErrKeyNotFound {
+		return nil, ErrKeyNotExists
+	}
+
+	var key RPCPrivateKey
+
+	err = item.Value(func(val []byte) error {
+		key.DecodeBytes(val)
+		return nil
+	})
+
+	return &key, err
+}

pkg/seed/server.go

@@ -63,13 +63,11 @@ func Run(ctx context.Context) {
 	// RPC
 	//
 
-	//
-	// Ready!
-	//
-
 	go rpc.RunWith(func(srv *grpc.Server) {
 		chat.RegisterChatServiceServer(srv, &chat.Server{})
-	})
+	},
+		rpc.WithStore(&rpc.BadgerStore{storage.DB()}),
+	)
 
 	select {
 	case err := <-rpc.WhenStartFailed():
@@ -83,6 +81,10 @@ func Run(ctx context.Context) {
 		return
 	}
 
+	//
+	// Ready!
+	//
+
 	log.I.Ln("seed is ready")
 	isReadyChan <- true
 

pkg/storage/flags.go

@@ -25,7 +25,7 @@ func InitFlags(cmd *cobra.Command) {
 
 	cmd.Flags().StringVarP(&storeEncryptionKey, storeKeyFlag, "",
 		"",
-		"the key required to unlock storage",
+		"the key required to unlock storage (NOT recommended)",
 	)
 
 	viper.BindPFlag(storeKeyFlag, cmd.Flags().Lookup(storeKeyFlag))

pkg/storage/service.go

@@ -119,3 +119,7 @@ func View(fn func(txn *badger.Txn) error) error {
 func Update(fn func(txn *badger.Txn) error) error {
 	return db.Update(fn)
 }
+
+func DB() *badger.DB {
+	return db
+}