adds transaction lock manager

Author: fighting-dreamer

appcontext/dependencies.go

@@ -6,27 +6,37 @@ import (
 	local_repo "nipun.io/brew_machine/repository/local"
 	"nipun.io/brew_machine/service"
 	local_service "nipun.io/brew_machine/service/local"
+	"sync"
 )
 
 type Instance struct {
-	BeverageRepository   repository.BeverageRepository
-	IngredientRepository repository.IngredientRepository
-	BeverageManager      service.BeverageManager
-	IngredientManager    service.IngredientManager
-	DispenserService     service.DispenserService
+	BeverageRepository     repository.BeverageRepository
+	IngredientRepository   repository.IngredientRepository
+	BeverageManager        service.BeverageManager
+	IngredientManager      service.IngredientManager
+	DispenserService       service.DispenserService
+	TransactionLockManager service.TransactionLockManager
 }
 
 var AppDependencies *Instance
 
 func LoadDependencies() {
 	AppDependencies = &Instance{}
+	AppDependencies.addTransactionLockManager()
 	AppDependencies.addBeverageRepository()
 	AppDependencies.addIngredientRepository()
 	AppDependencies.addBeverageManager()
 	AppDependencies.addIngredientManager()
 	AppDependencies.addDispenserService()
 }
 
+func (dependencies *Instance) addTransactionLockManager() {
+	dependencies.TransactionLockManager = &local_service.TransactionLockManager{
+		KeeperState: map[string]string{},
+		Keeper:      map[string]*sync.Mutex{},
+	}
+}
+
 func (dependencies *Instance) addBeverageRepository() {
 	dependencies.BeverageRepository = local_repo.NewInMemoryBeverageRepository()
 }

service/local/transaction_lock_manager.go

@@ -0,0 +1,46 @@
+package service
+
+import (
+	"strings"
+	"sync"
+
+	"nipun.io/brew_machine/logger"
+)
+
+type TransactionLockManager struct {
+	Keeper      map[string]*sync.Mutex
+	KeeperState map[string]string
+}
+
+const (
+	Locked = "LOCKED"
+)
+
+var mutex sync.Mutex // Global Mutex, all operation of locking and un-locking happen in a serial manner using this.
+
+func (tlm *TransactionLockManager) AcquireLock(entities []string) {
+	logger.Logger.Debug().Msgf("Trying to acquire operation lock for %+v", entities)
+	mutex.Lock()
+	entitiesString := strings.Join(entities, "-")
+	if tlm.Keeper[entitiesString] == nil {
+		tlm.Keeper[entitiesString] = &sync.Mutex{}
+		logger.Logger.Debug().Msgf("Created mutex for entity : %s", entitiesString)
+	}
+	logger.Logger.Debug().Msgf("Trying to acquire lock for %+v", entities)
+	tlm.Keeper[entitiesString].Lock() // who ever want to acquire a lock on something already locked, will have to wait.
+	logger.Logger.Debug().Msgf("Acquired lock on mutex for entity : %s", entitiesString)
+	tlm.KeeperState[entitiesString] = Locked
+	mutex.Unlock()
+}
+
+func (tlm *TransactionLockManager) ReleaseLock(entities []string) {
+	mutex.Lock() // to deal with classic deadlock scenario
+	entitiesString := strings.Join(entities, "-")
+
+	if tlm.KeeperState[entitiesString] == Locked {
+		logger.Logger.Debug().Msgf("released lock on mutex for entity : %s", entitiesString)
+		tlm.Keeper[entitiesString].Unlock()
+		tlm.KeeperState[entitiesString] = ""
+	}
+	mutex.Unlock()
+}

service/transaction_lock_manager.go

@@ -0,0 +1,6 @@
+package service
+
+type TransactionLockManager interface {
+	AcquireLock([]string)
+	ReleaseLock([]string)
+}