/// <summary> /// Creates an HTTP response which either contains a payload of management URLs for a non-completed instance /// or contains the payload containing the output of the completed orchestration. /// </summary> /// <remarks> /// If the orchestration instance completes within the specified timeout, then the HTTP response payload will /// contain the output of the orchestration instance formatted as JSON. However, if the orchestration does not /// complete within the specified timeout, then the HTTP response will be identical to that of the /// <see cref="IDurableOrchestrationClient.CreateCheckStatusResponse(HttpRequestMessage, string, bool)"/> API. /// </remarks> /// <param name="client">The client object.</param> /// <param name="request">The HTTP request that triggered the current function.</param> /// <param name="instanceId">The unique ID of the instance to check.</param> /// <param name="timeout">Total allowed timeout for output from the durable function. The default value is 10 seconds.</param> /// <returns>An HTTP response which may include a 202 and location header or a 200 with the durable function output in the response body.</returns> public static Task <HttpResponseMessage> WaitForCompletionOrCreateCheckStatusResponseAsync( this IDurableOrchestrationClient client, HttpRequestMessage request, string instanceId, TimeSpan timeout) { return(client.WaitForCompletionOrCreateCheckStatusResponseAsync( request, instanceId, timeout, retryInterval: TimeSpan.FromSeconds(1))); }
public static async Task <IActionResult> Run( [DurableClient] IDurableOrchestrationClient orchestrationClient, [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, ILogger log) { log.LogInformation("OrchestrationClient called."); string instanceId = await orchestrationClient.StartNewAsync(Orchestrator.FunctionName); var payload = orchestrationClient.CreateHttpManagementPayload(instanceId); return(new AcceptedResult(payload.StatusQueryGetUri, payload)); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { // Function input comes from the request content. string instanceId = await starter.StartNewAsync("CSVImport_Orchestrator", null); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public virtual async Task Refresh(IDurableOrchestrationClient starter, StateDetails stateDetails, ExecuteActionRequest exActReq, ApplicationArchitectClient appArch, EnterpriseArchitectClient entArch, EnterpriseManagerClient entMgr, IdentityManagerClient idMgr, SecurityManagerClient secMgr, DocumentClient client) { // await EnsureUserEnterprise(entArch, entMgr, secMgr, stateDetails.EnterpriseLookup, stateDetails.Username); State.Loading = false; State.HomePage.Loading = false; State.SSL.Loading = false; }
public async Task TimerStarter( [TimerTrigger("0 0 10 * * *")] TimerInfo timerInfo, [DurableClient] IDurableOrchestrationClient starter ) { int batchSize = Convert.ToInt32(Environment.GetEnvironmentVariable("USER_BATCH_SIZE")); int taskBatchSize = Convert.ToInt32(Environment.GetEnvironmentVariable("TASK_BATCH_SIZE")); string instanceId = await starter.StartNewAsync("Orchestrators-ScheduledCommunication", new { batchSize, taskBatchSize }); //TODO Log this to slack? return starter.CreateCheckStatusResponse(req, instanceId); }
public async Task IDurableOrchestrationClientBinding() { using (var host = TestHelpers.GetJobHost( this.loggerProvider, nameof(this.IDurableOrchestrationClientBinding), enableExtendedSessions: false)) { await host.StartAsync(); IDurableOrchestrationClient client = await host.GetOrchestrationClientBindingTest(this.output); } }
private async Task StartRecompensateProcess( IDurableOrchestrationClient processStarter, IDurableOrchestrationContext context, RegisterApplicationCommand command, ILogger log) { var recompensateCommand = this.BuildRecompensationCommand(context, command); var recompensationId = await processStarter.StartNewAsync(nameof(ApplicationProcessRecompensationOrchiestrator), recompensateCommand); log.LogInformation($"Started recompensation process for application process with instanceId: {context.InstanceId}." + $"Recompensation process instanceId: {recompensationId}"); }
public async Task <IActionResult> RunOrchestratorHttp( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var url = JsonConvert.DeserializeObject <Dictionary <string, string> >(await req.Content.ReadAsStringAsync()); var instanceId = await starter.StartNewAsync <string>("RunOrchestrator", System.Net.WebUtility.UrlEncode(url["url"])); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(new OkObjectResult("success")); }
public async Task Run( [TimerTrigger(PurgeFrequencyVariable)] TimerInfo myTimer, [DurableClient] IDurableOrchestrationClient client, ILogger log, CancellationToken hostCancellationToken) { EnsureArg.IsNotNull(client, nameof(client)); EnsureArg.IsNotNull(myTimer, nameof(myTimer)); EnsureArg.IsNotNull(log, nameof(log)); var orchestrationInstanceIdList = new List <string>(); log.LogInformation("Purging orchestration instance history at: {Timestamp}", _getUtcNow()); if (myTimer.IsPastDue) { log.LogWarning("Current function invocation is later than scheduled."); } // Specify conditions for orchestration instances. var condition = new OrchestrationStatusQueryCondition { RuntimeStatus = _purgeConfig.RuntimeStatuses, CreatedTimeFrom = DateTime.MinValue, CreatedTimeTo = _getUtcNow().AddDays(-_purgeConfig.MinimumAgeDays), ContinuationToken = null }; do { OrchestrationStatusQueryResult listOfOrchestrators = await client.ListInstancesAsync(condition, hostCancellationToken); condition.ContinuationToken = listOfOrchestrators.ContinuationToken; // Loop through the orchestration instances and purge them. foreach (DurableOrchestrationStatus orchestration in listOfOrchestrators.DurableOrchestrationState) { orchestrationInstanceIdList.Add(orchestration.InstanceId); await client.PurgeInstanceHistoryAsync(orchestration.InstanceId); } } while (condition.ContinuationToken != null); if (orchestrationInstanceIdList.Count != 0) { log.LogInformation("{Count} Durable Functions cleaned up successfully.", orchestrationInstanceIdList.Count); log.LogDebug("List of cleaned instance IDs: {list}", string.Join(", ", orchestrationInstanceIdList)); } else { log.LogInformation("No Orchestration instances found within given conditions."); } }
private async Task <HttpResponseMessage> HandleGetStatusRequestAsync( HttpRequestMessage request) { IDurableOrchestrationClient client = this.GetClient(request); var queryNameValuePairs = request.GetQueryNameValuePairs(); var createdTimeFrom = GetDateTimeQueryParameterValue(queryNameValuePairs, CreatedTimeFromParameter, default(DateTime)); var createdTimeTo = GetDateTimeQueryParameterValue(queryNameValuePairs, CreatedTimeToParameter, default(DateTime)); var runtimeStatus = GetIEnumerableQueryParameterValue <OrchestrationRuntimeStatus>(queryNameValuePairs, RuntimeStatusParameter); var pageSize = GetIntQueryParameterValue(queryNameValuePairs, PageSizeParameter); var continuationToken = ""; if (request.Headers.TryGetValues("x-ms-continuation-token", out var headerValues)) { continuationToken = headerValues.FirstOrDefault(); } IList <DurableOrchestrationStatus> statusForAllInstances; var nextContinuationToken = ""; if (pageSize > 0) { var condition = new OrchestrationStatusQueryCondition() { CreatedTimeFrom = createdTimeFrom, CreatedTimeTo = createdTimeTo, RuntimeStatus = runtimeStatus, PageSize = pageSize, ContinuationToken = continuationToken, }; var context = await client.GetStatusAsync(condition, CancellationToken.None); statusForAllInstances = context.DurableOrchestrationState.ToList(); nextContinuationToken = context.ContinuationToken; } else { statusForAllInstances = await client.GetStatusAsync(createdTimeFrom, createdTimeTo, runtimeStatus); } var results = new List <StatusResponsePayload>(statusForAllInstances.Count); foreach (var state in statusForAllInstances) { results.Add(this.ConvertFrom(state)); } var response = request.CreateResponse(HttpStatusCode.OK, results); response.Headers.Add("x-ms-continuation-token", nextContinuationToken); return(response); }
public async Task <IActionResult> Diagnostics( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { string instanceId = req.Query["instanceId"]; log.LogInformation($"Started DiagnosticsApi with ID = '{instanceId}'."); var data = await starter.GetStatusAsync(instanceId, true); return(new OkObjectResult(data)); }
public Task <IActionResult> RunAsync( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", "put", Route = "{*path}")] HttpRequest req, [DurableClient] IDurableOrchestrationClient orchestrationClient, ExecutionContext executionContext) { var additionalParameters = new DurableFunctionsOpenApiContextAdditionalProperties { ExecutionContext = executionContext, OrchestrationClient = orchestrationClient, }; return(this.host.HandleRequestAsync(req.Path, req.Method, req, additionalParameters)); }
private async Task StartRecompensateProcess( IDurableOrchestrationClient processStarter, IDurableOrchestrationContext context, RegisterApplicationCommand command, ILogger log) { await context.CallActivityAsync(nameof(ApplicationProcessFailedEventPublisher), ApplicationProcessStatus.Failed.ToString()); var recompensateCommand = this.BuildRecompensationCommand(context, command); await processStarter.StartNewAsync(nameof(ApplicationProcessRecompensationOrchestrator), context.InstanceId, recompensateCommand); log.LogInformation($"Started recompensation process for application process with instanceId: {context.InstanceId}."); }
/// <summary> /// Run a throttled fan out of the named orchestration passing in each of the /// unique keys for it to run over /// </summary> /// <param name="client"> /// The durable orchestration instance to run the fan-out over /// </param> /// <param name="orchestrationName"> /// The name of the function to run /// </param> /// <param name="keys"> /// The unique keys to pass in to the instances of the orchestration /// </param> /// <returns> /// An awaitable task that performs the fan-out /// </returns> public static async Task ThrottledFanOut(IDurableOrchestrationClient client, string orchestrationName, IEnumerable <string> keys) { if (keys != null) { await keys.ParallelForEachAsync(THROTTLE_BATCH_SIZE, key => { return(client.StartNewAsync(orchestrationName, key)); }); } return; }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, [DurableClient] IDurableOrchestrationClient client, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); string requestBody = req.Query["name"]; string instanceid = await client.StartNewAsync <string>("vsorchestrator1", requestBody); return(client.CreateCheckStatusResponse(req, instanceid)); }
public async Task <IActionResult> HttpStart( [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { // set orchestration client and logger Clova.DurableOrchestrationClient = starter; Clova.Logger = log; var response = await Clova.RespondAsync(req.Headers["SignatureCEK"], req.Body); return(new OkObjectResult(response)); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter) { //Gets the submission payload Submission submission = await req.Content.ReadAsAsync <Submission>(); //Starts a new orchestration string instanceId = await starter.StartNewAsync("SubmissionApprovalProcess_Orchestrator", submission); //Returns the check status response return(starter.CreateCheckStatusResponse(req, instanceId)); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { // Function input comes from the request content. string instanceId = await starter.StartNewAsync("Function1", null); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); //return starter.CreateCheckStatusResponse(req, instanceId); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, TimeSpan.FromSeconds(30))); }
public static async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Function, "post", Route = "providers/DotNetDevOps.LetsEncrypt/certificates")] HttpRequestMessage req, [OrchestrationClient] IDurableOrchestrationClient starter, ILogger log) { var addCertificateRequest = await req.Content.ReadAsAsync <AddCertificateRequest>(); var instanceId = await starter.StartNewAsync(nameof(AddCertificateOrchestrator), addCertificateRequest); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, TimeSpan.FromSeconds(3))); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { Order order = await req.Content.ReadAsAsync <Order>(); string instanceId = await starter.StartNewAsync <Order>("OrderProcessorWorkflowFn", order); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var orderIds = Enumerable.Range(0, 10); // Function input comes from the request content. string instanceId = await starter.StartNewAsync("OrchestratorFunction", orderIds.ToList()); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "orchestrators/PeriodEndOrchestrator")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { log.LogInformation($"Triggering PeriodEndOrchestrator for current active collection period"); string instanceId = await starter.StartNewAsync(nameof(PeriodEndOrchestrator), null); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public static async Task TriggerOrchestrator( [ServiceBusTrigger(Constants.QueueName, Connection = Constants.ingressConnectionString)] OrchestrationActionModel myQueueItem, ILogger log, [DurableClient] IDurableOrchestrationClient durableOrchestrationClient) { log.LogInformation($"C# ServiceBus queue trigger function processed message: {myQueueItem}"); //Start a new orchestrator - send service bus message as input data var instanceId = await durableOrchestrationClient.StartNewAsync(Constants.DurableOrchestrator, null, myQueueItem); //Log the instance Id - this Id can be used to track the results of the orchestration run log.LogInformation($"Orchestrator instance created with Id: {instanceId}"); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var data = await req.Content.ReadAsAsync <dynamic>(); var fileName = data.fileName; string instanceId = await starter.StartNewAsync("Monitor_Orchestrator", instanceId : null, input : fileName); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public async Task <IActionResult> GetCompletedFlows( [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequest req, [DurableClient] IDurableOrchestrationClient client, ILogger log) { var runtimeStatus = new List <OrchestrationRuntimeStatus> { OrchestrationRuntimeStatus.Completed }; return(await FindOrchestrations(req, client, runtimeStatus, DateTime.UtcNow.AddDays(GetDays(req)), DateTime.UtcNow, true)); }
public async Task StartOrchestratorBlobTrigger( [BlobTrigger("uploads/{name}", Connection = "BlobStorageConnection")] Stream blob, string name, [DurableClient] IDurableOrchestrationClient starter) { BinaryReader binaryReader = new BinaryReader(blob); var input = new BlobModel { Blob = binaryReader.ReadBytes((int)blob.Length), Name = name }; await starter.StartNewAsync("UploadOrchestratorFunction", input); }
public static async Task <IActionResult> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { //set body string requestBody = await new StreamReader(req.Body).ReadToEndAsync(); // Function input comes from the request content. string instanceId = await starter.StartNewAsync <string>("Orchestrator", requestBody); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public static async Task <IActionResult> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { string message = req.Form["text"]; string instanceId = await starter.StartNewAsync <string>("ScheduleOrchestration", null, message); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }
public async Task ProcessAsync([BlobTrigger("%InputContainer%/{fileName}")] Stream stream, string fileName, [DurableClient] IDurableOrchestrationClient client) { var orchestrationStatus = await client.GetStatusAsync(fileName); //if (orchestrationStatus != null && orchestrationStatus.RuntimeStatus != OrchestrationRuntimeStatus.Completed) //{ // await client.TerminateAsync(fileName, "Terminating the process"); //} await client.StartNewAsync(nameof(FileProcessorOrchestratorFunction), fileName); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var groupName = await req.Content.ReadAsStringAsync(); var instanceId = await starter.StartNewAsync <string>(nameof(TeamsConfig), groupName); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(starter.CreateCheckStatusResponse(req, instanceId)); }