public ErrorMessageEventArgs(SSSBMessage message, ISSSBService svc, Exception processingException, CancellationToken cancellation)
{
this._message = message;
this._service = svc;
this._processingException = processingException;
this._cancellation = cancellation;
}
public CustomMessageHandler(ISSSBService sssbService, IConnectionManager connectionManager, IStandardMessageHandlers standardMessageHandlers, ILogger <CustomMessageHandler> logger)
{
_connectionManager = connectionManager;
SSSBService = sssbService;
_standardMessageHandlers = standardMessageHandlers;
_logger = logger;
}
public override Task<ServiceMessageEventArgs> HandleMessage(ISSSBService sender, ServiceMessageEventArgs args)
{
try
{
// after the task is completed, to turn on the Timer again
lock (ScheduleTimer.Timers)
{
Guid conversationGroup = args.Message.ConversationGroupID;
var timer = (from t in BaseSheduleTimer.Timers.Values
where t.ConversationGroup.HasValue && t.ConversationGroup.Value == conversationGroup
select t).SingleOrDefault();
if (timer != null)
{
timer.Start();
}
}
}
catch (Exception ex)
{
_logger.LogError(ErrorHelper.GetFullMessage(ex));
}
finally
{
args.TaskCompletionSource.SetResult(_services.EndDialog());
}
return Task.FromResult(args);
}
public SSSBMessageDispatcher(ISSSBService sssbService, ILogger <SSSBMessageDispatcher> logger, IStandardMessageHandlers standardMessageHandlers, IServiceProvider services)
{
this._logger = logger;
this._sssbService = sssbService;
this._standardMessageHandlers = standardMessageHandlers;
this._services = services;
this._messageHandlers = new ConcurrentDictionary <string, IMessageHandler <ServiceMessageEventArgs> >();
this._errorMessageHandlers = new ConcurrentDictionary <string, IMessageHandler <ErrorMessageEventArgs> >();
}
public SSSBMessageReaderFactory(ISSSBService service, ISSSBMessageDispatcher messageDispatcher, ILoggerFactory loggerFactory,
IConnectionErrorHandler errorHandler, ISSSBManager manager, IConnectionManager connectionManager)
{
this._log = loggerFactory.CreateLogger(nameof(SSSBMessageReader));
this._service = service;
this._conversation_group = service.ConversationGroup;
this._messageDispatcher = messageDispatcher;
this._errorHandler = errorHandler;
this._manager = manager;
this._connectionManager = connectionManager;
}
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 ServiceMessageEventArgs(ServiceMessageEventArgs parentArgs, SSSBMessage message)
{
_message = message ?? parentArgs.Message;
_service = parentArgs._service;
_token = parentArgs._token;
_taskID = parentArgs._taskID;
_serviceScope = parentArgs._serviceScope;
_tcs = parentArgs._tcs;
_completion = parentArgs._completion;
_services = parentArgs._services;
}
public ServiceMessageEventArgs(SSSBMessage message, ISSSBService svc, CancellationToken cancellation, IServiceScope serviceScope)
{
_message = message;
_service = svc;
_token = cancellation;
_taskID = -1;
_serviceScope = serviceScope;
_tcs = new TaskCompletionSource <HandleMessageResult>();
_completion = _tcs.Task;
_services = _serviceScope.ServiceProvider;
}
public SSSBMessageReader(long taskId, Guid?conversation_group, BaseTasksCoordinator tasksCoordinator, ILogger log,
ISSSBService service, ISSSBMessageDispatcher dispatcher,
IConnectionErrorHandler errorHandler, ISSSBManager manager, IConnectionManager connectionManager) :
base(taskId, tasksCoordinator, log)
{
this._conversation_group = conversation_group;
this._service = service;
this._dispatcher = dispatcher;
this._errorHandler = errorHandler;
this._manager = manager;
this._connectionManager = connectionManager;
}
public abstract Task <T> HandleMessage(ISSSBService sender, T args);
public override async Task <ServiceMessageEventArgs> HandleMessage(ISSSBService sender, ServiceMessageEventArgs serviceMessageArgs)
{
MessageAtributes messageAtributes = null;
SSSBMessage originalMessage = null;
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
XElement envelopeXml = serviceMessageArgs.Message.GetMessageXML();
byte[] originalMessageBody = Convert.FromBase64String(envelopeXml.Element("body").Value);
XElement originalMessageXml = originalMessageBody.GetMessageXML();
messageAtributes = originalMessageXml.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);
originalMessage = new SSSBMessage(conversationHandle, conversationGroupID, validationType, contractName);
originalMessage.SequenceNumber = sequenceNumber;
originalMessage.ServiceName = serviceName;
originalMessage.Body = originalMessageBody;
}
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);
}
OnDemandTaskManager taskManager = serviceMessageArgs.Services.GetRequiredService <OnDemandTaskManager>();
try
{
serviceMessageArgs.Token.ThrowIfCancellationRequested();
var task = await taskManager.GetTaskInfo(messageAtributes.TaskID.Value);
serviceMessageArgs.TaskID = messageAtributes.TaskID.Value;
var executorArgs = new ExecutorArgs(taskManager, task, originalMessage, 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);
}
