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}"); } }