public override T Execute <T>(CommandConfig config, ICommand <T> command) { ICommandContext commandContext = Context.CommandContext; // Storing it in a variable, to reference later (it can change during command execution) bool isReused = commandContext.Reused; try { if (transactionContextFactory != null && !isReused) { ITransactionContext transactionContext = transactionContextFactory.OpenTransactionContext(commandContext); Context.TransactionContext = transactionContext; commandContext.AddCloseListener(new TransactionCommandContextCloseListener(transactionContext)); } return(next.Execute(config, command)); } catch (Exception e) { throw; } finally { if (transactionContextFactory != null && !isReused) { Context.RemoveTransactionContext(); } } }
public override T Execute <T>(CommandConfig config, ICommand <T> command) { long waitTime = waitTimeInMs; int failedAttempts = 0; do { if (failedAttempts > 0) { log.LogInformation($"Waiting for {waitTime}ms before retrying the command."); WaitBeforeRetry(waitTime); waitTime *= waitIncreaseFactor; } try { // try to execute the command return(next.Execute(config, command)); } catch (ActivitiOptimisticLockingException e) { log.LogInformation("Caught optimistic locking exception: " + e); } failedAttempts++; } while (failedAttempts <= numOfRetries); throw new ActivitiException(numOfRetries + " retries failed with ActivitiOptimisticLockingException. Giving up."); }
public virtual CommandConfig TransactionRequired() { CommandConfig config = new CommandConfig(this) { propagation = TransactionPropagation.REQUIRED }; return(config); }
public virtual CommandConfig SetContextReusePossible(bool contextReusePossible) { CommandConfig config = new CommandConfig(this) { contextReusePossible = contextReusePossible }; return(config); }
public virtual CommandConfig TransactionNotSupported() { CommandConfig config = new CommandConfig { contextReusePossible = false, propagation = TransactionPropagation.NOT_SUPPORTED }; return(config); }
public virtual CommandConfig TransactionRequiresNew() { CommandConfig config = new CommandConfig { contextReusePossible = false, propagation = TransactionPropagation.REQUIRES_NEW }; return(config); }
public override T Execute <T>(CommandConfig config, ICommand <T> command) { ICommandContext context = Context.CommandContext; bool contextReused = false; // We need to check the exception, because the transaction can be in a // rollback state, and some other command is being fired to compensate (eg. decrementing job retries) if (!config.ContextReusePossible || context == null || context.Exception != null) { context = commandContextFactory.CreateCommandContext <T>(command); } else { log.LogDebug($"Valid context found. Reusing it for the current command '{command.GetType().FullName}'"); contextReused = true; context.Reused = true; } try { // Push on stack Context.CommandContext = context; Context.ProcessEngineConfiguration = processEngineConfiguration; return(next.Execute(config, command)); } catch (NullReferenceException e) { context.SetException(e); } catch (Exception e) { context.SetException(e); } finally { try { if (!contextReused) { context.Close(); } } finally { // Pop from stack Context.RemoveCommandContext(); Context.RemoveProcessEngineConfiguration(); Context.RemoveBpmnOverrideContext(); } } return(default);
public override T execute <T>(CommandConfig config, ICommand <T> command) { if (calledInsideTransaction()) { //log.trace("Called inside transaction, skipping the retry interceptor."); return(next.execute(config, command)); } else { return(base.execute(config, command)); } }
public override T execute <T>(CommandConfig config, ICommand <T> command) { //LOGGER.debug("Running command with propagation {}", config.TransactionPropagation); if (config.TransactionPropagation == TransactionPropagation.NOT_SUPPORTED) { return(next.execute(config, command)); } bool requiresNew = config.TransactionPropagation == TransactionPropagation.REQUIRES_NEW; Transaction oldTx = null; try { bool existing = Existing; bool isNew = !existing || requiresNew; if (existing && requiresNew) { oldTx = doSuspend(); } if (isNew) { doBegin(); } T result; try { result = next.execute(config, command); } catch (Exception ex) { doRollback(isNew, ex); throw new Exception("TransactionCallback threw undeclared checked exception", ex); } if (isNew) { doCommit(); } return(result); } finally { doResume(oldTx); } }
public override T Execute <T>(CommandConfig config, ICommand <T> command) { if (!log.IsEnabled(LogLevel.Debug)) { // do nothing here if we cannot log return(next.Execute(config, command)); } log.LogDebug("\n"); log.LogDebug($"--- starting {command.GetType().Name} --------------------------------------------------------"); try { return(next.Execute(config, command)); } finally { log.LogDebug($"--- {command.GetType().Name} finished --------------------------------------------------------"); log.LogDebug("\n"); } }
public override T Execute <T>(CommandConfig config, ICommand <T> command) { object value; ICommandContext commandContext = Context.CommandContext; try { // Execute the command. // This will produce operations that will be put on the agenda. commandContext.Agenda.PlanOperation(new RunableOperation(() => { T result = command.Execute(commandContext); commandContext.SetResult(result); })); // Run loop for agenda ExecuteOperations(commandContext); // At the end, call the execution tree change listeners. // TODO: optimization: only do this when the tree has actually changed (ie check dbSqlSession). if (commandContext.HasInvolvedExecutions()) { Context.Agenda.PlanExecuteInactiveBehaviorsOperation(); ExecuteOperations(commandContext); } value = commandContext.GetResult(); return((T)value); } catch (InvalidCastException ex) { System.Diagnostics.Debugger.Break(); return(default);
protected internal CommandConfig(CommandConfig commandConfig) { this.contextReusePossible = commandConfig.contextReusePossible; this.propagation = commandConfig.propagation; }