public static async Task <int> PeriodicTask(
[OrchestrationTrigger] DurableOrchestrationContext ctx, TraceWriter log)
{
var timesRun = ctx.GetInput <int>();
timesRun++;
if (!ctx.IsReplaying)
{
log.Info("starting the periodic task activity " + ctx.InstanceId + " " + timesRun);
}
await ctx.CallActivityAsync("A_PeriodicActivity", timesRun);
var nextRun = ctx.CurrentUtcDateTime.AddSeconds(15);
await ctx.CreateTimer(nextRun, CancellationToken.None);
ctx.ContinueAsNew(timesRun);
return(timesRun);
}
public static async Task <string> ProccessTranscriptions([OrchestrationTrigger] DurableOrchestrationContext context)
{
//get list of transactions where status == success
var list = await context.CallActivityAsync <IEnumerable <Transcription> > ("PollCompleteTranscriptions", null);
//for each transaction in the list, download the transcript
foreach (var t in list)
{
var blob = await context.CallActivityAsync <Uri> ("ProcessTranscript", t);
if (blob != null && await context.CallActivityAsync <bool> ("ArchiveAudioBlob", t.RecordingsUrl))
{
await context.CallActivityAsync <bool> ("DeleteTranscript", t);
}
}
return(context.InstanceId);
}
public static async Task IotHubScaleOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context,
TraceWriter log)
{
log.Info("IotHubScaleOrchestrator started");
// launch and wait on the "worker" function
await context.CallActivityAsync(IotHubScaleWorkerName);
// register a timer with the durable functions infrastructure to re-launch the orchestrator in the future
DateTime wakeupTime = context.CurrentUtcDateTime.Add(TimeSpan.FromMinutes(JobFrequencyMinutes));
await context.CreateTimer(wakeupTime, CancellationToken.None);
log.Info(String.Format("IotHubScaleOrchestrator done... tee'ing up next instance in {0} minutes.", JobFrequencyMinutes.ToString()));
// end this 'instance' of the orchestrator and schedule another one to start based on the timer above
context.ContinueAsNew(null);
}
public static async Task GameMonitorWorkflow(
[OrchestrationTrigger] DurableOrchestrationContext context,
ILogger logger)
{
var username = context.GetInput <string>();
logger.LogInformation("Start of game monitor workflow for {user}", username);
var monsterKilled = context.WaitForExternalEvent(KILLMONSTER);
var treasureFound = context.WaitForExternalEvent(GOTTREASURE);
await Task.WhenAll(monsterKilled, treasureFound);
await context.CallActivityAsync(nameof(ConsoleFunctions.AddToQueue),
$"{username} has won the game!");
logger.LogInformation("User {user} won the game.", username);
}
public static async Task <List <Report> > GenerateReports(
[OrchestrationTrigger] DurableOrchestrationContext ctx,
ILogger log)
{
log.LogInformation("Executing orchestrator function");
var payments = ctx.GetInput <List <Payment> >();
var reportTasks = new List <Task <Report> >();
foreach (var paymentGroup in payments.GroupBy(p => p.CardType))
{
var task = ctx.CallActivityAsync <Report>("A_CreateReport", paymentGroup.ToList());
reportTasks.Add(task);
}
var reports = await Task.WhenAll(reportTasks);
return(reports.ToList());
}
public static async Task FullBackupMain([OrchestrationTrigger] DurableOrchestrationContext context, [OrchestrationClient] DurableOrchestrationClient client, ILogger log)
{
var jobs = await context.CallActivityAsync <IEnumerable <FunctionParameters.CollectionBackupJob> >(Names.ResolveCollectionBackupJobs, null);
foreach (var job in jobs)
{
try
{
await context.CallActivityAsync(Names.BackupDocuments, job);
}
catch (Exception ex)
{
log.LogError(ex, $"Error while backing up collection '{job.CollectionLink}'.");
}
}
log.LogInformation($"Completed full backup with a total of {jobs.Count()} collections backed up.");
}
public static async Task ProcessClaimOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context,
ILogger log)
{
var claim = context.GetInput <WhatIfDemoDbDataContext.Claim>();
// Sending mobile notification
await context.CallActivityAsync(nameof(SendMobileNotification), claim);
// Waiting for the claim to be approved
await context.WaitForExternalEvent(nameof(ApproveClaim));
// Saving the claim to DB
var retryOptions = new RetryOptions(TimeSpan.FromSeconds(5), 3);
await context.CallActivityWithRetryAsync <WhatIfDemoDbDataContext.Claim>(nameof(SaveClaimToDb), retryOptions, claim);
log.LogWarning($"Claim {claim.id} processing finished!");
}
public static async Task DebatchCoordinatesFile([OrchestrationTrigger] DurableOrchestrationContext context, ILogger log)
{
log.LogInformation("Starting DebatchCoordinatesFile");
List <List <string> > groupsOfLines = await context.CallActivityAsync <List <List <string> > >(nameof(GetCoordinates), null);
log.LogInformation("retreived coordinates file as Stream");
List <Task> parallelTasks = new List <Task>();
foreach (var group in groupsOfLines)
{
parallelTasks.Add(context.CallActivityAsync(nameof(ProcessGroupOfLines), group));
}
await Task.WhenAll(parallelTasks);
log.LogInformation("All done");
}
public static async Task OrchestratorThrowWithRetry([OrchestrationTrigger] DurableOrchestrationContext ctx)
{
string message = ctx.GetInput <string>();
RetryOptions options = new RetryOptions(TimeSpan.FromSeconds(5), 3);
// Specify an explicit sub-orchestration ID that can be queried by the test driver.
Guid subInstanceId = await ctx.CallActivityAsync <Guid>(nameof(TestActivities.NewGuid), null);
ctx.SetCustomStatus(subInstanceId.ToString("N"));
// This throw happens in the implementation of an orchestrator.
await ctx.CallSubOrchestratorWithRetryAsync(
nameof(TestOrchestrations.ThrowOrchestrator),
options,
subInstanceId.ToString("N"),
message);
}
public static async Task BatchActor([OrchestrationTrigger] DurableOrchestrationContext ctx)
{
var requiredItems = new HashSet <string>(new[] { @"item1", @"item2", @"item3", @"item4", @"item5" });
// If an item was sent in during StartAsNew() this handles that
string itemName = ctx.GetInput <string>();
requiredItems.Remove(itemName);
while (requiredItems.Any())
{
itemName = await ctx.WaitForExternalEvent <string>("newItem");
requiredItems.Remove(itemName);
}
// we've received events for all the required items; safe to bail now!
}
public static async Task <WordPairs> RunOrchestrator([OrchestrationTrigger] DurableOrchestrationContext context)
{
IEnumerable <string> textFileNames = await context.CallActivityAsync <IEnumerable <string> >("ListFiles", "out-container");
List <Task <string> > tasks = new List <Task <string> >();
foreach (var filename in textFileNames)
{
tasks.Add(context.CallActivityAsync <string>("RetrieveContent", filename));
}
var completedTasks = await Task.WhenAll(tasks);
var result = CalculateMostUsed(completedTasks);
await context.CallActivityAsync("WriteToBlob", result);
return(result);
}
public static async Task TopOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context, ILogger log)
{
if (!context.IsReplaying)
{
log.LogInformation($"{nameof(TopOrchestrator)} - Start. InstanceId={context.InstanceId}");
}
for (int i = 0; i < 100; i++)
{
await context.CallSubOrchestratorAsync <string>(nameof(SubOrchestrator), i);
}
if (!context.IsReplaying)
{
log.LogInformation($"{nameof(TopOrchestrator)} - End. InstanceId={context.InstanceId}");
}
}
public static async Task StartKokuhakuWorkflow(
[OrchestrationTrigger] DurableOrchestrationContext context,
TraceWriter log)
{
var info = context.GetInput <KokuhakuInformation>();
await context.CallActivityAsync(nameof(SendEmail), info);
var approved = await context.WaitForExternalEvent <bool>("Approval");
if (approved)
{
await context.CallActivityAsync(nameof(Approved), info);
}
else
{
await context.CallActivityAsync(nameof(Reject), info);
}
}
public static async Task <IEnumerable <WeatherDto> > Run([OrchestrationTrigger] DurableOrchestrationContext context)
{
var date = context.GetInput <DateTime>();
var requests = new Task <WeatherDto> [3];
// fan out
for (var i = 0; i < 3; i++)
{
requests[i] = context.CallActivityAsync <WeatherDto>("GetWeatherFromApi", date.AddDays(i));
}
// fan in
await Task.WhenAll(requests);
// aggregate results
return(requests.Select(x => x.Result).Where(x => x != null));
}
public static async Task <dynamic> RunOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
var tasks = new List <Task <OrderDetails> >();
var orderTotals = new List <double>();
var transactions = await context.CallActivityAsync <IEnumerable <StripeCharge> >("Durable_GetTransactions", null);
foreach (var transaction in transactions)
{
tasks.Add(context.CallActivityAsync <OrderDetails>("Durable_GetOrderProcess", transaction));
}
await Task.WhenAll(tasks);
return(from details in tasks
group details by details.Result.status into s
select new { status = s.Key, count = s.Count() });
}
public static async Task <List <string> > Run([OrchestrationTrigger] DurableOrchestrationContext context)
{
var outputs = new List <string>();
var ValidateMe = context.GetInput <string>();
JObject stuff = JObject.Parse(ValidateMe);
Documento doc = JsonConvert.DeserializeObject <Documento>(ValidateMe);
outputs.Add(await context.CallActivityAsync <string>("ValidationOne", doc));
outputs.Add(await context.CallActivityAsync <string>("ValidationTwo", doc));
outputs.Add(await context.CallActivityAsync <string>("ValidationThree", doc));
outputs.Add(await context.CallActivityAsync <string>("ValidationFour", doc));
outputs.Add(await context.CallActivityAsync <string>("ValidationFive", doc));
outputs.Add(await context.CallActivityAsync <string>("ValidationSix", doc));
outputs.Add(ValidateMe);
return(outputs);
}
public static async Task NewOrderWorkflow(
[OrchestrationTrigger] DurableOrchestrationContext ctx,
ILogger log)
{
var order = ctx.GetInput <Order>();
if (!ctx.IsReplaying)
{
log.LogInformation($"Starting new order workflow for {order.Id}.");
}
await ctx.CallActivityAsync(nameof(SaveOrderToDatabaseActivity), order);
await ctx.CallActivityAsync(nameof(CreateLicenseFileActivity), order);
await ctx.CallActivityAsync(nameof(EmailLicenseFileActivity), order);
log.LogInformation($"Order {order.Id} processed successfully.");
}
public static async Task <string> RunOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context, ILogger log)
{
log.LogInformation($"************** RunOrchestrator method executing ********************");
VirtualMachineIds virtualMachineIds = context.GetInput <VirtualMachineIds>();
// Fanning out
log.LogInformation($"************** Fanning out ********************");
var parallelActivities = new List <Task <string> >();
foreach (var vmid in virtualMachineIds.VirtualMachineIdList)
{
log.LogInformation($"************** vmid = " + vmid);
// Start a new activity function and capture the task reference
Task <string> task = context.CallActivityAsync <string>("vmManagementOrchestration_ToggleVM", vmid);
// Store the task reference for later
parallelActivities.Add(task);
}
// Wait until all the activity functions have done their work
log.LogInformation($"************** 'Waiting' for parallel results ********************");
await Task.WhenAll(parallelActivities);
log.LogInformation($"************** All activity functions complete ********************");
// Now that all parallel activity functions have completed,
// fan in AKA aggregate the results, in this case into a single
// string using a StringBuilder
log.LogInformation($"************** fanning in ********************");
var sb = new StringBuilder();
foreach (var completedParallelActivity in parallelActivities)
{
sb.AppendLine(completedParallelActivity.Result);
}
return(sb.ToString());
}
public async Task Run([OrchestrationTrigger] DurableOrchestrationContext context,
ILogger log)
{
var teamModel = context.GetInput <TeamModel>();
if (!teamModel.Initialized)
{
await context.CallSubOrchestratorWithRetryAsync(nameof(InitializeOrchestrator), _options.AsRetryOptions(), teamModel);
teamModel.Initialized = true;
}
try
{
var weeks = context.CurrentUtcDateTime.Date
.Range(_options.PastWeeks, _options.FutureWeeks, _options.StartDayOfWeek);
var weekTasks = weeks
.Select(startDate => new WeekModel
{
StartDate = startDate,
StoreId = teamModel.StoreId,
TeamId = teamModel.TeamId
})
.Select(weekModel => context.CallSubOrchestratorWithRetryAsync(nameof(WeekOrchestrator), _options.AsRetryOptions(), weekModel));
await Task.WhenAll(weekTasks);
}
catch (Exception ex) when(_options.ContinueOnError)
{
log.LogTeamError(ex, teamModel);
}
if (_options.FrequencySeconds < 0)
{
return;
}
var dueTime = context.CurrentUtcDateTime.AddSeconds(_options.FrequencySeconds);
await context.CreateTimer(dueTime, CancellationToken.None);
context.ContinueAsNew(teamModel);
}
public static async Task Run(
[OrchestrationTrigger] DurableOrchestrationContext orchestrationContext,
ILogger logger)
{
logger.LogInformation("{0} function processed a request.", nameof(InitialLoadingOrchestratorFunction));
int pageNumber = 1;
while (true)
{
logger.LogInformation("Processing {0} page", pageNumber);
ShowsPage page = await orchestrationContext.CallActivityAsync <ShowsPage>(nameof(GetShowsPageFunction), pageNumber);
if (page.IsLastPage)
{
break;
}
IEnumerable <Task <CastInfo> > castInfosTasks = page.Shows.Select(
show => orchestrationContext.CallActivityAsync <CastInfo>(nameof(GetShowCastFunction), show.Id));
var castInfos = await Task.WhenAll(castInfosTasks);
var showsWithCast = new List <ShowWithCast>(page.Shows.Count);
foreach (var castInfo in castInfos)
{
var showToEnrich = page.Shows.First(show => show.Id == castInfo.ShowId);
showsWithCast.Add(
new ShowWithCast
{
Id = showToEnrich.Id,
Name = showToEnrich.Name,
Updated = showToEnrich.Updated,
Cast = castInfo.Cast
});
}
await orchestrationContext.CallActivityAsync(nameof(InsertShowsFunction), showsWithCast);
pageNumber++;
}
}
public static async Task <string> Run(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
string result = string.Empty;
string requestID = context.GetInput <string>()?.Trim();
if (string.IsNullOrEmpty(requestID))
{
requestID = Guid.NewGuid().ToString();
}
var actvityInfo = new ActivityCreateBlobInfo()
{
BlobContainer = requestID,
NumberOfRecords = 100,
};
int loopCount = 10;
var tasks = new List <Task <string> >();
for (int i = 0; i < loopCount; i++)
{
actvityInfo.BlobName = $"{i+1}.json";
actvityInfo.NumberToStart = i * actvityInfo.NumberOfRecords + 1;
tasks.Add(
context.CallActivityAsync <string>(
"WriteRecordsToBlob",
actvityInfo)
);
}
//case using WhenAll
string[] results = await Task.WhenAll(tasks);
//.ConfigureAwait(false); 사용하면 안됨.
// 기본값 true로 해서 SynchronizationContext로 동기화하지 않는다면, 끝났다는 정보를 API가 제공하지 못함.
// 즉, 실행이 끝났는대도 API는 running을 알려주게 됨.
result = JsonConvert.SerializeObject(results);
return(result);
}
public static async Task <long> DiskUsage([OrchestrationTrigger] DurableOrchestrationContext ctx)
{
string directory = ctx.GetInput <string>();
string[] files = await ctx.CallActivityAsync <string[]>(nameof(TestActivities.GetFileList), directory);
var tasks = new Task <long> [files.Length];
for (int i = 0; i < files.Length; i++)
{
tasks[i] = ctx.CallActivityAsync <long>(nameof(TestActivities.GetFileSize), files[i]);
}
await Task.WhenAll(tasks);
long totalBytes = tasks.Sum(t => t.Result);
return(totalBytes);
}
public static async Task <int> TryCatchLoop([OrchestrationTrigger] DurableOrchestrationContext ctx)
{
int iterations = ctx.GetInput <int>();
int catchCount = 0;
for (int i = 0; i < iterations; i++)
{
try
{
await ctx.CallActivityAsync(nameof(TestActivities.ThrowActivity), "Kah-BOOOOOM!!!");
}
catch (FunctionFailedException)
{
catchCount++;
}
}
return(catchCount);
}
public static async Task <List <string> > RunOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
var outputs = new List <string>();
outputs.Add(await context.CallActivityAsync <string>(nameof(StringReturnActivity), "Tokyo"));
var result2 = await context.CallActivityAsync <string>(nameof(Workaround1FixedActivity), "Novi Sad");
var result = JsonConvert.DeserializeObject <SelfRefClass>(result2, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
PreserveReferencesHandling = PreserveReferencesHandling.Objects,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize
});
outputs.Add(result.Name);
return(outputs);
}
public static async Task <List <string> > Orchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
var input = context.GetInput <Input>();
var outputs = new List <Task <string> >();
// Replace "hello" with the name of your Durable Activity Function.
outputs.Add(context.CallActivityAsync <string>("Function1_Hello", "Tokyo"));
outputs.Add(context.CallActivityAsync <string>("Function1_Hello", "Seattle"));
context.SetCustomStatus("Seattle klart");
outputs.Add(context.CallActivityAsync <string>("Function1_Hello", "London"));
await Task.WhenAll(outputs);
// returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
return(outputs);
}
public static async Task Run(
[OrchestrationTrigger] DurableOrchestrationContext counterContext,
TraceWriter log)
{
int numberOfExecutions = 0;
try
{
numberOfExecutions = counterContext.GetInput <int>();
log.Info($"********{counterContext.InstanceId}: Current counter state is {numberOfExecutions}. isReplaying: {counterContext.IsReplaying} Waiting for next operation.**************");
log.Info($"*********{counterContext.InstanceId}: Call activity ExistFile from {numberOfExecutions}*************");
var existsFile = await counterContext.CallActivityAsync <bool>("ExistFile", numberOfExecutions.ToString());
if (existsFile)
{
log.Info($"*********{counterContext.InstanceId}: EXISTS FILE {numberOfExecutions}.json *************");
log.Info($"*********{counterContext.InstanceId}: Call activity AddCRM from {numberOfExecutions}*************");
await counterContext.CallActivityAsync("AddCRM", numberOfExecutions.ToString());
log.Info($"*********Add element to queeue *************");
await counterContext.CallActivityAsync("AddQueueTrigger", numberOfExecutions.ToString());
log.Info($"*********END element to queeue *************");
}
else
{
log.Info($"*********{counterContext.InstanceId}: NO EXIST FILE {numberOfExecutions}.json *************");
}
log.Info($"*********Return {counterContext.InstanceId}: FINISH from {numberOfExecutions}*************");
}
catch (Exception ex)
{
log.Error($"**********ERROR General execution: {numberOfExecutions} - {counterContext.IsReplaying} - {counterContext.InstanceId} *********", ex.InnerException != null ? ex.InnerException : ex);
if (!counterContext.IsReplaying)
{
log.Info($"**********RETRY execution: {numberOfExecutions} - {counterContext.InstanceId} *********");
counterContext.ContinueAsNew(numberOfExecutions);
}
}
}
public static bool VerifyUniqueGuids([OrchestrationTrigger] DurableOrchestrationContext ctx)
{
HashSet <Guid> guids = new HashSet <Guid>();
for (int i = 0; i < 10000; i++)
{
Guid newGuid = ctx.NewGuid();
if (guids.Contains(newGuid))
{
return(false);
}
else
{
guids.Add(newGuid);
}
}
return(true);
}
public static async Task MakeTemplate(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
var list = context.GetInput <List <string> >() ?? new List <string>();
var value = await context.WaitForExternalEvent <string>(Consts.DurableEventNameAddToTemplate);
if (value.StartsWith(Consts.FinishMakingTemplate))
{
// 完成したリストをReplyトークンとともに返信Activityに渡す
var token = value.Replace(Consts.FinishMakingTemplate + "_", string.Empty);
await context.CallActivityAsync(nameof(SendTemplates), (token, list));
}
else
{
// リストにセリフを追加しオーケストレーターを再実行
list.Add(value);
context.ContinueAsNew(list);
}
}
public static async Task <List <string> > RunOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
var outputs = new List <string>();
String content = context.GetInput <String>();
UpdateBaseImageRequest request = JsonConvert.DeserializeObject <UpdateBaseImageRequest>(content);
request.stack = "php";
outputs.Add(await context.CallActivityAsync <string>("HttpUpdateBaseImage_UpdateStack", request));
request.stack = "dotnetcore";
outputs.Add(await context.CallActivityAsync <string>("HttpUpdateBaseImage_UpdateStack", request));
request.stack = "python";
outputs.Add(await context.CallActivityAsync <string>("HttpUpdateBaseImage_UpdateStack", request));
request.stack = "node";
outputs.Add(await context.CallActivityAsync <string>("HttpUpdateBaseImage_UpdateStack", request));
return(outputs);
}
public static async Task <List <BusinessRules.RuleResponse> > Run(
[OrchestrationTrigger] DurableOrchestrationContext context)
{
var data = await context.CallActivityAsync <BusinessRules.CustomersData>("XmlDeserialiser");
var tasks = new List <Task <BusinessRules.RuleResponse> >();
for (int i = 0; i < 300; i++)
{
tasks.Add(context.CallActivityAsync <BusinessRules.RuleResponse>("Rule1", data));
// tasks.Add(context.CallActivityAsync<BusinessRules.RuleResponse>("Rule2", data)); -
// tasks.Add(context.CallActivityAsync<BusinessRules.RuleResponse>("Rule2", data)); -
}
await Task.WhenAll(tasks);
var result = tasks.Select(x => x.Result).ToList();
return(result);
}
