protected override string Execute(DurableTask.Core.TaskContext context, string input) { Console.WriteLine("Executing Cron Job. Started At: '" + DateTime.Now.ToString() + "' Number: " + input); string completed = "Cron Job '" + input + "' Completed..."; Console.WriteLine(completed); Count++; return(completed); }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { ServiceEventSource.Current.Message($"Executing Cron Job. Started At: '{DateTime.Now}' Number: {input}"); Thread.Sleep(2 * 1000); string completed = $"Cron Job '{input}' Completed..."; ServiceEventSource.Current.Message(completed); return(completed); }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { Console.WriteLine($"Executing Cron Job. Started At: '{DateTime.Now}' Number: {input}"); Thread.Sleep(2 * 1000); string completed = $"Cron Job '{input}' Completed..."; Console.WriteLine(completed); return(completed); }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { GetUserName userNamedialog = new GetUserName(); Console.WriteLine("Waiting for user to enter name..."); string user = ""; DialogResult dialogResult = userNamedialog.ShowDialog(); if (dialogResult == DialogResult.OK) { user = userNamedialog.UserName; } Console.WriteLine("User Name Entered: " + user); return(user); }
protected override int Execute(DurableTask.Core.TaskContext context, int[] chunk) { if (chunk == null || chunk.Length != 2) { throw new ArgumentException("chunk"); } Console.WriteLine("Compute Sum for " + chunk[0] + "," + chunk[1]); var sum = 0; int start = chunk[0]; int end = chunk[1]; for (int i = start; i <= end; i++) { sum += i; } Console.WriteLine("Total Sum for Chunk '" + chunk[0] + "," + chunk[1] + "' is " + sum.ToString()); return(sum); }
protected override string Execute(DurableTask.Core.TaskContext context, string user) { string message; if (!string.IsNullOrWhiteSpace(user) && user.Equals("TimedOut")) { message = "GetUser Timed out!!!"; Console.WriteLine(message); } else { Console.WriteLine("Sending greetings to user: "******"..."); Thread.Sleep(5 * 1000); message = "Greeting sent to " + user; Console.WriteLine(message); } return(message); }
/// <summary> /// Syncronous execute method, blocked for AsyncTaskActivity /// </summary> /// <returns>string.Empty</returns> public override string Run(TaskContext context, string input) { // will never run return(string.Empty); }
/// <summary> /// Abstract method for executing a task activity synchronously /// </summary> /// <param name="context">The task context</param> /// <param name="input">The serialized input</param> /// <returns>Serialized output from the execution</returns> public abstract string Run(TaskContext context, string input);
/// <summary> /// Abstract method for executing a task activity asynchronously /// </summary> /// <param name="context">The task context</param> /// <param name="input">The typed input</param> /// <returns>The typed output from the execution</returns> protected abstract Task <TResult> ExecuteAsync(TaskContext context, TInput input);
/// <summary> /// Virtual method for executing a task activity asynchronously /// </summary> /// <param name="context">The task context</param> /// <param name="input">The serialized input</param> /// <returns>Serialized output from the execution</returns> public virtual Task <string> RunAsync(TaskContext context, string input) { return(Task.FromResult(Run(context, input))); }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { Console.WriteLine("CleanupTask Executed..."); return("CleanupResult"); }
protected override int Execute(DurableTask.Core.TaskContext context, int chunk) { Console.WriteLine($"Square::{chunk}::{chunk * chunk}"); return(chunk * chunk); }
/// <summary> /// Method for executing a task activity asyncronously /// </summary> /// <param name="context">The task context</param> /// <param name="input">The serialized input</param> /// <returns>Serialized output from the execution</returns> public override async Task <string> RunAsync(TaskContext context, string input) { JArray jArray = JArray.Parse(input); int parameterCount = jArray.Count; ParameterInfo[] methodParameters = MethodInfo.GetParameters(); if (methodParameters.Length < parameterCount) { throw new TaskFailureException( "TaskActivity implementation cannot be invoked due to more than expected input parameters. Signature mismatch.") .WithFailureSource(this.MethodInfoString()); } var inputParameters = new object[methodParameters.Length]; for (int i = 0; i < methodParameters.Length; i++) { Type parameterType = methodParameters[i].ParameterType; if (i < parameterCount) { JToken jToken = jArray[i]; var jValue = jToken as JValue; if (jValue != null) { inputParameters[i] = jValue.ToObject(parameterType); } else { string serializedValue = jToken.ToString(); inputParameters[i] = DataConverter.Deserialize(serializedValue, parameterType); } } else { if (methodParameters[i].HasDefaultValue) { inputParameters[i] = Type.Missing; } else { inputParameters[i] = parameterType.IsValueType ? Activator.CreateInstance(parameterType) : null; } } } string serializedReturn; try { object invocationResult = InvokeActivity(inputParameters); if (invocationResult is Task) { var invocationTask = invocationResult as Task; if (MethodInfo.ReturnType.IsGenericType) { serializedReturn = DataConverter.Serialize(await((dynamic)invocationTask)); } else { await invocationTask; serializedReturn = string.Empty; } } else { serializedReturn = DataConverter.Serialize(invocationResult); } } catch (TargetInvocationException e) { Exception realException = e.InnerException ?? e; string details = Utils.SerializeCause(realException, DataConverter); throw new TaskFailureException(realException.Message, details) .WithFailureSource(this.MethodInfoString()); } catch (Exception e) when(!Utils.IsFatal(e)) { string details = Utils.SerializeCause(e, DataConverter); throw new TaskFailureException(e.Message, e, details) .WithFailureSource(this.MethodInfoString()); } return(serializedReturn); }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { Console.WriteLine("BadTask Executed..."); throw new InvalidOperationException("BadTask failed."); }
async Task OnProcessWorkItemAsync(TaskActivityWorkItem workItem) { Task renewTask = null; var renewCancellationTokenSource = new CancellationTokenSource(); TaskMessage taskMessage = workItem.TaskMessage; OrchestrationInstance orchestrationInstance = taskMessage.OrchestrationInstance; TaskScheduledEvent scheduledEvent = null; try { if (string.IsNullOrWhiteSpace(orchestrationInstance?.InstanceId)) { this.logHelper.TaskActivityDispatcherError( workItem, $"The activity worker received a message that does not have any OrchestrationInstance information."); throw TraceHelper.TraceException( TraceEventType.Error, "TaskActivityDispatcher-MissingOrchestrationInstance", new InvalidOperationException("Message does not contain any OrchestrationInstance information")); } if (taskMessage.Event.EventType != EventType.TaskScheduled) { this.logHelper.TaskActivityDispatcherError( workItem, $"The activity worker received an event of type '{taskMessage.Event.EventType}' but only '{EventType.TaskScheduled}' is supported."); throw TraceHelper.TraceException( TraceEventType.Critical, "TaskActivityDispatcher-UnsupportedEventType", new NotSupportedException("Activity worker does not support event of type: " + taskMessage.Event.EventType)); } // call and get return message scheduledEvent = (TaskScheduledEvent)taskMessage.Event; this.logHelper.TaskActivityStarting(orchestrationInstance, scheduledEvent); TaskActivity taskActivity = this.objectManager.GetObject(scheduledEvent.Name, scheduledEvent.Version); if (taskActivity == null) { throw new TypeMissingException($"TaskActivity {scheduledEvent.Name} version {scheduledEvent.Version} was not found"); } if (workItem.LockedUntilUtc < DateTime.MaxValue) { // start a task to run RenewUntil renewTask = Task.Factory.StartNew( () => this.RenewUntil(workItem, renewCancellationTokenSource.Token), renewCancellationTokenSource.Token); } // TODO : pass workflow instance data var context = new TaskContext(taskMessage.OrchestrationInstance); HistoryEvent eventToRespond = null; var dispatchContext = new DispatchMiddlewareContext(); dispatchContext.SetProperty(taskMessage.OrchestrationInstance); dispatchContext.SetProperty(taskActivity); dispatchContext.SetProperty(scheduledEvent); await this.dispatchPipeline.RunAsync(dispatchContext, async _ => { // correlation CorrelationTraceClient.Propagate(() => workItem.TraceContextBase?.SetActivityToCurrent()); try { string output = await taskActivity.RunAsync(context, scheduledEvent.Input); eventToRespond = new TaskCompletedEvent(-1, scheduledEvent.EventId, output); } catch (TaskFailureException e) { TraceHelper.TraceExceptionInstance(TraceEventType.Error, "TaskActivityDispatcher-ProcessTaskFailure", taskMessage.OrchestrationInstance, e); string details = this.IncludeDetails ? e.Details : null; eventToRespond = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details); this.logHelper.TaskActivityFailure(orchestrationInstance, scheduledEvent.Name, (TaskFailedEvent)eventToRespond, e); CorrelationTraceClient.Propagate(() => CorrelationTraceClient.TrackException(e)); } catch (Exception e) when(!Utils.IsFatal(e) && !Utils.IsExecutionAborting(e)) { TraceHelper.TraceExceptionInstance(TraceEventType.Error, "TaskActivityDispatcher-ProcessException", taskMessage.OrchestrationInstance, e); string details = this.IncludeDetails ? $"Unhandled exception while executing task: {e}\n\t{e.StackTrace}" : null; eventToRespond = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details); this.logHelper.TaskActivityFailure(orchestrationInstance, scheduledEvent.Name, (TaskFailedEvent)eventToRespond, e); } if (eventToRespond is TaskCompletedEvent completedEvent) { this.logHelper.TaskActivityCompleted(orchestrationInstance, scheduledEvent.Name, completedEvent); } }); var responseTaskMessage = new TaskMessage { Event = eventToRespond, OrchestrationInstance = orchestrationInstance }; await this.orchestrationService.CompleteTaskActivityWorkItemAsync(workItem, responseTaskMessage); } catch (SessionAbortedException e) { // The activity aborted its execution this.logHelper.TaskActivityAborted(orchestrationInstance, scheduledEvent, e.Message); TraceHelper.TraceInstance(TraceEventType.Warning, "TaskActivityDispatcher-ExecutionAborted", orchestrationInstance, "{0}: {1}", scheduledEvent.Name, e.Message); await this.orchestrationService.AbandonTaskActivityWorkItemAsync(workItem); } finally { if (renewTask != null) { renewCancellationTokenSource.Cancel(); try { // wait the renewTask finish await renewTask; } catch (OperationCanceledException) { // ignore } } } }
async Task OnProcessWorkItemAsync(TaskActivityWorkItem workItem) { Task renewTask = null; var renewCancellationTokenSource = new CancellationTokenSource(); try { TaskMessage taskMessage = workItem.TaskMessage; OrchestrationInstance orchestrationInstance = taskMessage.OrchestrationInstance; if (string.IsNullOrWhiteSpace(orchestrationInstance?.InstanceId)) { throw TraceHelper.TraceException( TraceEventType.Error, "TaskActivityDispatcher-MissingOrchestrationInstance", new InvalidOperationException("Message does not contain any OrchestrationInstance information")); } if (taskMessage.Event.EventType != EventType.TaskScheduled) { throw TraceHelper.TraceException( TraceEventType.Critical, "TaskActivityDispatcher-UnsupportedEventType", new NotSupportedException("Activity worker does not support event of type: " + taskMessage.Event.EventType)); } // call and get return message var scheduledEvent = (TaskScheduledEvent)taskMessage.Event; TaskActivity taskActivity = objectManager.GetObject(scheduledEvent.Name, scheduledEvent.Version); if (taskActivity == null) { throw new TypeMissingException($"TaskActivity {scheduledEvent.Name} version {scheduledEvent.Version} was not found"); } renewTask = Task.Factory.StartNew(() => RenewUntil(workItem, renewCancellationTokenSource.Token), renewCancellationTokenSource.Token); // TODO : pass workflow instance data var context = new TaskContext(taskMessage.OrchestrationInstance); HistoryEvent eventToRespond = null; var dispatchContext = new DispatchMiddlewareContext(); dispatchContext.SetProperty(taskMessage.OrchestrationInstance); dispatchContext.SetProperty(taskActivity); dispatchContext.SetProperty(scheduledEvent); await this.dispatchPipeline.RunAsync(dispatchContext, async _ => { try { string output = await taskActivity.RunAsync(context, scheduledEvent.Input); eventToRespond = new TaskCompletedEvent(-1, scheduledEvent.EventId, output); } catch (TaskFailureException e) { TraceHelper.TraceExceptionInstance(TraceEventType.Error, "TaskActivityDispatcher-ProcessTaskFailure", taskMessage.OrchestrationInstance, e); string details = IncludeDetails ? e.Details : null; eventToRespond = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details); } catch (Exception e) when(!Utils.IsFatal(e)) { TraceHelper.TraceExceptionInstance(TraceEventType.Error, "TaskActivityDispatcher-ProcessException", taskMessage.OrchestrationInstance, e); string details = IncludeDetails ? $"Unhandled exception while executing task: {e}\n\t{e.StackTrace}" : null; eventToRespond = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details); } }); var responseTaskMessage = new TaskMessage { Event = eventToRespond, OrchestrationInstance = orchestrationInstance }; await this.orchestrationService.CompleteTaskActivityWorkItemAsync(workItem, responseTaskMessage); } finally { if (renewTask != null) { renewCancellationTokenSource.Cancel(); renewTask.Wait(); } } }
async Task OnProcessWorkItemAsync(TaskActivityWorkItem workItem) { Task?renewTask = null; using var renewCancellationTokenSource = new CancellationTokenSource(); TaskMessage taskMessage = workItem.TaskMessage; OrchestrationInstance orchestrationInstance = taskMessage.OrchestrationInstance; TaskScheduledEvent? scheduledEvent = null; Activity?diagnosticActivity = null; try { if (string.IsNullOrWhiteSpace(orchestrationInstance?.InstanceId)) { this.logHelper.TaskActivityDispatcherError( workItem, $"The activity worker received a message that does not have any OrchestrationInstance information."); throw TraceHelper.TraceException( TraceEventType.Error, "TaskActivityDispatcher-MissingOrchestrationInstance", new InvalidOperationException("Message does not contain any OrchestrationInstance information")); } if (taskMessage.Event.EventType != EventType.TaskScheduled) { this.logHelper.TaskActivityDispatcherError( workItem, $"The activity worker received an event of type '{taskMessage.Event.EventType}' but only '{EventType.TaskScheduled}' is supported."); throw TraceHelper.TraceException( TraceEventType.Critical, "TaskActivityDispatcher-UnsupportedEventType", new NotSupportedException("Activity worker does not support event of type: " + taskMessage.Event.EventType)); } scheduledEvent = (TaskScheduledEvent)taskMessage.Event; if (scheduledEvent.Name == null) { string message = $"The activity worker received a {nameof(EventType.TaskScheduled)} event that does not specify an activity name."; this.logHelper.TaskActivityDispatcherError(workItem, message); throw TraceHelper.TraceException( TraceEventType.Error, "TaskActivityDispatcher-MissingActivityName", new InvalidOperationException(message)); } this.logHelper.TaskActivityStarting(orchestrationInstance, scheduledEvent); TaskActivity?taskActivity = this.objectManager.GetObject(scheduledEvent.Name, scheduledEvent.Version); if (workItem.LockedUntilUtc < DateTime.MaxValue) { // start a task to run RenewUntil renewTask = Task.Factory.StartNew( () => this.RenewUntil(workItem, renewCancellationTokenSource.Token), renewCancellationTokenSource.Token); } var dispatchContext = new DispatchMiddlewareContext(); dispatchContext.SetProperty(taskMessage.OrchestrationInstance); dispatchContext.SetProperty(taskActivity); dispatchContext.SetProperty(scheduledEvent); // correlation CorrelationTraceClient.Propagate(() => { workItem.TraceContextBase?.SetActivityToCurrent(); diagnosticActivity = workItem.TraceContextBase?.CurrentActivity; }); ActivityExecutionResult?result; try { await this.dispatchPipeline.RunAsync(dispatchContext, async _ => { if (taskActivity == null) { // This likely indicates a deployment error of some kind. Because these unhandled exceptions are // automatically retried, resolving this may require redeploying the app code so that the activity exists again. // CONSIDER: Should this be changed into a permanent error that fails the orchestration? Perhaps // the app owner doesn't care to preserve existing instances when doing code deployments? throw new TypeMissingException($"TaskActivity {scheduledEvent.Name} version {scheduledEvent.Version} was not found"); } var context = new TaskContext(taskMessage.OrchestrationInstance); context.ErrorPropagationMode = this.errorPropagationMode; HistoryEvent?responseEvent; try { string?output = await taskActivity.RunAsync(context, scheduledEvent.Input); responseEvent = new TaskCompletedEvent(-1, scheduledEvent.EventId, output); } catch (Exception e) when(e is not TaskFailureException && !Utils.IsFatal(e) && !Utils.IsExecutionAborting(e)) { // These are unexpected exceptions that occur in the task activity abstraction. Normal exceptions from // activities are expected to be translated into TaskFailureException and handled outside the middleware // context (see further below). TraceHelper.TraceExceptionInstance(TraceEventType.Error, "TaskActivityDispatcher-ProcessException", taskMessage.OrchestrationInstance, e); string?details = this.IncludeDetails ? $"Unhandled exception while executing task: {e}" : null; responseEvent = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details, new FailureDetails(e)); this.logHelper.TaskActivityFailure(orchestrationInstance, scheduledEvent.Name, (TaskFailedEvent)responseEvent, e); } var result = new ActivityExecutionResult { ResponseEvent = responseEvent }; dispatchContext.SetProperty(result); }); result = dispatchContext.GetProperty <ActivityExecutionResult>(); } catch (TaskFailureException e) { // These are normal task activity failures. They can come from Activity implementations or from middleware. TraceHelper.TraceExceptionInstance(TraceEventType.Error, "TaskActivityDispatcher-ProcessTaskFailure", taskMessage.OrchestrationInstance, e); string?details = this.IncludeDetails ? e.Details : null; var failureEvent = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details, e.FailureDetails); this.logHelper.TaskActivityFailure(orchestrationInstance, scheduledEvent.Name, failureEvent, e); CorrelationTraceClient.Propagate(() => CorrelationTraceClient.TrackException(e)); result = new ActivityExecutionResult { ResponseEvent = failureEvent }; } catch (Exception middlewareException) when(!Utils.IsFatal(middlewareException)) { // These are considered retriable this.logHelper.TaskActivityDispatcherError(workItem, $"Unhandled exception in activity middleware pipeline: {middlewareException}"); throw; } HistoryEvent?eventToRespond = result?.ResponseEvent; if (eventToRespond is TaskCompletedEvent completedEvent) { this.logHelper.TaskActivityCompleted(orchestrationInstance, scheduledEvent.Name, completedEvent); } else if (eventToRespond is null) { // Default response if middleware prevents a response from being generated eventToRespond = new TaskCompletedEvent(-1, scheduledEvent.EventId, null); } var responseTaskMessage = new TaskMessage { Event = eventToRespond, OrchestrationInstance = orchestrationInstance }; await this.orchestrationService.CompleteTaskActivityWorkItemAsync(workItem, responseTaskMessage); } catch (SessionAbortedException e) { // The activity aborted its execution this.logHelper.TaskActivityAborted(orchestrationInstance, scheduledEvent, e.Message); TraceHelper.TraceInstance(TraceEventType.Warning, "TaskActivityDispatcher-ExecutionAborted", orchestrationInstance, "{0}: {1}", scheduledEvent?.Name, e.Message); await this.orchestrationService.AbandonTaskActivityWorkItemAsync(workItem); } finally { diagnosticActivity?.Stop(); // Ensure the activity is stopped here to prevent it from leaking out. if (renewTask != null) { renewCancellationTokenSource.Cancel(); try { // wait the renewTask finish await renewTask; } catch (OperationCanceledException) { // ignore } } } }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { ServiceEventSource.Current.Message("CleanupTask Executed..."); return("CleanupResult"); }
protected override string Execute(DurableTask.Core.TaskContext context, string input) { ServiceEventSource.Current.Message("BadTask Executed..."); throw new InvalidOperationException("BadTask failed."); }