public static async Task <IEnumerable <(int, long)> > Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context, ILogger log)
{
var input = context.GetInput <OrchestratorDto>();
int take = input.EventData.Take;
DateTime endTime = context.CurrentUtcDateTime.AddSeconds(take);
int next = input.EventData.Skip;
List <(int, long)> takenSamples = new List <(int, long)>();
while (context.CurrentUtcDateTime < endTime)
{
var current = next;
long time;
(next, time) = await context.CallActivityAsync <(int, long)>("SendFlightDataSignalRActivity", new SendFlightDataSignalRActivityInput { index = next, count = 20, allplanes = true });
takenSamples.Add((current, time));
var nextCheckpoint = context.CurrentUtcDateTime.AddMilliseconds(1050);
if (!context.IsReplaying)
{
log.LogInformation($"Next check for at {nextCheckpoint}.");
}
await context.CreateTimer(nextCheckpoint, CancellationToken.None);
}
log.LogInformation($"Monitor expiring.");
return(takenSamples);
}
public static async Task CreateCustomerResourceGroup(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating Customer Resource Group: {resourceGroupName}", creationParams.ResourceGroupName);
}
await context.CallActivityAsync(nameof(ResourceCreationActivities.CreateResourceGroup), creationParams);
if (!context.IsReplaying)
{
log.LogWarning("ORC - Registering Resource Providers in: {resourceGroupName}", creationParams.ResourceGroupName);
}
await context.CallActivityAsync(nameof(ResourceCreationActivities.RegisterResourceProviders), creationParams);
if (!context.IsReplaying)
{
log.LogWarning($"ORC - Created Resource Group & Registered Providers in: {creationParams.ResourceGroupName}");
}
}
public async Task LoggerFn(
[OrchestrationTrigger] DurableOrchestrationContextBase context, ILogger logger)
{
Assert.IsNotNull(logger, "Logger injected into function was null");
logger.LogInformation("Activity executing");
}
public static async Task CreateSiteResources(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating Site Resources in: {resourceGroup}", creationParams.ResourceGroupName);
}
// site resources (sql server, sql db, redis cache, storageAccount (record attachments), ???)
var storageRequest = CreateStorageAccountRequest.FromCreationParams(creationParams);
storageRequest.StorageAccountName = ResourceCreationActivities.GenerateStorageAccountName(creationParams, string.Empty);
var t1 = context.CallSubOrchestratorAsync(nameof(CreateSiteSqlServerAndDatabase), creationParams);
var t2 = context.CallActivityAsync <CreateStorageAccountResult>(nameof(ResourceCreationActivities.CreateStorageAccount), storageRequest);
await Task.WhenAll(t1, t2);
if (!context.IsReplaying)
{
log.LogWarning($"ORC - Created Storage Account Name: {t2.Result.StorageAccountName} - Primary Key: {t2.Result.PrimaryKey.KeyName}, {t2.Result.PrimaryKey.Value}");
log.LogWarning($"ORC - Created Site Resources in Resource Group: {creationParams.ResourceGroupName}");
}
}
private static Task <ConfirmParkingResponse> ConfirmParking(
ConfirmParkingRequest request,
LicensePlateRegistration licensePlateRegistration,
DurableOrchestrationContextBase context)
{
Task <ConfirmParkingResponse> confirmTask;
switch (licensePlateRegistration.Type)
{
case LicensePlateType.Appointment:
confirmTask = context.CallActivityAsync <ConfirmParkingResponse>(
nameof(ConfirmParkingForAppointment),
request);
break;
case LicensePlateType.Employee:
confirmTask = context.CallActivityAsync <ConfirmParkingResponse>(
nameof(ConfirmParkingForEmployee),
request);
break;
default:
var unknownLicencePlateResponse = ConfirmParkingResponseBuilder.BuildWithFailedUnknownLicensePlate(request.ParkingGarageName);
confirmTask = Task.FromResult(unknownLicencePlateResponse);
break;
}
return(confirmTask);
}
public async Task <PlanetResidents> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var planetName = context.GetInput <string>();
var result = new PlanetResidents();
var planetResult = await context.CallActivityAsync <Planet>(
nameof(SearchPlanetActivity),
planetName);
if (planetResult != null)
{
result.PlanetName = planetResult.Name;
var tasks = new List <Task <string> >();
foreach (var residentUrl in planetResult.ResidentUrls)
{
tasks.Add(
context.CallActivityAsync <string>(
nameof(GetCharacterActivity),
residentUrl)
);
}
await Task.WhenAll(tasks);
result.Residents = tasks.Select(task => task.Result).ToArray();
}
return(result);
}
public static async Task CreateLongRunningTimer(
this DurableOrchestrationContextBase target,
DateTime fireAt,
CancellationToken token)
{
if (fireAt < target.CurrentUtcDateTime.AddDays(7))
{
await target.CreateTimer(fireAt, token);
}
else
{
var diff = fireAt - target.CurrentUtcDateTime;
while (diff > TimeSpan.Zero)
{
if (diff > TimeSpan.FromDays(7))
{
await target.CreateTimer(target.CurrentUtcDateTime.AddDays(7), token);
diff -= TimeSpan.FromDays(7);
}
else
{
await target.CreateTimer(target.CurrentUtcDateTime.Add(diff), token);
diff = TimeSpan.Zero;
}
}
}
}
public static async Task <string> ProcessOrderV2(
[OrchestrationTrigger] DurableOrchestrationContextBase ctx,
ILogger log)
{
var order = ctx.GetInput <Order>();
if (!ctx.IsReplaying)
{
log.LogInformation($"Processing order {order.Id}");
}
await ctx.CallActivityAsync("A_SaveOrderToDatabase", order);
// create files in parallel
var pdfTask = ctx.CallActivityAsync <string>("A_CreatePersonalizedPdf", order);
var videoTask = ctx.CallActivityAsync <string>("A_CreateWatermarkedVideo", order);
await Task.WhenAll(pdfTask, videoTask);
var pdfLocation = pdfTask.Result;
var videoLocation = videoTask.Result;
await ctx.CallActivityAsync("A_SendOrderConfirmationEmail", (order, pdfLocation, videoLocation));
return("Order processed successfully");
}
public async Task <CharacterInfo> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var name = context.GetInput <string>();
var result = new CharacterInfo();
var characterResult = await context.CallActivityAsync <Character>(
nameof(SearchCharacterActivity),
name);
result.Name = characterResult.Name;
var homeWorldResult = await context.CallActivityAsync <string>(
nameof(GetPlanetActivity),
characterResult.PlanetUrl);
result.HomeWorld = homeWorldResult;
var speciesResult = await context.CallActivityAsync <Species>(
nameof(GetSpeciesActivity),
characterResult.SpeciesUrl.FirstOrDefault());
result.Species = speciesResult.Name;
var speciesHomeWorldResult = await context.CallActivityAsync <string>(
nameof(GetPlanetActivity),
speciesResult.HomeWorld);
result.SpeciesHomeWorld = speciesHomeWorldResult;
return(result);
}
public static Task DurableFunctionWithSeparateActivityInput(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
return(context.CallActivityAsync(nameof(ActivityVerifyingInput), new TestFunctionInput()
{
Token = "activity"
}));
}
public static async Task DurableFunctionWithRetryFailingActivity(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
await context.CallActivityWithRetryAsync(
nameof(FailAtGivenCallNoActivity),
new RetryOptions(TimeSpan.FromMilliseconds(1), 2) { },
new RetryingActivitySetup(-1));
}
public static async Task <string> Run([OrchestrationTrigger] DurableOrchestrationContextBase context, ILogger log, [Inject] IGreeter greeter)
{
var name = context.GetInput <string>();
var greeting = greeter.Greet(name);
var primaryGoodbye = await context.CallActivityAsync <string>("PrimaryGoodbye2", name);
var secondaryGoodbye = await context.CallActivityAsync <string>("SecondaryGoodbye2", name);
return($"{greeting} {primaryGoodbye} or {secondaryGoodbye}");
}
public static async Task CalendarUpdate(
[OrchestrationTrigger] DurableOrchestrationContextBase context
)
{
await context.CallActivityAsync(nameof(GoogleTokenServer.RefreshGoogleTokenActivity), string.Empty);
await context.CallActivityAsync(nameof(MSATokenServer.RefreshMSATokenActivity), string.Empty);
await context.CallActivityAsync(nameof(SignalRHandler.UpdateCalendarActivity), string.Empty);
}
public async Task <string> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var result = await context.CallActivityAsync <string>(
nameof(HelloWorldActivity),
null);
return(result);
}
public static async Task <List <string> > Run([OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var outputs = new List <string>();
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Seattle"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Columbus"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Marysville"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "London"));
return(outputs);
}
public static async Task <List <string> > Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var outputs = new List <string>();
outputs.Add(await context.CallActivityAsync <string>("BackgroundVerification", "name"));
outputs.Add(await context.CallActivityAsync <string>("RegisterDriver", "Seattle"));
outputs.Add(await context.CallActivityAsync <string>("BookTraining", "London"));
// returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
return(outputs);
}
public static async Task <List <string> > Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var outputs = new List <string>();
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Tokyo"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Seattle"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "London"));
// returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
return(outputs);
}
public static async Task ImageUpdate(
[OrchestrationTrigger] DurableOrchestrationContextBase context
)
{
await context.CallActivityAsync(nameof(Storage.CheckConfigurationActivity), string.Empty);
await context.CallActivityAsync(nameof(MSATokenServer.RefreshMSATokenActivity), string.Empty);
string imageUpdateMessage = await context.CallActivityAsync <string>(nameof(ImageHandler.RollImageActivity), string.Empty);
await context.CallActivityAsync(nameof(SignalRHandler.UpdateImageActivity), imageUpdateMessage);
}
public static async Task <List <string> > RunOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var outputs = new List <string>();
// Replace "hello" with the name of your Durable Activity Function.
outputs.Add(await context.CallActivityAsync <string>("DurableFunctions_Hello", "Tokyo"));
outputs.Add(await context.CallActivityAsync <string>("DurableFunctions_Hello", "Seattle"));
outputs.Add(await context.CallActivityAsync <string>("DurableFunctions_Hello", "London"));
return(outputs);
}
public async Task <string> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var nrOfChars = context.GetInput <int>();
var result = await context.CallActivityAsync <string>(
nameof(LargeMessageActivity),
nrOfChars);
return(result);
}
public static async Task <string> RunOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var score = context.GetInput <HighScore>();
var blobUri = await context.CallActivityAsync <string>(
nameof(QRCodeGeneratorActivity),
score);
return(blobUri);
}
public async Task <string> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var name = context.GetInput <string>();
var result = await context.CallActivityAsync <string>(
nameof(HelloNameActivity),
name);
return(result);
}
public async Task <string> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var sleepTimeSeconds = context.GetInput <int>();
var result = await context.CallActivityAsync <string>(
nameof(SleepingActivity),
sleepTimeSeconds);
return(result);
}
public static async Task Func([OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var data = await context.CallActivityAsync <string[]>(GetDataActivity.Name, null);
var tasks = data.Select(x => context.CallActivityAsync <bool>(ProcessActivity.Name, x));
var results = await Task.WhenAll(tasks);
if (results.Any(x => !x))
{
await context.CallActivityAsync(ErrorNotifyActivity.Name, null);
}
}
public async Task <string> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var result = await context.CallActivityWithRetryAsync <string>(
nameof(FailingActivity),
new RetryOptions(
firstRetryInterval : TimeSpan.FromSeconds(5),
maxNumberOfAttempts : 3),
string.Empty);
return(result);
}
public static async Task <string[]> OrchestrationClientFunction(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var outputs = new string[3];
outputs[0] = await context.CallActivityAsync <string>(nameof(ActivityFunction), "Tokyo");
outputs[1] = await context.CallActivityAsync <string>(nameof(ActivityFunction), "Seattle");
outputs[2] = await context.CallActivityAsync <string>(nameof(ActivityFunction), "London");
return(outputs);
}
public static async Task <ParkingOrchestrationResponse> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger logger)
{
if (!context.IsReplaying)
{
logger.LogInformation($"Started {nameof(ParkingGarageCarEntryOrchestration)} with InstanceId: {context.InstanceId}.");
}
var request = context.GetInput <ParkingOrchestrationRequest>();
var licensePlateResult = await context.CallActivityAsync <LicensePlateRegistration>(
nameof(GetLicensePlateRegistration),
request.LicensePlateNumber);
var confirmParkingRequest = ConfirmParkingRequestBuilder.Build(request.ParkingGarageName, licensePlateResult);
var confirmParkingResponse = await ConfirmParking(confirmParkingRequest, licensePlateResult, context);
if (confirmParkingResponse.IsSuccess)
{
await context.CallActivityAsync(
nameof(OpenGate),
confirmParkingResponse.ParkingGarageName);
}
else
{
var displayMessageRequest = DisplayMessageRequestBuilder.Build(
confirmParkingResponse.ParkingGarageName,
confirmParkingResponse.Message);
await context.CallActivityAsync(
nameof(DisplayMessage),
displayMessageRequest);
}
if (licensePlateResult.Type == LicensePlateType.Appointment)
{
var sendNotificationRequest = SendNotificationRequestBuilder.BuildWithAppointmentHasArrived(
licensePlateResult.ContactPerson,
licensePlateResult.Name);
await context.CallActivityAsync(
nameof(SendNotification),
sendNotificationRequest);
}
var parkingOrchestrationResponse = ParkingOrchestrationResponseBuilder.Build(
licensePlateResult,
confirmParkingResponse.IsSuccess);
return(parkingOrchestrationResponse);
}
public static async Task Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var myGuid = System.Guid.NewGuid();
log.LogWarning($"myGuid: {myGuid}");
await context.CallActivityAsync(nameof(ActivityA), "1");
await context.CallActivityAsync(nameof(ActivityA), "2");
await context.CallActivityAsync(nameof(ActivityA), "3");
}
public static async Task <List <string> > Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var outputs = new List <string>();
//context.GetInput();
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Seattle"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Utrecht"));
outputs.Add(await context.CallActivityAsync <string>("E1_SayHello", "Future Tech"));
await context.CallActivityAsync <string>("SendSignalRMessageActivity", new SignalRDto { id = context.InstanceId, message = $"Result: {String.Join(" ", outputs)}", progress = 100 });
return(outputs);
}
public static async Task <bool> RunAsync(
[OrchestrationTrigger] DurableOrchestrationContextBase context, ExecutionContext eContext)
{
_client = Client.InitializeClient(eContext.FunctionAppDirectory);
var place = context.GetInput <Place>();
try
{
log.Information("Calling CreatePlace function");
place.Id = await context.CallActivityAsync <int>(PlacesConstants.CreatePlace, place);
}
catch (Exception ex)
{
log.Error(ex, $"Error occured in CreatePlace function {ex.Message} ");
}
try
{
log.Information($"Calling UpdatePlace function for Place with Id: {place.Id}");
place = await context.CallActivityAsync <Place>(PlacesConstants.UpdatePlace, place.Id);
}
catch (Exception ex)
{
log.Error(ex, $"Error occured in UpdatePlace function {ex.Message}");
}
try
{
log.Information($"Calling DeletePlace function for Place with Id: {place.Id}");
var deleted = await context.CallActivityAsync <bool>(PlacesConstants.DeletePlace, place.Id);
}
catch (Exception ex)
{
log.Error(ex, $"Error occured in DeletePlace function {ex.Message}");
}
try
{
log.Information($"Calling GetPlace function with palceId : {place.Id}");
place = await context.CallActivityAsync <Place>(PlacesConstants.GetPlace, place.Id);
}
catch (Exception ex)
{
log.Error(ex, $"Error occured in GetPlace function {ex.Message}");
}
return(place != null);
}
