Add crud.BackingStore (#176)

* Add crud.BackingStore

BackingStore is a utility for people developing CRUD stores that makes
it easier for them to do late binding / initialization when the
list/save/delete/read methods are called, instead of in the constructor,
when you may not be ready to connect to databases, plugins, etc or returning errors.

Signed-off-by: Carolyn Van Slyck <carolyn.vanslyck@microsoft.com>

* Finish comment sentence

Signed-off-by: Carolyn Van Slyck <carolyn.vanslyck@microsoft.com>

* Incorporate review feedback

Signed-off-by: Carolyn Van Slyck <carolyn.vanslyck@microsoft.com>

* Take into account item type in the backing store

Now that #175 has been merged into master, update BackingStore to
account for bucketing by item type (credentials/claims).

Signed-off-by: Carolyn Van Slyck <carolyn.vanslyck@microsoft.com>

Author: carolynvs-msft

claim/claimstore.go

@@ -3,25 +3,27 @@ package claim
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 
 	"github.com/cnabio/cnab-go/utils/crud"
 )
 
+// ItemType is the location in the backing store where claims are persisted.
 const ItemType = "claims"
 
 // ErrClaimNotFound represents a claim not found in claim storage
 var ErrClaimNotFound = errors.New("Claim does not exist")
 
 // Store is a persistent store for claims.
 type Store struct {
-	backingStore crud.Store
+	backingStore *crud.BackingStore
 }
 
 // NewClaimStore creates a persistent store for claims using the specified
 // backing key-blob store.
-func NewClaimStore(backingStore crud.Store) Store {
+func NewClaimStore(store crud.Store) Store {
 	return Store{
-		backingStore: backingStore,
+		backingStore: crud.NewBackingStore(store),
 	}
 }
 
@@ -54,22 +56,23 @@ func (s Store) Read(name string) (Claim, error) {
 	return claim, err
 }
 
-// ReadAll retrieves all the claims
+// ReadAll retrieves all of the claims.
 func (s Store) ReadAll() ([]Claim, error) {
-	claims := make([]Claim, 0)
-
-	list, err := s.backingStore.List(ItemType)
+	results, err := s.backingStore.ReadAll(ItemType)
 	if err != nil {
-		return claims, err
+		return nil, err
 	}
 
-	for _, c := range list {
-		cl, err := s.Read(c)
+	claims := make([]Claim, len(results))
+	for i, bytes := range results {
+		var claim Claim
+		err = json.Unmarshal(bytes, &claim)
 		if err != nil {
-			return claims, err
+			return nil, fmt.Errorf("error unmarshaling claim: %v", err)
 		}
-		claims = append(claims, cl)
+		claims[i] = claim
 	}
+
 	return claims, nil
 }
 

credentials/credstore.go

@@ -0,0 +1,81 @@
+package credentials
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/cnabio/cnab-go/utils/crud"
+)
+
+// ItemType is the location in the backing store where credentials are persisted.
+const ItemType = "credentials"
+
+// ErrNotFound represents a credential set not found in storage
+var ErrNotFound = errors.New("Credential set does not exist")
+
+// Store is a persistent store for credential sets.
+type Store struct {
+	backingStore *crud.BackingStore
+}
+
+// NewCredentialStore creates a persistent store for credential sets using the specified
+// backing key-blob store.
+func NewCredentialStore(store crud.Store) Store {
+	return Store{
+		backingStore: crud.NewBackingStore(store),
+	}
+}
+
+// List lists the names of the stored credential sets.
+func (s Store) List() ([]string, error) {
+	return s.backingStore.List(ItemType)
+}
+
+// Save a credential set. Any previous version of the credential set is overwritten.
+func (s Store) Save(cred CredentialSet) error {
+	bytes, err := json.MarshalIndent(cred, "", "  ")
+	if err != nil {
+		return err
+	}
+	return s.backingStore.Save(ItemType, cred.Name, bytes)
+}
+
+// Read loads the credential set with the given name from the store.
+func (s Store) Read(name string) (CredentialSet, error) {
+	bytes, err := s.backingStore.Read(ItemType, name)
+	if err != nil {
+		if err == crud.ErrRecordDoesNotExist {
+			return CredentialSet{}, ErrNotFound
+		}
+		return CredentialSet{}, err
+	}
+	credset := CredentialSet{}
+	err = json.Unmarshal(bytes, &credset)
+	return credset, err
+}
+
+// ReadAll retrieves all the credential sets.
+func (s Store) ReadAll() ([]CredentialSet, error) {
+	results, err := s.backingStore.ReadAll(ItemType)
+	if err != nil {
+		return nil, err
+	}
+
+	creds := make([]CredentialSet, len(results))
+	for i, bytes := range results {
+		var cs CredentialSet
+		err = json.Unmarshal(bytes, &cs)
+		if err != nil {
+			return nil, fmt.Errorf("error unmarshaling credential set: %v", err)
+		}
+		creds[i] = cs
+	}
+
+	return creds, nil
+}
+
+// Delete deletes a credential set from the store.
+func (s Store) Delete(name string) error {
+	return s.backingStore.Delete(ItemType, name)
+}

utils/crud/backingstore.go

@@ -0,0 +1,115 @@
+package crud
+
+var _ Store = &BackingStore{}
+
+// BackingStore wraps another store that may have Connect/Close methods that
+// need to be called.
+// - Connect is called before a method when the connection is closed.
+// - Close is called after each method when AutoClose is true (default).
+type BackingStore struct {
+	AutoClose    bool
+	opened       bool
+	backingStore Store
+}
+
+func NewBackingStore(store Store) *BackingStore {
+	return &BackingStore{
+		AutoClose:    true,
+		backingStore: store,
+	}
+}
+
+func (s *BackingStore) Connect() error {
+	if s.opened {
+		return nil
+	}
+	if connectable, ok := s.backingStore.(HasConnect); ok {
+		s.opened = true
+		return connectable.Connect()
+	}
+	return nil
+}
+
+func (s *BackingStore) Close() error {
+	if closable, ok := s.backingStore.(HasClose); ok {
+		s.opened = false
+		return closable.Close()
+	}
+	return nil
+}
+
+func (s *BackingStore) autoClose() error {
+	if s.opened && s.AutoClose {
+		return s.Close()
+	}
+	return nil
+}
+
+func (s *BackingStore) List(itemType string) ([]string, error) {
+	err := s.Connect()
+	if err != nil {
+		return nil, err
+	}
+
+	defer s.autoClose()
+
+	return s.backingStore.List(itemType)
+}
+
+func (s *BackingStore) Save(itemType string, name string, data []byte) error {
+	err := s.Connect()
+	if err != nil {
+		return err
+	}
+
+	defer s.autoClose()
+
+	return s.backingStore.Save(itemType, name, data)
+}
+
+func (s *BackingStore) Read(itemType string, name string) ([]byte, error) {
+	err := s.Connect()
+	if err != nil {
+		return nil, err
+	}
+
+	defer s.autoClose()
+
+	return s.backingStore.Read(itemType, name)
+}
+
+// ReadAll retrieves all the items.
+func (s *BackingStore) ReadAll(itemType string) ([][]byte, error) {
+	defer s.autoClose()
+
+	autoClose := s.AutoClose
+	s.AutoClose = false
+	defer func() { s.AutoClose = autoClose }()
+
+	results := make([][]byte, 0)
+	list, err := s.List(itemType)
+	if err != nil {
+		return results, err
+	}
+
+	for _, name := range list {
+		result, err := s.Read(itemType, name)
+		if err != nil {
+			return results, err
+		}
+		results = append(results, result)
+	}
+
+	return results, nil
+}
+
+func (s *BackingStore) Delete(itemType string, name string) error {
+	err := s.Connect()
+	if err != nil {
+		return err
+	}
+
+	defer s.autoClose()
+
+	return s.backingStore.Delete(itemType, name)
+}