protected override string Execute(DurableTask.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.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 string Execute(DurableTask.TaskContext context, string user)
{
string message = null;
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);
}
protected override int Execute(DurableTask.TaskContext context, int[] chunk)
{
if (chunk == null || chunk.Length != 2)
{
throw new ArgumentException("chunk");
}
Console.WriteLine("Compute Sum for " + chunk[0] + "," + chunk[1]);
int 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.TaskContext context, string input)
{
Console.WriteLine("CleanupTask Executed...");
return("CleanupResult");
}
protected override string Execute(DurableTask.TaskContext context, string input)
{
Console.WriteLine("BadTask Executed...");
throw new InvalidOperationException("BadTask failed.");
}
protected override async Task OnProcessWorkItem(BrokeredMessage message)
{
Utils.CheckAndLogDeliveryCount(message, taskHubDescription.MaxTaskActivityDeliveryCount, this.orchestratorQueueName);
Task renewTask = null;
var renewCancellationTokenSource = new CancellationTokenSource();
try
{
TaskMessage taskMessage = await Utils.GetObjectFromBrokeredMessageAsync <TaskMessage>(message);
OrchestrationInstance orchestrationInstance = taskMessage.OrchestrationInstance;
if (orchestrationInstance == null || string.IsNullOrWhiteSpace(orchestrationInstance.InstanceId))
{
throw TraceHelper.TraceException(TraceEventType.Error,
new InvalidOperationException("Message does not contain any OrchestrationInstance information"));
}
if (taskMessage.Event.EventType != EventType.TaskScheduled)
{
throw TraceHelper.TraceException(TraceEventType.Critical,
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(message, renewCancellationTokenSource.Token));
// TODO : pass workflow instance data
var context = new TaskContext(taskMessage.OrchestrationInstance);
HistoryEvent eventToRespond = null;
try
{
string output = await taskActivity.RunAsync(context, scheduledEvent.Input);
eventToRespond = new TaskCompletedEvent(-1, scheduledEvent.EventId, output);
}
catch (TaskFailureException e)
{
TraceHelper.TraceExceptionInstance(TraceEventType.Error, taskMessage.OrchestrationInstance, e);
string details = IncludeDetails ? e.Details : null;
eventToRespond = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details);
}
catch (Exception e)
{
TraceHelper.TraceExceptionInstance(TraceEventType.Error, taskMessage.OrchestrationInstance, e);
string details = IncludeDetails
? string.Format("Unhandled exception while executing task: {0}\n\t{1}", e, e.StackTrace)
: null;
eventToRespond = new TaskFailedEvent(-1, scheduledEvent.EventId, e.Message, details);
}
var responseTaskMessage = new TaskMessage();
responseTaskMessage.Event = eventToRespond;
responseTaskMessage.OrchestrationInstance = orchestrationInstance;
BrokeredMessage responseMessage = Utils.GetBrokeredMessageFromObject(responseTaskMessage,
settings.MessageCompressionSettings,
orchestrationInstance, "Response for " + message.MessageId);
responseMessage.SessionId = orchestrationInstance.InstanceId;
using (var ts = new TransactionScope())
{
workerQueueClient.Complete(message.LockToken);
deciderSender.Send(responseMessage);
ts.Complete();
}
}
finally
{
if (renewTask != null)
{
renewCancellationTokenSource.Cancel();
renewTask.Wait();
}
}
}
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.");
}
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);
}
catch (Exception e)
{
string details = Utils.SerializeCause(e, DataConverter);
throw new TaskFailureException(e.Message, details);
}
return(serializedReturn);
}
public override string Run(TaskContext context, string input)
{
// will never run
return(string.Empty);
}
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.");
}
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);
}
catch (Exception e)
{
string details = Utils.SerializeCause(e, DataConverter);
throw new TaskFailureException(e.Message, details);
}
return serializedReturn;
}
public override string Run(TaskContext context, string input)
{
// will never run
return string.Empty;
}
protected abstract Task <TResult> ExecuteAsync(TaskContext context, TInput input);
public virtual Task <string> RunAsync(TaskContext context, string input)
{
return(Task.FromResult(Run(context, input)));
}
public abstract string Run(TaskContext context, string input);
