/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
var strategyHandler = SystemBootstrapper.GetInstance <IStrategyHandler>();
if (strategyHandler.IsNull() || !strategyHandler.AutoHandleErrorProcesses)
{
try
{
return(Next.Execute(process, processType, args));
}
catch (Exception ex)
{
return(VoidResult.FaultedResult <TResult>(ex));
}
}
var strategyResult = strategyHandler.Execute(() => Next.Execute(process, processType, args));
if (strategyResult.Exception != null)
{
return(VoidResult.FaultedResult <TResult>(strategyResult.Exception));
}
return(strategyResult.Result);
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
// get authorize attrigute
var attributes = processType.GetCustomAttributes(typeof(SignalsAuthorizeAttribute), false).Cast <SignalsAuthorizeAttribute>().ToList();
// if no attribute is present the request is valid
if (!attributes.Any())
{
return(Next.Execute(process, processType, args));
}
var correctMethod = false;
foreach (var attribute in attributes)
{
// try authorize the user
correctMethod |= attribute.Authorize(processType.Name);
}
if (!correctMethod)
{
return(VoidResult.FaultedResult <TResult>(new AuthorizationErrorInfo()));
}
return(Next.Execute(process, processType, args));
}
/// <summary>
/// Execute process using passed arguments
/// </summary>
/// <param name="process"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult ExecuteBackground <TResult>(IBaseProcess <TResult> process, params object[] args) where TResult : VoidResult, new()
{
var processType = process.GetType();
var result = _backgroundPipe[0].Execute(process, processType, args);
return(result);
}
/// <summary>
/// Invoke callbacks when error happens
/// </summary>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <param name="ex"></param>
internal void InvokeError(IBaseProcess<VoidResult> process, Type processType, object[] args, Exception ex)
{
foreach(var callback in Callbacks)
{
callback(process, processType, args, ex);
}
}
/// <summary>
/// Handle the request
/// </summary>
/// <returns></returns>
public TResponse Dispatch <TResponse>(IBaseProcess <TResponse> process)
where TResponse : VoidResult, new()
{
// execute process
var response = ProcessExecutor.Execute(process);
return(response);
}
/// <summary>
/// Handle the request
/// </summary>
/// <returns></returns>
public TResponse Dispatch <T1, T2, T3, TResponse>(IBaseProcess <TResponse> process, T1 obj1, T2 obj2, T3 obj3)
where TResponse : VoidResult, new()
{
// execute process
var response = ProcessExecutor.Execute(process, obj1, obj2, obj3);
return(response);
}
//public static void InvokeProcessCompeteEvent(this IBaseProcess process, IProcessExecutionContext context, bool isFailed=false)
//{
// if (isFailed)
// {
// Robustness.Instance.SafeCall(() =>
// {
// process.ProcessCompleted(context);
// });
// }
// else
// {
// Robustness.Instance.SafeCall(() =>
// {
// process.ProcessFailed(context);
// });
// }
// Robustness.Instance.SafeCall(() =>
// {
// process.ProcessFinalizer(context);
// });
//}
#endregion
public static void InvokeProcessRetry(this IBaseProcess process, IProcessRetryContext context)
{
{
Robustness.Instance.SafeCall(() =>
{
process.OnRetry(context);
}, context.Logger);
}
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
if (process is IDistributedProcess distributedProcess)
{
return(distributedProcess.ExecuteBackgroundProcess(args) as TResult);
}
return(null);
}
//private readonly Action<ProcessExecutionContext, bool> _invokeProcessCompletion;
public VolumeGenerator(IBaseProcess process, IStateManager stateManager, IVolumeHandler volumeHandler,
IResolver resolver, CancellationToken cancellationToken, IProcessRepository registeredProcesses,
IBatchEngineSubscribers batchEngineSubscribers, IFrameworkLogger logger)
{
_process = process;
_stateManager = stateManager;
this._volumeHandler = volumeHandler;
_resolver = resolver;
_cancellationToken = cancellationToken;
_registeredProcesses = registeredProcesses;
_batchEngineSubscribers = batchEngineSubscribers;
_logger = logger;
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
// Get guard attribute
var guardAttributes = processType.GetCustomAttributes(typeof(SignalsGuardAttribute), false).Cast <SignalsGuardAttribute>().ToList();
foreach (var guardAttribute in guardAttributes)
{
var guardResult = guardAttribute.Check(process.BaseContext);
if (guardResult != null)
{
return(VoidResult.FaultedResult <TResult>(guardResult));
}
}
return(Next.Execute(process, processType, args));
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
var auditProvider = SystemBootstrapper.GetInstance <IAuditProvider>();
if (auditProvider.IsNull())
{
return(Next.Execute(process, processType, args));
}
var entry = auditProvider.Entry();
entry.Originator = ApplicationConfiguration.Instance?.ApplicationName ?? Environment.MachineName;
entry.Process = process.Name;
entry.EventType = process.Description;
entry.EpicId = process.EpicId;
entry.Payload = args?.SerializeJson();
return(auditProvider.Audit(entry, () => Next.Execute(process, processType, args)));
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
var innerResult = Next.Execute(process, processType, args);
var logger = SystemBootstrapper.GetInstance <ILogger>();
if (logger.IsNull())
{
return(innerResult);
}
if (innerResult.IsFaulted)
{
if (innerResult.IsSystemFault)
{
var errorInfo = innerResult.ErrorMessages.OfType <UnmanagedExceptionErrorInfo>().SingleOrDefault();
var exception = errorInfo.Exception;
var entry = LogEntry.Exception(exception, message: innerResult.GetFaultMessage());
entry.ProcessName = process.Name;
entry.Action = exception.TargetSite?.Name;
entry.Origin = ApplicationConfiguration.Instance?.ApplicationName ?? Environment.MachineName;
entry.Payload = args?.SerializeJson();
entry.UserIdentifier = process.BaseContext?.CurrentUserPrincipal?.Identity?.Name;
logger.Fatal(entry);
}
else
{
var entry = LogEntry.Trace(message: innerResult.GetFaultMessage(), payload: args);
entry.ProcessName = process.Name;
entry.Action = process.Name;
entry.Origin = ApplicationConfiguration.Instance?.ApplicationName ?? Environment.MachineName;
entry.Payload = args?.SerializeJson();
entry.UserIdentifier = process.BaseContext?.CurrentUserPrincipal?.Identity?.Name;
logger.Info(entry);
}
}
return(innerResult);
}
/// <summary>
/// Execute process with input
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="process"></param>
/// <param name="input1"></param>
/// <param name="input2"></param>
/// <param name="input3"></param>
/// <returns></returns>
public static TResponse With <T1, T2, T3, TResponse>(this IBaseProcess <TResponse> process, T1 input1, T2 input2, T3 input3)
where TResponse : VoidResult, new()
{
return(process.BaseContext.Mediator.Dispatch(process, input1, input2, input3));
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
try
{
return(Next.Execute(process, processType, args));
}
catch (Exception ex)
{
var criticalAttributes = processType.GetCustomAttributes(typeof(CriticalAttribute), true).Cast <CriticalAttribute>().ToList();
if (criticalAttributes.Any())
{
var manager = SystemBootstrapper.GetInstance <CriticalErrorCallbackManager>();
manager?.InvokeError(process, processType, args, ex);
}
var happeningDate = DateTime.UtcNow;
if (ApplicationConfiguration.Instance?.CriticalConfiguration != null)
{
string InterpolateException(string originalString)
{
return(originalString
.Replace("[#Date#]", happeningDate.ToString(CultureInfo.InvariantCulture))
.Replace("[#Process#]", processType.Name)
.Replace("[#Message#]", ex.Message)
.Replace("[#StackTrace#]", ex.StackTrace)
.Replace("[#Data#]", args?.SerializeJson()));
}
var client = SystemBootstrapper.GetInstance <ISmtpClient>();
if (!client.IsNull())
{
foreach (var attribute in criticalAttributes)
{
var emails = attribute.NotificaitonEmails?.Split(',')?.Select(x => x.Trim())?.ToList();
if (!emails.IsNullOrHasZeroElements())
{
var from = ApplicationConfiguration.Instance.ApplicationEmail;
var to = emails;
var subject = InterpolateException(ApplicationConfiguration.Instance.CriticalConfiguration.Subject);
var body = InterpolateException(ApplicationConfiguration.Instance.CriticalConfiguration.Body);
var data = $@"Date: {happeningDate.ToString(CultureInfo.InvariantCulture)}{Environment.NewLine}
Process: {processType.Name}{Environment.NewLine}
Message: {ex.Message}{Environment.NewLine}
StackTrace: {ex.StackTrace}{Environment.NewLine}
Data: {args?.SerializeJson()}{Environment.NewLine}";
Attachment attachment = Attachment.CreateAttachmentFromString(data, "critical_info.txt");
var message = new MailMessage();
message.From = new MailAddress(from);
message.Subject = subject;
message.Body = body;
message.IsBodyHtml = true;
foreach (var email in emails)
{
message.To.Add(email);
}
message.Attachments.Add(attachment);
client.Send(message);
}
}
}
}
throw;
}
}
/// <summary>
/// CTOR
/// </summary>
internal void SetProcess(IBaseProcess <VoidResult> process)
{
this.process = process;
}
/// <summary>
/// Execute process with input
/// </summary>
/// <typeparam name="TResponse"></typeparam>
/// <param name="process"></param>
/// <returns></returns>
public static TResponse With <TResponse>(this IBaseProcess <TResponse> process)
where TResponse : VoidResult, new()
{
return(process.BaseContext.Mediator.Dispatch(process));
}
/// <summary>
/// Execute handler
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="process"></param>
/// <param name="processType"></param>
/// <param name="args"></param>
/// <returns></returns>
public TResult Execute <TResult>(IBaseProcess <TResult> process, Type processType, params object[] args) where TResult : VoidResult, new()
{
return(process.ExecuteProcess(args));
}
public void RegisterProcess(IBaseProcess process)
{
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="benchmarker"></param>
/// <param name="process"></param>
public ProcessBenchmarker(IBenchmarker benchmarker, IBaseProcess<VoidResult> process)
{
this.benchmarker = benchmarker;
this.process = process;
}
