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 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 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 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 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 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}");
}
}
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 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 sleepTimeSeconds = context.GetInput <int>();
var result = await context.CallActivityAsync <string>(
nameof(SleepingActivity),
sleepTimeSeconds);
return(result);
}
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 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 <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);
}
public static async Task <string> ProcessOrderV3(
[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);
string pdfLocation = null;
string videoLocation = null;
try
{
// 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);
pdfLocation = pdfTask.Result;
videoLocation = videoTask.Result;
}
catch (Exception ex)
{
if (!ctx.IsReplaying)
{
log.LogError($"Failed to create files", ex);
}
}
if (pdfLocation != null && videoLocation != null)
{
await ctx.CallActivityWithRetryAsync("A_SendOrderConfirmationEmail",
new RetryOptions(TimeSpan.FromSeconds(30), 3),
(order, pdfLocation, videoLocation));
return("Order processed successfully");
}
await ctx.CallActivityWithRetryAsync("A_SendProblemEmail",
new RetryOptions(TimeSpan.FromSeconds(30), 3),
order);
return("There was a problem processing this order");
}
public async Task <IActionResult> LoadWaterAllocationDataOrchestration([OrchestrationTrigger] DurableOrchestrationContextBase context, ILogger log)
{
var runId = context.GetInput <string>();
log.LogInformation($"Load Water Allocation Data Orchestration [{runId}]");
var parallelTasks = new List <Task <StatusHelper> >
{
context.CallActivityAsync <StatusHelper>(FunctionNames.LoadOrganizations, runId)
, context.CallActivityAsync <StatusHelper>(FunctionNames.LoadSites, runId)
, context.CallActivityAsync <StatusHelper>(FunctionNames.LoadWaterSources, runId)
, context.CallActivityAsync <StatusHelper>(FunctionNames.LoadMethods, runId)
, context.CallActivityAsync <StatusHelper>(FunctionNames.LoadRegulatoryOverlays, runId)
, context.CallActivityAsync <StatusHelper>(FunctionNames.LoadReportingUnits, runId)
, context.CallActivityAsync <StatusHelper>(FunctionNames.LoadVariables, runId)
};
var parallelResults = await Task.WhenAll(parallelTasks);
foreach (var result in parallelResults)
{
log.LogInformation(JsonConvert.SerializeObject(result));
}
if (parallelResults.Any(a => !a.Status))
{
throw new Exception("Failure Loading Initial Data");
}
var results = new List <StatusHelper>
{
await context.CallActivityAsync <StatusHelper>(FunctionNames.LoadAggregatedAmounts, runId)
, await context.CallActivityAsync <StatusHelper>(FunctionNames.LoadWaterAllocation, runId)
, await context.CallActivityAsync <StatusHelper>(FunctionNames.LoadSiteSpecificAmounts, runId)
};
foreach (var result in results)
{
log.LogInformation(JsonConvert.SerializeObject(result));
}
if (results.Any(a => !a.Status))
{
throw new Exception("Failure Loading Fact Data");
}
return(new OkObjectResult(new { status = "success" }));
}
public static async Task Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
var input = context.GetInput <MessageInput>();
var smsKey = await context.CallActivityAsync <string>("A_SaveTwilioMapping", context.InstanceId);
input.SmsKey = smsKey;
await context.CallActivityAsync <string>("A_SendTwilioText", input);
var status = await context.WaitForExternalEvent <string>("TwilioCallback");
log.LogWarning("Got a status from Twilio! " + status);
}
public static async Task <SubOrchestratorExampleOutput> Run(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var input = context.GetInput <SubOrchestratorExampleModel>();
var activity1 = await context.CallActivityAsync <string>("E1_SayHello", input.Input);
var activity2 = await context.CallActivityAsync <string>(
"SendSignalRMessageActivity",
new SignalRDto { id = context.ParentInstanceId, message = input.Input, progress = input.Progress });
return(new SubOrchestratorExampleOutput
{
Message = activity1,
Canceled = false
});
}
public static async Task <LSAMessage> ActionA2(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var message = context.GetInput <LSAMessage>();
message = await context.CallActivityAsync <LSAMessage>("StepA", message);
context.SetCustomStatus(message);
message = await context.CallActivityAsync <LSAMessage>("StepC", message);
context.SetCustomStatus(message);
return(message);
}
public static async Task CreateCoreResources(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating Core Resources in: {resourceGroupName}", creationParams.ResourceGroupName);
}
//await context.CallActivityWithRetryAsync(
// nameof(ResourceCreationActivities.CreateAppServicePlan),
// new RetryOptions(TimeSpan.FromMinutes(1), maxNumberOfAttempts: 3)
// {
// BackoffCoefficient = 1.0,
// Handle = ex =>
// {
// if (ex is CloudException)
// {
// log.LogError(ex, "failed to create app service plan...");
// return true;
// }
// // don't bother retrying on any other exceptions
// return false;
// },
// RetryTimeout = TimeSpan.FromMinutes(1)
// },
// creationParams);
var storageRequest = CreateStorageAccountRequest.FromCreationParams(creationParams);
storageRequest.StorageAccountName = ResourceCreationActivities.GenerateStorageAccountName(creationParams, "logs");
var t1 = context.CallSubOrchestratorAsync(nameof(CreateCustomerAppServicePlan), 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 Core Resources in: {creationParams.ResourceGroupName}");
}
}
public async Task <IEnumerable <WishResult> > ProviderOrchestrationAsync([OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var model = context.GetInput <SearchProviderContext>();
var results = new List <WishResult>();
foreach (var wish in model.Wishes)
{
var wishResults = await context.CallActivityAsync <IEnumerable <WishResult> >(Constants.WishSearchActivity, new SearchWishContext
{
Provider = model.Provider,
Wish = wish
});
results.AddRange(wishResults);
}
return(results);
}
public static async Task <Schedule> ChargeForTermFunctionAsync([OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var request = context.GetInput <ScheduleRequest>();
var term = new Term()
{
Start = request.TermStart,
End = request.TermEnd
};
var lessonDefinitions = request.Lessons.Select(
l => new LessonDefinition(l.LessonDay, l.Duration, l.WeeksPerLesson));
//log.LogInformation(term.Start.ToLongDateString());
var s = await context.CallActivityAsync <Schedule>("GetSchedule", (term, lessonDefinitions));
return(s);
}
public static async Task CreateSiteSqlServerAndDatabase(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating Sql Server and Database Resources in: {resourceGroupName}", creationParams.ResourceGroupName);
}
await context.CallActivityAsync(nameof(ResourceCreationActivities.CreateSqlServer), creationParams);
await context.CallActivityAsync(nameof(ResourceCreationActivities.CreateSqlDatabase), creationParams);
if (!context.IsReplaying)
{
log.LogWarning($"ORC - Created Sql Server and Database Resources in: {creationParams.ResourceGroupName}");
}
}
public static async Task CreateResourcesOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
// customer resources -->
// create resource group & register resource providers in subscription
// create app service plan (prod & dev share the same service plan)
// register wildcard SSL certificates
// create storage account for http and application logs from webapps // <shortname>logs<prefix-hash>
// create blob2sumo webjob
// create webapp router
// aws setup
await context.CallSubOrchestratorAsync(nameof(CreateCustomerResources), creationParams);
// site resources (sql server, sql db, cache, storageAccount (record attachments), ???)
await context.CallSubOrchestratorAsync(nameof(CreateSiteResources), creationParams);
// link resources (all the web apps)
}
public static async Task <Response> Run1(
[OrchestrationTrigger] DurableOrchestrationContextBase context)
{
var output = new Dictionary <string, int>();
double volume = 0.0;
output.Add(Environment.MachineName, Environment.ProcessorCount);
var depth = context.GetInput <int>();
if (depth > 0)
{
var tasks = new List <Task <Response> >();
for (int i = 0; i < 10; i++)
{
tasks.Add(context.CallActivityAsync <Response>("DFLoadTestActivity", (depth - 1).ToString()));
tasks.Add(context.CallSubOrchestratorAsync <Response>("DFLoadTestOrchestration", (depth - 1).ToString()));
}
await Task.WhenAll(tasks);
foreach (var t in tasks)
{
volume += t.Result.Volume;
foreach (var kvp in t.Result.Hosts)
{
output[kvp.Key] = kvp.Value;
}
}
}
return(new Response()
{
Volume = volume,
Hosts = output,
Elapsed = 0.0, // filled in later
});
}
public async Task SearchOrchestrationAsync(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
[Table(Constants.WishTableName)] CloudTable wishTable,
[Pushover] IAsyncCollector <PushoverNotification> notifications)
{
var model = context.GetInput <SearchContext>();
var results = new List <WishResult>();
foreach (var provider in model.Providers)
{
var providerResults = await context.CallSubOrchestratorAsync <IEnumerable <WishResult> >(SubOrchestrator, new SearchProviderContext
{
Provider = provider,
Wishes = model.Wishes
});
results.AddRange(providerResults);
}
if (results.Any())
{
var addResultsCmd = new AddWishResultsCommand(results);
await wishTable.ExecuteAsync(addResultsCmd);
var wishNames = results.GroupBy(r => r.WishName)
.Select(r => r.Key)
.Distinct();
await notifications.AddAsync(new PushoverNotification
{
Title = "NZB Wishlist",
Message = $"Found new results for {string.Join(", ", wishNames)}"
});
}
var updateWishesCmd = new UpdateLastSearchDateCommand(model.Wishes);
await wishTable.ExecuteAsync(updateWishesCmd);
}
public static async Task CreateCustomerResources(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating Customer Resources in: {resourceGroup}", creationParams.ResourceGroupName);
}
// Resource Group and Resource Providers
if (!context.IsReplaying)
{
log.LogWarning("ORC - Waiting for Resource Group + Providers");
}
await context.CallSubOrchestratorAsync(nameof(CreateCustomerResourceGroup), creationParams);
// App Serice Plan and Log Storage Account
if (!context.IsReplaying)
{
log.LogWarning("ORC - Waiting for ASP + Storage Account");
}
await context.CallSubOrchestratorAsync(nameof(CreateCoreResources), creationParams);
// WebApp Router + AWS Setup can be done as two tasks running in parallel
Task[] finalTasks =
{
context.CallSubOrchestratorAsync(nameof(CreateWebAppRouter), creationParams),
context.CallSubOrchestratorAsync(nameof(PerformAwsSetup), creationParams)
};
await Task.WhenAll(finalTasks);
if (!context.IsReplaying)
{
log.LogWarning($"ORC - Created Customer Resources in Resource Group: {creationParams.ResourceGroupName}");
}
}
internal static async Task <StatusHelper> LoadData(DurableOrchestrationContextBase context, string currFunctionName, string countFunctionName, string batchFunctionName, int recordCount, ILogger log)
{
var runId = context.GetInput <string>();
var lineCount = await context.CallActivityAsync <long>(countFunctionName, runId);
var processed = 0;
while (processed < lineCount)
{
var status = await context.CallActivityAsync <StatusHelper>(batchFunctionName, new BatchData { RunId = runId, StartIndex = processed, Count = recordCount });
if (!status.Status)
{
return(new StatusHelper {
Name = currFunctionName, Status = false
});
}
processed += recordCount;
}
return(new StatusHelper {
Name = currFunctionName, Status = true
});
}
public static async Task CreateCustomerAppServicePlan(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating Customer App Service Plan + Wildcard SSL in Resource Group: {resourceGroupName}", creationParams.ResourceGroupName);
}
Task[] tasks =
{
context.CallActivityAsync(nameof(ResourceCreationActivities.CreateAppServicePlan), creationParams), // do with register ssl
context.CallActivityAsync(nameof(ResourceCreationActivities.RegisterSslCertificates), creationParams), // do with create asp
};
await Task.WhenAll(tasks);
if (!context.IsReplaying)
{
log.LogWarning("ORC - Created Customer App Service Plan + Wildcard SSL in Resource Group: {resourceGroupName}", creationParams.ResourceGroupName);
}
}
public static async Task PerformAwsSetup(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Setting up AWS in Resource Group: {resourceGroupName}", creationParams.ResourceGroupName);
}
Task[] setupAwsTasks =
{
context.CallActivityAsync(nameof(ResourceCreationActivities.SetupAwsSes), creationParams),
context.CallActivityAsync(nameof(ResourceCreationActivities.SetupAwsS3Bucket), creationParams)
};
await Task.WhenAll(setupAwsTasks);
if (!context.IsReplaying)
{
log.LogWarning($"ORC - Set up AWS in Resource Group: {creationParams.ResourceGroupName}");
}
}
public static async Task CreateWebAppRouter(
[OrchestrationTrigger] DurableOrchestrationContextBase context,
ILogger log)
{
CreationParameters creationParams = context.GetInput <CreationParameters>();
if (!context.IsReplaying)
{
log.LogWarning("ORC - Creating WebAppRouter in Resource Group: {resourceGroupName}", creationParams.ResourceGroupName);
}
await context.CallActivityAsync(nameof(ResourceCreationActivities.CreateWebApp), creationParams);
await context.CallActivityAsync(nameof(ResourceCreationActivities.CreateWebAppSlot), creationParams);
await context.CallActivityAsync(nameof(ResourceCreationActivities.UploadDeployWebAppArtifact), creationParams);
await context.CallActivityAsync(nameof(ResourceCreationActivities.SwapWebAppSlot), creationParams);
if (!context.IsReplaying)
{
log.LogWarning($"ORC - Created WebAppRouter in Resource Group: {creationParams.ResourceGroupName}");
}
}
