220809

type SagaOrchestrator struct {  
   Name         string  
  Transactions []Transaction  
}

func NewSagaOrchestrator(name string, transactions []Transaction) (*SagaOrchestrator, error) {  
  var sagaCreationErrorPrefix = "[ERROR] [SAGA_PATTERN] "  
  
  so := new(SagaOrchestrator)  
  so.Name = name  
  
  var countOfCompensatableTransactions = 0  
  var countOfPivotTransactions = 0  
  var countOfRetryableTransactions = 0  
  lastIndex := len(transactions) - 1  
  // Loops through the list of transactions to check for acceptable order has been passed  
  for index, transaction := range transactions {  
  
 //Checks for Compensatable Transactions  
 //Ruling:
 // There cannot be a Pivot Transaction prior to any Compensatable Transaction
 // There cannot be Retryable Transactions prior to any Pivot Transactions  
 if transaction.GetTransactionType() == GetCompensatableTransactionType() {  
         countOfCompensatableTransactions = countOfCompensatableTransactions + 1  
         
	  //Checking if it's before any Pivot Transactions  
	  if countOfPivotTransactions > 0 {  
            return nil, errors.New(sagaCreationErrorPrefix + "[SAGA_CREATION] [Compensatable]| Cannot put Compensatable Transactions after a Pivot Transaction")  
         }  
         //Checking if it's before any Retryable Transactions  
	  if countOfRetryableTransactions > 0 {  
            return nil, errors.New(sagaCreationErrorPrefix + "[SAGA_CREATION] [Compensatable]| Cannot put Compensatable Transactions before any Retryable Transaction(s)")  
         }  
     }  
  
 //Checks for Pivot Transaction  
 //Ruling:
 // There cannot be more than one pivot transaction 
 // There are no Retryable prior to the Pivot  
 if transaction.GetTransactionType() == GetPivotTransactionType() {  
         countOfPivotTransactions = countOfPivotTransactions + 1  
	  //Checks that there is not already a Pivot Transaction in the List of Transactions  
	  if countOfPivotTransactions > 1 {  
            return nil, errors.New(sagaCreationErrorPrefix + "[SAGA_CREATION] [Pivot]| There is more than one Pivot Transaction")  
         }  
	  //Checks that there is not any Retryable Transactions prior in the list of Transactions  
	  if countOfRetryableTransactions > 0 {  
            return nil, errors.New(sagaCreationErrorPrefix + "[SAGA_CREATION] [Pivot]| Cannot put Pivot Transaction After Retryable Transactions")  
         }    
      }  
//Checking Retryable  
//Note: currently 220801 that I do not think I need to check for anything for Retryable, cause the other two cover it. 
//but I will leave this code here just in case
if transaction.GetTransactionType() == GetPivotTransactionType() {  
         countOfRetryableTransactions = countOfRetryableTransactions + 1  
}  
//Checks at last Transaction in the list  
if index == lastIndex {  
	//Checks that there is a pivot if there is any Compensatable Transactions  
	if countOfPivotTransactions < 1 && countOfCompensatableTransactions > 0 {  
            return nil, errors.New(sagaCreationErrorPrefix + "[SAGA_CREATION] | Compensatable Transactions have not Pivot Transactions")  
         }  
      }  
   }  
  // So it passes the checks above its good to go.  
  so.Transactions = transactions  
   return so, nil  
}

type Transaction interface {  
  GetTransactionType() sagaTransactionType  
  GetTransactionCommands() []TransactionCommand  
  GetTransactionName() string  
}

  type Transaction interface {  
  GetTransactionType() sagaTransactionType  
  ...

  type Transaction interface {  
  ...
  GetTransactionCommands() []TransactionCommand  
  ...

// TransactionCommand this action part of the Transaction in which Execute would do it and give the response if any.
// this was made to allow both REST and Kafka thus functioning taking an anonymous interface. Doing this allows for both  
// of the possible solutions Actions to be in the same collection  
type TransactionCommand interface {  
  Execute() (success bool, err error)  
  GetTransactionCommandType() string  
  GetTransactionCommandName() string  
}

type TransactionCommand interface {  
  ...
  GetTransactionCommandType() string  
  GetTransactionCommandName() string  

type TransactionCommand interface {  
  Execute() (success bool, err error)
  ....  

const RetryableTransactionRetryLimit = 3  
  
type sagaRunner struct {  
   logger             *log.Logger  
  generalErrorPrefix error  
}  
  
//ExecuteSaga  
/*  
  
 Order of Transaction is import in passed ListOfTransactions - Compensatable Transactions: -- NOTE: Compensatable Transactions should have two Transaction Commands. The first one for the intended Transaction and the second one to Roll back that Transaction encase of failure/issues in any of the following Transaction  
 -- Can only be in place prior in order to the Pivot Transaction and never after -- If there is no Pivot Transaction Action then there cannot be any Compensatable Transactions - Pivot Transaction:  
 -- There can only be one per list of Transactions or - Retryable Transactions: -- If the Pivot Transaction exist in the List then Retryable Transactions can only be in after that Pivot Transaction  
 -- Retryable Transactions should never be in the list of Transactions prior to the Pivot Transaction if it exists  
 - NOTE Other Use Cases: -- You can have a Pivot Transaction without Compensatable Transaction(s)  
 -- You can just have list of Transactions without Pivot nor Compensatable Transactions(So just Retryable Transactions (Granted idk why you would tho))*/  
func ExecuteSaga(orchestrator SagaOrchestrator) error {  
   prefixSagaExecutionError := errors.New(prefixSagaExecutionError + "[" + orchestrator.Name + "]")  
   sagaRunnerLogger := sagaRunner{  
      logger:             log.New(os.Stdout, orchestrator.Name+" | ", log.LstdFlags),  
  generalErrorPrefix: prefixSagaExecutionError,  
  }  
   //This is the list of the undo transaction in the event of a failure or  
  var compensatableTransactionCommands []TransactionCommand  
  var hasCompensatableTransaction = false  
  
  sagaRunnerLogger.logger.Println("------- Saga Execution Start --------")  
   for _, transaction := range orchestrator.Transactions {  
      //Pull the List of Transactions Commands  
 // [1] is the intended transaction Command // [2] would be a compensatableTransaction Command  transactionCommands := transaction.GetTransactionCommands()  
  
      sagaRunnerLogger.logger.Println("Transaction Name: " + transaction.GetTransactionName())  
      sagaRunnerLogger.logger.Printf("Transaction Type: %+v\n", transaction.GetTransactionType())  
  
      //Execute the Transaction  
 // To handle result a lil later  canProceed, err := transactionCommands[0].Execute()  
  
      sagaRunnerLogger.logger.Println("--- Transaction Executed Results ---")  
      sagaRunnerLogger.logger.Printf("Can Proceed to Next Transaction: %t\n", canProceed)  
      sagaRunnerLogger.logger.Printf("Was There an Error In that Transaction: %v\n", err)  
      //COMPENSATABLE TRANSACTION  
 //If it's a Compensatable Transaction Type add the second transaction to the list undo Transaction Commands  if transaction.GetTransactionType() == GetCompensatableTransactionType() {  
         hasCompensatableTransaction = true  
  compensatableTransactionCommands = append(compensatableTransactionCommands, transactionCommands[2])  
      }  
        
      //FAILURE IN COMPENSATABLE OR PIVOT TRANSACTION  
 // If get the do not proceed flag or an error (the canProceed is for Transaction Commands that get responses)  if !canProceed || err != nil {  
         // This is just in case you get a Pivot Transaction without any CompensatableTransaction(s) in an effort to try and save some compute  
  if !hasCompensatableTransaction {  
            if transaction.GetTransactionType() == GetPivotTransactionType() {  
               if err == nil {  
                  err = errors.New("got a Do Not Proceed, but No Error(So now you get an Error)")  
               }  
               log.Println(err)  
               return err  
            }  
         }  
         //Check if the Transaction Type is Pivot/Compensatable then undo the Transactions providing the list of undo Transaction Commands  
  if transaction.GetTransactionType() == GetCompensatableTransactionType() || transaction.GetTransactionType() == GetPivotTransactionType() {  
            undoErr := undoCompensatableTransactions(compensatableTransactionCommands, &sagaRunnerLogger)  
            if undoErr != nil {  
               // This process fails I really don't want to tell the end user. So I guess I'll just log it.  
  sagaRunnerLogger.logger.Println(undoErr)  
            }  
            if err == nil {  
               err = errors.New("got a Do Not Proceed, but No Error(So now you get an Error)")  
            }  
            return err  
  
         }  
      }  
      //Check if the Transaction Type is Retryable then try to reattempt them to preset retry limit  
  if transaction.GetTransactionType() == GetRetriableTransactionType() {  
         if !canProceed || err != nil {  
            didItFinallyWork, err := retryRetractableTransactionToPresetLimit(transactionCommands[0], &sagaRunnerLogger)  
            if err != nil {  
               return err  
  }  
            if !didItFinallyWork {  
               retriesFailed := fmt.Errorf("%v [UNDO] | After the Preset Number (#%d) of Retries this RetryTabiable Transaction(%v) has still Failed. Look at contruction of this Transaction and its Transaction Command(%v)", sagaRunnerLogger.generalErrorPrefix, RetryableTransactionRetryLimit, transaction.GetTransactionName(), transaction.GetTransactionCommands()[0].GetTransactionCommandName())  
               sagaRunnerLogger.logger.Println(retriesFailed)  
               // I am not positive If I am supposed to return this error I will for now  
  return fmt.Errorf("%v | %v ", retriesFailed, err)  
            }  
         }  
  
      }  
      sagaRunnerLogger.logger.Println("------- Next Transaction --------")  
   } //End of loop  
  sagaRunnerLogger.logger.Println("------- End of Saga Execution --------")  
   return nil  
}  
func retryRetractableTransactionToPresetLimit(command TransactionCommand, runner *sagaRunner) (bool, error) {  
   var didItFinallyWork = false  
 var err error  
 for i := 1; i <= RetryableTransactionRetryLimit; i++ {  
      runner.logger.Println(fmt.Sprintf("%v [RETRYABLE] Retrying Retryable Transaction %d of %d", runner.generalErrorPrefix, i, RetryableTransactionRetryLimit))  
      var err1 error  
  didItFinallyWork, err1 = command.Execute()  
      //TODO Learn proper error handling  
  err = fmt.Errorf("retry #: %d | error: %v | %v", i, err1, err)  
  
   }  
   return didItFinallyWork, err  
}  
  
func undoCompensatableTransactions(listOfCompensatableTransactions []TransactionCommand, runner *sagaRunner) error {  
   //TODO Need to learn to Wrap errors  
  undo := errors.New("[UNDO] |")  
   errCollector := errors.New("")  
   for _, transactionCommand := range listOfCompensatableTransactions {  
      workAsExpected, err := transactionCommand.Execute()  
      if err != nil {  
         runner.logger.Printf(" %v %v | TransactionCommandName: %v, Error: %v", runner.generalErrorPrefix, undo, transactionCommand.GetTransactionCommandName(), err)  
         errCollector = fmt.Errorf("%v | %v | %v", runner.generalErrorPrefix, undo, err)  
         return errCollector  
      }  
      if !workAsExpected {  
         runner.logger.Printf("%v %v | | TransactionCommandName: %v . Got an do not proceed on the undo that's not good so here is your sign", runner.generalErrorPrefix, undo, transactionCommand.GetTransactionCommandName())  
      }  
   }  
   return nil  
}