/// <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; }