protected virtual async Task ExecuteTask(ExecutorArgs executorArgs, ServiceMessageEventArgs args)
{
try
{
var executor = this.ExecutorFactory.Value.CreateInstance(executorArgs, args);
Task <HandleMessageResult> resultTask = RunExecutor(executor, args);
if (executor.IsAsyncProcessing && !resultTask.IsCompleted)
{
this.ExecuteAsync(resultTask, executorArgs, args);
}
else
{
var res = await resultTask;
args.TaskCompletionSource.TrySetResult(res);
}
}
catch (OperationCanceledException)
{
args.TaskCompletionSource.TrySetCanceled(args.Token);
}
catch (PPSException ex)
{
args.TaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogError(ErrorHelper.GetFullMessage(ex));
args.TaskCompletionSource.TrySetException(new PPSException(ex));
}
}
public ProcessPendingExecutor(ExecutorArgs args, IServiceBrokerHelper isssbHelper) :
base(args)
{
_issbHelper = isssbHelper;
_processAll = false;
_objectID = null;
}
protected virtual async Task ExecuteTask(ExecutorArgs executorArgs, ServiceMessageEventArgs args)
{
try
{
var executor = (IExecutor)ActivatorUtilities.CreateInstance(args.Services, executorArgs.TaskInfo.ExecutorType, new object[] { executorArgs });
executorArgs.TasksManager.CurrentExecutor = executor;
Task <HandleMessageResult> execResTask = execResTask = RunExecutor(executor, args);
if (executor.IsAsyncProcessing && !execResTask.IsCompleted)
{
this.ExecuteAsync(execResTask, executorArgs, args);
}
else
{
var res = await execResTask;
args.TaskCompletionSource.TrySetResult(res);
}
}
catch (OperationCanceledException)
{
args.TaskCompletionSource.TrySetCanceled(args.Token);
}
catch (PPSException ex)
{
args.TaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogError(ErrorHelper.GetFullMessage(ex));
args.TaskCompletionSource.TrySetException(new PPSException(ex));
}
}
public IExecutor CreateInstance(ExecutorArgs executorArgs, ServiceMessageEventArgs args)
{
var executor = (IExecutor)ActivatorUtilities.CreateInstance(args.Services, this.ExecutorType, new object[] { executorArgs });
executorArgs.TasksManager.CurrentExecutor = executor;
return(executor);
}
public override async Task <ServiceMessageEventArgs> HandleMessage(ISSSBService sender, ServiceMessageEventArgs serviceMessageArgs)
{
MessageAtributes messageAtributes = null;
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
XElement xml = serviceMessageArgs.Message.GetMessageXML();
messageAtributes = xml.GetMessageAttributes();
}
catch (OperationCanceledException)
{
serviceMessageArgs.TaskCompletionSource.TrySetCanceled(serviceMessageArgs.Token);
return(serviceMessageArgs);
}
catch (PPSException ex)
{
serviceMessageArgs.TaskCompletionSource.TrySetException(ex);
return(serviceMessageArgs);
}
catch (Exception ex)
{
this.Logger.LogError(ErrorHelper.GetFullMessage(ex));
serviceMessageArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
return(serviceMessageArgs);
}
var taskManager = serviceMessageArgs.Services.GetRequiredService <IOnDemandTaskManager>();
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
var task = await taskManager.GetTaskInfo(messageAtributes.TaskID.Value);
serviceMessageArgs.TaskID = messageAtributes.TaskID.Value;
var executorArgs = new ExecutorArgs(taskManager, task, serviceMessageArgs.Message, messageAtributes);
await ExecuteTask(executorArgs, serviceMessageArgs);
}
catch (OperationCanceledException)
{
serviceMessageArgs.TaskCompletionSource.TrySetCanceled(serviceMessageArgs.Token);
}
catch (PPSException ex)
{
serviceMessageArgs.TaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogCritical(ErrorHelper.GetFullMessage(ex));
serviceMessageArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
}
return(serviceMessageArgs);
}
public BaseExecutor(ExecutorArgs args)
{
Type loggerType = typeof(ILogger <>);
this.Logger = (ILogger)args.TasksManager.Services.GetRequiredService(loggerType.MakeGenericType(this.GetType()));
this.Message = args.Message;
this.TasksManager = args.TasksManager;
this.TaskInfo = args.TaskInfo;
this.EventDate = args.Atributes.EventDate;
this.Parameters = args.Atributes.Parameters;
this.IsDefered = args.Atributes.IsDefered;
this.AttemptNumber = args.Atributes.AttemptNumber;
}
protected virtual void ExecuteAsync(Task <HandleMessageResult> execResTask, ExecutorArgs executorArgs, ServiceMessageEventArgs serviceArgs)
{
var continuationTask = execResTask.ContinueWith((antecedent) =>
{
try
{
if (antecedent.IsFaulted)
{
antecedent.Exception.Flatten().Handle((err) =>
{
serviceArgs.TaskCompletionSource.TrySetException(err);
return(true);
});
}
else if (antecedent.IsCanceled)
{
serviceArgs.TaskCompletionSource.TrySetCanceled(serviceArgs.Token);
}
else
{
serviceArgs.TaskCompletionSource.TrySetResult(antecedent.Result);
}
}
catch (OperationCanceledException)
{
serviceArgs.TaskCompletionSource.TrySetCanceled(serviceArgs.Token);
}
catch (PPSException ex)
{
serviceArgs.TaskCompletionSource.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogError(ErrorHelper.GetFullMessage(ex));
serviceArgs.TaskCompletionSource.TrySetException(new PPSException(ex));
}
}, TaskContinuationOptions.ExecuteSynchronously);
}
public TestExecutor(ExecutorArgs args) :
base(args)
{
}
public FlushSettingsExecutor(ExecutorArgs args, IScheduleManager scheduleManager) :
base(args)
{
_scheduleManager = scheduleManager;
}
public MultyStepExecutor(ExecutorArgs args) :
base(args)
{
this._metaDataManager = new Lazy <IMetaDataManager>(() => new MetaDataManager(this._metaDataID, this.Services), true);
}
public override async Task <ServiceMessageEventArgs> HandleMessage(ISSSBService sender, ServiceMessageEventArgs serviceMessageArgs)
{
MessageAtributes messageAtributes = null;
SSSBMessage deferedMessage = null;
ServiceMessageEventArgs previousServiceMessageArgs = serviceMessageArgs;
var tcs = serviceMessageArgs.TaskCompletionSource;
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
XElement envelopeXml = serviceMessageArgs.Message.GetMessageXML();
byte[] deferedMessageBody = Convert.FromBase64String(envelopeXml.Element("body").Value);
XElement deferedMessageXml = deferedMessageBody.GetMessageXML();
messageAtributes = deferedMessageXml.GetMessageAttributes();
messageAtributes.IsDefered = true;
messageAtributes.AttemptNumber = (int)envelopeXml.Attribute("attemptNumber");
string messageType = (string)envelopeXml.Attribute("messageType");
string serviceName = (string)envelopeXml.Attribute("serviceName");
string contractName = (string)envelopeXml.Attribute("contractName");
long sequenceNumber = (long)envelopeXml.Attribute("sequenceNumber");
MessageValidationType validationType = (MessageValidationType)Enum.Parse(typeof(MessageValidationType), envelopeXml.Attribute("validationType").Value);
Guid conversationHandle = Guid.Parse(envelopeXml.Attribute("conversationHandle").Value);
Guid conversationGroupID = Guid.Parse(envelopeXml.Attribute("conversationGroupID").Value);
deferedMessage = new SSSBDeferedMessage(conversationHandle, conversationGroupID, validationType, contractName, previousServiceMessageArgs.Message)
{
SequenceNumber = sequenceNumber,
ServiceName = serviceName,
Body = deferedMessageBody
};
serviceMessageArgs = new ServiceMessageEventArgs(previousServiceMessageArgs, deferedMessage);
}
catch (OperationCanceledException)
{
tcs.TrySetCanceled(serviceMessageArgs.Token);
return(serviceMessageArgs);
}
catch (PPSException ex)
{
tcs.TrySetException(ex);
return(serviceMessageArgs);
}
catch (Exception ex)
{
this.Logger.LogError(ErrorHelper.GetFullMessage(ex));
tcs.TrySetException(new PPSException(ex));
return(serviceMessageArgs);
}
var taskManager = serviceMessageArgs.Services.GetRequiredService <IOnDemandTaskManager>();
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
var task = await taskManager.GetTaskInfo(messageAtributes.TaskID.Value);
serviceMessageArgs.TaskID = messageAtributes.TaskID.Value;
var executorArgs = new ExecutorArgs(taskManager, task, deferedMessage, messageAtributes);
await ExecuteTask(executorArgs, serviceMessageArgs);
}
catch (OperationCanceledException)
{
tcs.TrySetCanceled(serviceMessageArgs.Token);
}
catch (PPSException ex)
{
tcs.TrySetException(ex);
}
catch (Exception ex)
{
Logger.LogCritical(ErrorHelper.GetFullMessage(ex));
tcs.TrySetException(new PPSException(ex));
}
return(serviceMessageArgs);
}
