protected override async Task <Null> RunOrchestration(OrchestrationContext context, CounterOrchestrationInput input, ILogger logger)
{
Debug.WriteLine($"Counter: {input.Counter}");
if (!context.IsReplaying)
{
logger.LogInformation("Orchestration started with Input: {input}.", input.Counter);
}
await ScheduleTask <Null>(typeof(Task1), new Task1Input()
{
Text = "Text passed from Orchestration."
});
await ScheduleTask <Null>(typeof(Task2), new Task2Input()
{
Number = 2
});
Task.Delay(100).Wait();
input.Counter--;
if (input.Counter > 0)
{
if (!context.IsReplaying)
{
logger.LogInformation("Orchestration will ContinueAsNew.");
}
context.ContinueAsNew(input);
}
return(new Null());
}
public override async Task <int> RunTask(OrchestrationContext context, RecurringOrchestrationInput input)
{
var testTasks = context.CreateClient <ITestTasks>();
if (targetOchestrationInvocationsCount == 0)
{
// First time, Reset Generation Count variable.
await testTasks.ResetGenerationCounter();
}
int result = await context.CreateSubOrchestrationInstance <int>(input.TargetOrchestrationType,
GetTargetOrchestrationVersion(),
input.TargetOrchestrationInstanceId,
input.TargetOrchestrationInput);
await context.CreateTimer(GetNextExecutionTime(context), true, CancellationToken.None);
if (ShouldRepeatTargetOrchestration())
{
context.ContinueAsNew(input);
}
else
{
// Finally, Reset Generation Count variable.
await testTasks.ResetGenerationCounter();
}
return(result);
}
public override async Task <int> RunTask(OrchestrationContext context, int currentValue)
{
string operation = await this.WaitForOperation();
bool done = false;
switch (operation?.ToLowerInvariant())
{
case "incr":
currentValue++;
break;
case "decr":
currentValue--;
break;
case "end":
done = true;
break;
}
if (!done)
{
context.ContinueAsNew(currentValue);
}
return(currentValue);
}
public override Task <int> RunTask(OrchestrationContext context, int input)
{
if (input > 0)
{
context.ContinueAsNew(input - 1);
}
return(Task.FromResult(input));
}
public override async Task <string> RunTask(OrchestrationContext context, string input)
{
string result = await context.ScheduleTask <string>(typeof(Activity1));
if (string.Equals(input, "THROW", StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException("BADFOOD");
}
if (string.Equals(input, "DONTTHROW", StringComparison.OrdinalIgnoreCase))
{
// nothing
}
else if (string.Equals(input, "WAIT_THROW", StringComparison.OrdinalIgnoreCase))
{
await context.CreateTimer <object>(context.CurrentUtcDateTime.AddSeconds(15), null);
throw new InvalidOperationException("BADFOOD");
}
else if (string.Equals(input, "WAIT_DONTTHROW", StringComparison.OrdinalIgnoreCase))
{
await context.CreateTimer <object>(context.CurrentUtcDateTime.AddSeconds(15), null);
}
else if (string.Equals(input, "WAIT_AND_WAIT_DONTTHROW", StringComparison.OrdinalIgnoreCase))
{
await context.CreateTimer <object>(context.CurrentUtcDateTime.AddSeconds(15), null);
await context.CreateTimer <object>(context.CurrentUtcDateTime.AddSeconds(10), null);
}
else if (string.Equals(input, "WAIT_NEWGEN", StringComparison.OrdinalIgnoreCase))
{
await context.CreateTimer <object>(context.CurrentUtcDateTime.AddSeconds(5), null);
context.ContinueAsNew("WAIT_NEWGEN_STOP");
}
else if (string.Equals(input, "WAIT_NEWGEN_STOP", StringComparison.OrdinalIgnoreCase))
{
await context.CreateTimer <object>(context.CurrentUtcDateTime.AddSeconds(5), null);
context.ContinueAsNew("DONTTHROW");
}
return(result);
}
public override async Task <int> RunTask(OrchestrationContext context, int numberOfGenerations)
{
int count = await context.ScheduleTask <int>(typeof(GenerationSubTask));
numberOfGenerations--;
if (numberOfGenerations > 0)
{
context.ContinueAsNew(numberOfGenerations);
}
return(count);
}
public override async Task <string> RunTask(OrchestrationContext context, string input)
{
string result = await context.ScheduleTask <string>(typeof(HelloActivity), input);
result = input + ":" + result;
if (counter < 3)
{
counter++;
context.ContinueAsNew(result);
}
return(result);
}
public override async Task <int> RunTask(OrchestrationContext context, int numberOfGenerations)
{
int count = await context.ScheduleTask <int>(typeof(GenerationBasicTask));
numberOfGenerations--;
if (numberOfGenerations > 0)
{
context.ContinueAsNew(numberOfGenerations);
}
// This is a HACK to get unit test up and running. Should never be done in actual code.
Result = count;
return(count);
}
public override async Task <int> RunTask(OrchestrationContext context, int numberOfGenerations)
{
int count = await WaitForSignal();
signal.WaitOne();
numberOfGenerations--;
if (numberOfGenerations > 0)
{
context.ContinueAsNew(numberOfGenerations);
}
// This is a HACK to get unit test up and running. Should never be done in actual code.
Result = count.ToString();
return(count);
}
public override async Task <int> RunTask(OrchestrationContext context, int input)
{
if (input > 0)
{
var nextIteration = await context.ScheduleTask <int>(SubtractActivity.Name, SubtractActivity.Version, new SubtractActivity.Input
{
LeftValue = input,
RightValue = 1
});
context.ContinueAsNew(nextIteration);
}
return(input);
}
public override async Task <int> RunTask(OrchestrationContext context, int numberOfGenerations)
{
var testTasks = context.CreateClient <ITestTasks>();
int count = await testTasks.IncrementGenerationCount();
numberOfGenerations--;
if (numberOfGenerations > 0)
{
context.ContinueAsNew(numberOfGenerations);
}
// This is a HACK to get unit test up and running. Should never be done in actual code.
Result = count;
return(count);
}
protected override async Task <Null> RunOrchestration(OrchestrationContext context, TweetOrchestrationInput input, ILogger logger)
{
var outPut = await context.ScheduleTask <GetTweetTaskOutput>(typeof(GetTweetsTask), getTweetsTaskInput());
await context.ScheduleTask <Null>(typeof(SwitchOnLightTask), switchOnLightTaskInput(input.LatestTweetId, outPut.LatestTweetId));
input.LatestTweetId = outPut.LatestTweetId;
await context.CreateTimer(context.CurrentUtcDateTime.AddMinutes(1), "");
logger.LogInformation("Orchestration will ContinueAsNew.");
context.ContinueAsNew(input);
return(new Null());
}
public override async Task <string> RunTask(OrchestrationContext context, int numberOfGenerations)
{
numberOfGenerations--;
if (numberOfGenerations > 0)
{
context.ContinueAsNew(numberOfGenerations);
}
if (numberOfGenerations == 1)
{
throw new InvalidOperationException("Test");
}
Interlocked.Increment(ref Count);
return("done");
}
public override async Task <string> RunTask(OrchestrationContext context, int input)
{
if (input == 0)
{
context.ContinueAsNew(1);
return("continue as new");
}
else if (input == 1)
{
await context.CreateTimer(context.CurrentUtcDateTime, 0);
return("OK");
}
else
{
throw new InvalidOperationException();
}
}
public async override Task <int> RunTask(OrchestrationContext context, TestOrchestrationInput input)
{
Debug.WriteLine($"Orchestration Input: {input.Counter}. IsReplaying: {context.IsReplaying}");
await context.ScheduleTask <TstNull>(typeof(Tests.TaskOrchestration.CounterOrchestration.Task1), "Input1");
await context.ScheduleTask <TstNull>(typeof(Task2), "Input1");
Task.Delay(100).Wait();
input.Counter--;
if (input.Counter > 0)
{
Debug.WriteLine($"ContinueAsNew {input.Counter}");
context.ContinueAsNew(input);
}
return(input.Counter);
}
public override async Task <int> RunTask(OrchestrationContext context, DriverOrchestrationData data)
{
var results = new List <Task <int> >();
var i = 0;
for (; i < data.NumberOfParallelTasks; i++)
{
results.Add(context.CreateSubOrchestrationInstance <int>(typeof(TestOrchestration), data.SubOrchestrationData));
}
int[] counters = await Task.WhenAll(results.ToArray());
int result = counters.Max();
if (data.NumberOfIteration > 1)
{
data.NumberOfIteration--;
context.ContinueAsNew(data);
}
return(result);
}
public async override Task <string> RunTask(OrchestrationContext context, string input)
{
var message = await tcs.Task;
if (message == "stop")
{
return($"{input} is done");
}
else
{
// send a message back to the sender
var senderInstance = new OrchestrationInstance()
{
InstanceId = message
};
context.SendEvent(senderInstance, channelName, $"hi from {input}");
// start over to wait for the next message
context.ContinueAsNew(input);
return("this value is meaningless");
}
}
public override async Task <object> RunTask(OrchestrationContext context, object input)
{
WasRun = true;
context.ContinueAsNew("V3", null);
return(null);
}
public override async Task <string> Execute(OrchestrationContext innerContext, string serializedInput)
{
if (this.operationBatch.Count == 0 && this.lockRequest == null)
{
// we are idle after a ContinueAsNew - the batch is empty.
// Wait for more messages to get here (via extended sessions)
await this.doneProcessingMessages.Task;
}
this.Config.TraceHelper.FunctionStarting(
this.context.HubName,
this.context.Name,
this.context.InstanceId,
this.Config.GetIntputOutputTrace(serializedInput),
FunctionType.Entity,
isReplay: false);
if (this.NumberEventsToReceive > 0)
{
await this.doneProcessingMessages.Task;
}
// Commit the effects of this batch, if
// we have not already run into an internal error
// (in which case we will abort the batch instead of committing it)
if (this.context.InternalError == null)
{
// try to serialize the updated entity state
bool writeBackSuccessful = this.context.TryWriteback(out var serializationErrorMessage);
// Send all buffered outgoing messages
this.context.SendOutbox(innerContext, writeBackSuccessful, serializationErrorMessage);
var jstate = JToken.FromObject(this.context.State);
// continue as new
innerContext.ContinueAsNew(jstate);
}
if (this.context.ErrorsPresent(out var description))
{
this.Config.TraceHelper.FunctionFailed(
this.context.HubName,
this.context.Name,
this.context.InstanceId,
description,
functionType: FunctionType.Entity,
isReplay: false);
}
else
{
this.Config.TraceHelper.FunctionCompleted(
this.context.HubName,
this.context.Name,
this.context.InstanceId,
this.Config.GetIntputOutputTrace(this.context.State.EntityState),
continuedAsNew: true,
functionType: FunctionType.Entity,
isReplay: false);
}
// The return value is not used.
return(string.Empty);
}
public override Task <object> RunTask(OrchestrationContext context, object input)
{
WasRun = true;
context.ContinueAsNew("V3", null);
return(Task.FromResult <object>(null));
}
/// <inheritdoc/>
public override void ContinueAsNew(object input)
{
PreUpdateProperties();
_innerContext.ContinueAsNew(input);
PostUpdateProperties();
}
public override async Task <string> Execute(OrchestrationContext innerContext, string serializedInput)
{
#if !FUNCTIONS_V1
// Adding "Tags" to activity allows using App Insights to query current state of entities
var activity = Activity.Current;
OrchestrationRuntimeStatus status = OrchestrationRuntimeStatus.Running;
DurableTaskExtension.TagActivityWithOrchestrationStatus(status, this.context.InstanceId, true);
#endif
if (this.operationBatch.Count == 0 &&
this.lockRequest == null &&
(this.toBeRescheduled == null || this.toBeRescheduled.Count == 0))
{
// we are idle after a ContinueAsNew - the batch is empty.
// Wait for more messages to get here (via extended sessions)
await this.doneProcessingMessages.Task;
}
if (!this.messageDataConverter.IsDefault)
{
innerContext.MessageDataConverter = this.messageDataConverter;
}
if (!this.errorDataConverter.IsDefault)
{
innerContext.ErrorDataConverter = this.errorDataConverter;
}
this.Config.TraceHelper.FunctionStarting(
this.context.HubName,
this.context.Name,
this.context.InstanceId,
this.Config.GetIntputOutputTrace(serializedInput),
FunctionType.Entity,
isReplay: false);
if (this.NumberEventsToReceive > 0)
{
await this.doneProcessingMessages.Task;
}
// Commit the effects of this batch, if
// we have not already run into an internal error
// (in which case we will abort the batch instead of committing it)
if (this.context.InternalError == null)
{
bool writeBackSuccessful = true;
ResponseMessage serializationErrorMessage = null;
if (this.RollbackFailedOperations)
{
// the state has already been written back, since it is
// done right after each operation.
}
else
{
// we are writing back the state here, after executing
// the entire batch of operations.
writeBackSuccessful = this.context.TryWriteback(out serializationErrorMessage);
}
// Reschedule all signals that were received before their time
this.context.RescheduleMessages(innerContext, this.toBeRescheduled);
// Send all buffered outgoing messages
this.context.SendOutbox(innerContext, writeBackSuccessful, serializationErrorMessage);
var jstate = JToken.FromObject(this.context.State);
// continue as new
innerContext.ContinueAsNew(jstate);
}
if (this.context.ErrorsPresent(out var description))
{
this.Config.TraceHelper.FunctionFailed(
this.context.HubName,
this.context.Name,
this.context.InstanceId,
description,
functionType: FunctionType.Entity,
isReplay: false);
}
else
{
this.Config.TraceHelper.FunctionCompleted(
this.context.HubName,
this.context.Name,
this.context.InstanceId,
this.Config.GetIntputOutputTrace(this.context.State.EntityState),
continuedAsNew: true,
functionType: FunctionType.Entity,
isReplay: false);
}
// The return value is not used.
return(string.Empty);
}