duplicate messages send fixes

client/serverstorage.go

@@ -7,6 +7,7 @@ import (
 	"crypto/sha256"
 	"encoding/json"
 	"path/filepath"
+	"sync"
 
 	"forge.redroom.link/yves/meowlib"
 	"github.com/dgraph-io/badger"
@@ -14,30 +15,37 @@ import (
 
 type ServerStorage struct {
 	DbFile string `json:"db_file,omitempty"`
+	mu     sync.Mutex
 	db     *badger.DB
 }
 
-// Open a badger database from struct ServerStorage
+// open opens the Badger database. Caller must hold mu.
 func (ss *ServerStorage) open() error {
-
 	opts := badger.DefaultOptions(filepath.Join(GetConfig().StoragePath, GetConfig().GetIdentity().Uuid, ss.DbFile))
 	opts.Logger = nil
 	var err error
 	ss.db, err = badger.Open(opts)
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 
-// Store function StoreServer stores a server in a badger database with Server.GetUid() as key
+// close closes the Badger database. Caller must hold mu.
+func (ss *ServerStorage) close() {
+	ss.db.Close()
+}
+
+// StoreServer stores a server in the Badger database with Server.GetUid() as key.
 func (ss *ServerStorage) StoreServer(sc *Server) error {
-	err := ss.open()
-	if err != nil {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
+	return ss.storeServerLocked(sc)
+}
+
+// storeServerLocked is StoreServer without acquiring the lock. Caller must hold mu.
+func (ss *ServerStorage) storeServerLocked(sc *Server) error {
+	if err := ss.open(); err != nil {
 		return err
 	}
 	defer ss.close()
-	// first marshal the Server to bytes with protobuf
 	jsonsrv, err := json.Marshal(sc)
 	if err != nil {
 		return err
@@ -52,51 +60,56 @@ func (ss *ServerStorage) StoreServer(sc *Server) error {
 	}
 	shakey := sha256.Sum256([]byte(sc.GetServerCard().GetUid()))
 	key := shakey[:]
-	// then store it in the database
 	return ss.db.Update(func(txn *badger.Txn) error {
 		return txn.Set(key, data)
 	})
-
 }
 
-// Check if a server exists in a badger database with Server.GetUid() as key
+// ServerExists checks if a server exists in the Badger database.
 func (ss *ServerStorage) ServerExists(sc *Server) (bool, error) {
-	err := ss.open()
-	if err != nil {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
+	return ss.serverExistsLocked(sc)
+}
+
+// serverExistsLocked is ServerExists without acquiring the lock. Caller must hold mu.
+func (ss *ServerStorage) serverExistsLocked(sc *Server) (bool, error) {
+	if err := ss.open(); err != nil {
 		return false, err
 	}
 	defer ss.close()
-
 	shakey := sha256.Sum256([]byte(sc.GetServerCard().GetUid()))
 	key := shakey[:]
-	// check if key exists in badger database
-	err = ss.db.View(func(txn *badger.Txn) error {
+	err := ss.db.View(func(txn *badger.Txn) error {
 		_, err := txn.Get(key)
 		return err
-	}) // Add a comma here
-	if err != nil { // key does not exist
+	})
+	if err != nil {
 		return false, nil
 	}
 	return true, nil
 }
 
-// Store a server in a badger database with Server.GetUid() as key if it is not already there
+// StoreServerIfNotExists stores a server only if it is not already present.
 func (ss *ServerStorage) StoreServerIfNotExists(sc *Server) error {
-	exists, err := ss.ServerExists(sc)
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
+	exists, err := ss.serverExistsLocked(sc)
 	if err != nil {
 		return err
 	}
 	if !exists {
-		return ss.StoreServer(sc)
+		return ss.storeServerLocked(sc)
 	}
 	return nil
 }
 
-// LoadServer function loads a Server from a badger database with Server.GetUid() as key
+// LoadServer loads a Server from the Badger database by uid.
 func (ss *ServerStorage) LoadServer(uid string) (*Server, error) {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
 	var sc Server
-	err := ss.open()
-	if err != nil {
+	if err := ss.open(); err != nil {
 		return nil, err
 	}
 	defer ss.close()
@@ -122,10 +135,11 @@ func (ss *ServerStorage) LoadServer(uid string) (*Server, error) {
 	return &sc, err
 }
 
-// DeleteServer function deletes a Server from a badger database with Server.GetUid() as key
+// DeleteServer deletes a Server from the Badger database by uid.
 func (ss *ServerStorage) DeleteServer(uid string) error {
-	err := ss.open()
-	if err != nil {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
+	if err := ss.open(); err != nil {
 		return err
 	}
 	defer ss.close()
@@ -136,11 +150,12 @@ func (ss *ServerStorage) DeleteServer(uid string) error {
 	})
 }
 
-// LoadAllServers function loads all Servers from a badger database
+// LoadAllServers loads all Servers from the Badger database.
 func (ss *ServerStorage) LoadAllServers() ([]*Server, error) {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
 	var scs []*Server
-	err := ss.open()
-	if err != nil {
+	if err := ss.open(); err != nil {
 		return nil, err
 	}
 	defer ss.close()
@@ -173,11 +188,12 @@ func (ss *ServerStorage) LoadAllServers() ([]*Server, error) {
 	return scs, err
 }
 
-// LoadAllServers function loads all ServersCards from a badger database
+// LoadAllServerCards loads all ServerCards from the Badger database.
 func (ss *ServerStorage) LoadAllServerCards() ([]*meowlib.ServerCard, error) {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
 	var scs []*meowlib.ServerCard
-	err := ss.open()
-	if err != nil {
+	if err := ss.open(); err != nil {
 		return nil, err
 	}
 	defer ss.close()
@@ -210,11 +226,12 @@ func (ss *ServerStorage) LoadAllServerCards() ([]*meowlib.ServerCard, error) {
 	return scs, err
 }
 
-// LoadServersFromUids function loads Servers with id in []Uid parameter from a badger database
+// LoadServersFromUids loads Servers whose UIDs are in the provided slice.
 func (ss *ServerStorage) LoadServersFromUids(uids []string) ([]*Server, error) {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
 	var scs []*Server
-	err := ss.open()
-	if err != nil {
+	if err := ss.open(); err != nil {
 		return nil, err
 	}
 	defer ss.close()
@@ -248,11 +265,12 @@ func (ss *ServerStorage) LoadServersFromUids(uids []string) ([]*Server, error) {
 	return scs, err
 }
 
-// LoadServersFromUids function loads Servers with id in []Uid parameter from a badger database
+// LoadServerCardsFromUids loads ServerCards whose UIDs are in the provided slice.
 func (ss *ServerStorage) LoadServerCardsFromUids(uids []string) ([]*meowlib.ServerCard, error) {
+	ss.mu.Lock()
+	defer ss.mu.Unlock()
 	var scs []*meowlib.ServerCard
-	err := ss.open()
-	if err != nil {
+	if err := ss.open(); err != nil {
 		return nil, err
 	}
 	defer ss.close()
@@ -285,8 +303,3 @@ func (ss *ServerStorage) LoadServerCardsFromUids(uids []string) ([]*meowlib.Serv
 	})
 	return scs, err
 }
-
-// close a badger database
-func (ss *ServerStorage) close() {
-	ss.db.Close()
-}