public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "put", Route = "Database/{key}")] HttpRequestMessage req, string key, [OrchestrationClient] IDurableOrchestrationClient starter, ILogger log) { string instanceId; // GET request if (req.Method == HttpMethod.Get) { instanceId = await starter.StartNewAsync("Database_GET_Orchestrator", key); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, System.TimeSpan.MaxValue)); } // PUT request else if (req.Method == HttpMethod.Put) { var content = req.Content; string value = content.ReadAsStringAsync().Result; instanceId = await starter.StartNewAsync("Database_PUT_Orchestrator", new WriteOperation(key, value)); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, System.TimeSpan.MaxValue)); } // Otherwise. else { return(req.CreateResponse(System.Net.HttpStatusCode.BadRequest)); } }
public async Task <HttpResponseMessage> RunAsync( [HttpTrigger(AuthorizationLevel.Anonymous, Route = "scan/{organization}/{projectName}/{scope}")] HttpRequestMessage request, string organization, string projectName, string scope, [DurableClient] IDurableOrchestrationClient starter) { if (starter == null) { throw new ArgumentNullException(nameof(starter)); } if (_tokenizer.IdentifierFromClaim(request) == null) { return(new HttpResponseMessage(HttpStatusCode.Unauthorized)); } var project = await _azuredo.GetAsync(Project.ProjectByName(projectName)); if (project == null) { return(new HttpResponseMessage(HttpStatusCode.NotFound)); } // clear cache for manual scan _policiesResolver.Clear(project.Id); var scanDate = DateTime.UtcNow; var instanceId = await starter.StartNewAsync <object>(nameof(ProjectScanOrchestrator), (project, scope, scanDate)); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(request, instanceId, TimeSpan.FromSeconds(TimeOut))); }
public static async Task <IActionResult> RunOrchestrated( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); var content = await new StreamReader(req.Body).ReadToEndAsync(); try { var options = JsonConvert.DeserializeObject <FractalOptions>(content); var instanceId = await starter.StartNewAsync(nameof(RunOrchestrator), null, options); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, TimeSpan.FromSeconds(60))); } catch (Exception ex) { var response = new FunctionResult { ErrorMessage = $"{ex.GetType().Name}: {ex.Message}", }; return(new OkObjectResult(response)); } }
/// <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 default 10 second 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 this timeout, then the HTTP response will be identical to that of the /// <see cref="IDurableOrchestrationClient.CreateCheckStatusResponse(HttpRequest, 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> /// <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 <IActionResult> WaitForCompletionOrCreateCheckStatusResponseAsync( this IDurableOrchestrationClient client, HttpRequest request, string instanceId) { return(client.WaitForCompletionOrCreateCheckStatusResponseAsync( request, instanceId, timeout: TimeSpan.FromSeconds(10))); }
/// <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> Checkout( [HttpTrigger(AuthorizationLevel.Function, "post", Route = "user/{userId}/order/checkout")] HttpRequest req, [DurableClient] IDurableOrchestrationClient client, string userId, ILogger log) { log.LogInformation("Processing order checkout."); var instanceId = await client.StartNewAsync <string>(nameof(OrderOrchestrator), userId); return(await client.WaitForCompletionOrCreateCheckStatusResponseAsync(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 async Task <HttpResponseMessage> HttpStartAsync( [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient orchestrator) { Person person = personService.GetPersonFromRequestAsync(req); string instanceId = await orchestrator.StartNewAsync(nameof(GreetingOrchestrator), person); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await orchestrator.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, TimeSpan.FromSeconds(TimeoutInSeconds))); }
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 async Task <IActionResult> ClassifyAsync([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "customers")] HttpRequest request, [DurableClient] IDurableOrchestrationClient client) { var fileRecordsRequest = await request.GetModel <InsertCustomersRequest>(); var instanceId = Guid.NewGuid().ToString("N"); await client.StartNewAsync(nameof(CustomerRecordOrchestratorFunction), instanceId, fileRecordsRequest); var actionResult = await client.WaitForCompletionOrCreateCheckStatusResponseAsync(request, instanceId, TimeSpan.FromSeconds(2)); return(actionResult); }
public static async Task <HttpResponseMessage> HttpStart( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var body = JsonConvert.DeserializeObject <ListRequest>(req.Content.ReadAsStringAsync().Result); string instanceId = await starter.StartNewAsync("DurableFunction", Guid.NewGuid().ToString(), body); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId)); //return starter.CreateCheckStatusResponse(req, instanceId); }
public static async Task <JToken> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "Counter/{name}")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient client, string name) { var entityId = new EntityId("Counter", name); var orchestratorId = await client.StartNewAsync("GetCounter_Orchestrator", entityId); await client.WaitForCompletionOrCreateCheckStatusResponseAsync(req, orchestratorId); var status = await client.GetStatusAsync(orchestratorId); return(status.Output); }
public static async Task Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "Game/Player/{player}/Add/{item}/{quantity}")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient client, string player, string item, int quantity) { var input = new AddItemToPlayerInventoryOrchestratorInput { Player = player, Item = item, Quantity = quantity }; var orchestratorId = await client.StartNewAsync("AddItemToPlayerInventoryFunction_Orchestrator", input); await client.WaitForCompletionOrCreateCheckStatusResponseAsync(req, orchestratorId); }
public async Task <IActionResult> ProcessFlow( BeginRequestData beginRequestData, HttpRequestMessage request, IDurableOrchestrationClient client) { await client.StartNewAsync(Constants.MyOrchestration, beginRequestData.Id, beginRequestData); _log.LogInformation($"Started orchestration with ID = '{beginRequestData.Id}'."); TimeSpan timeout = TimeSpan.FromSeconds(7); TimeSpan retryInterval = TimeSpan.FromSeconds(1); await client.WaitForCompletionOrCreateCheckStatusResponseAsync( request, beginRequestData.Id, timeout, retryInterval); var data = await client.GetStatusAsync(beginRequestData.Id); // timeout if (data.RuntimeStatus != OrchestrationRuntimeStatus.Completed) { await client.TerminateAsync(beginRequestData.Id, "Timeout something took too long"); return(new ContentResult() { Content = "{ error: \"Timeout something took too long\" }", ContentType = "application/json", StatusCode = (int)HttpStatusCode.InternalServerError }); } var output = data.Output.ToObject <MyOrchestrationDto>(); var completeResponseData = new CompleteResponseData { BeginRequestData = output.BeginRequest, Id2 = output.BeginRequest.Id + ".v2", MyActivityTwoResult = output.MyActivityTwoResult }; return(new OkObjectResult(completeResponseData)); }
public static async Task <HttpResponseMessage> BalanceInquiry( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "Account/{accountId}")] HttpRequestMessage req, string accountId, [OrchestrationClient] IDurableOrchestrationClient starter, ILogger log) { string instanceId; // GET request if (req.Method == HttpMethod.Get) { instanceId = await starter.StartNewAsync("GetBalance", accountId); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, System.TimeSpan.MaxValue)); } else { return(req.CreateResponse(System.Net.HttpStatusCode.BadRequest)); } }
private async Task <HttpResponseMessage> HandleStartOrchestratorRequestAsync( HttpRequestMessage request, string functionName, string instanceId) { try { IDurableOrchestrationClient client = this.GetClient(request); object input = null; if (request.Content != null) { using (Stream s = await request.Content.ReadAsStreamAsync()) using (StreamReader sr = new StreamReader(s)) using (JsonReader reader = new JsonTextReader(sr)) { JsonSerializer serializer = JsonSerializer.Create(MessagePayloadDataConverter.MessageSettings); input = serializer.Deserialize <object>(reader); } } string id = await client.StartNewAsync(functionName, instanceId, input); TimeSpan?timeout = GetTimeSpan(request, "timeout"); TimeSpan?pollingInterval = GetTimeSpan(request, "pollingInterval"); if (timeout.HasValue && pollingInterval.HasValue) { return(await client.WaitForCompletionOrCreateCheckStatusResponseAsync(request, id, timeout.Value, pollingInterval.Value)); } else { return(client.CreateCheckStatusResponse(request, id)); } } catch (JsonReaderException e) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid JSON content", e)); } }
public static async Task <HttpResponseMessage> PerformWithdraw( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "Account/{accountId}/Withdraw/{amount}")] HttpRequestMessage req, string accountId, string amount, [OrchestrationClient] IDurableOrchestrationClient starter, ILogger log) { string instanceId; // POST request if (req.Method == HttpMethod.Post) { instanceId = await starter.StartNewAsync("Withdraw", new AccountOperation(accountId, "withdraw", Int32.Parse(amount))); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, System.TimeSpan.MaxValue)); } else { return(req.CreateResponse(System.Net.HttpStatusCode.BadRequest)); } }
public static async Task <IActionResult> PostCard( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "card/{id:guid}")] HttpRequest request, Guid id, [DurableClient] IDurableEntityClient entities, [DurableClient] IDurableOrchestrationClient orchestrations) { var entityId = EntityIdFromGuid(id); var entityState = await entities.ReadEntityStateAsync <AttachmentDurableCard>(entityId); if (!entityState.EntityExists) { return(new NotFoundResult()); } var attachment = request.ReadFormAsJObject(); if (!await entityState.EntityState.ValidateAsync(attachment)) { return(new BadRequestResult()); } var operations = new JsonPatchDocument(); operations.Add("data/attachments/-", attachment); var entityOperation = new EntityOperation { EntityId = entityId, Document = operations }; var instanceId = await orchestrations.StartNewAsync(nameof(PatchCard), entityOperation); var timeout = TimeSpan.FromMinutes(1); var response = await orchestrations.WaitForCompletionOrCreateCheckStatusResponseAsync(request, instanceId, timeout); return(new RedirectResult($"/card/{id}")); }
public static async Task <HttpResponseMessage> ResetDeviceStatus( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "v1/devices/{deviceId}/status/reset")] HttpRequestMessage req, string deviceId, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var instanceId = deviceId; var existingInstance = await starter.GetStatusAsync(instanceId); if (existingInstance != null) { await starter.TerminateAsync(instanceId, "reset command called."); //await starter.PurgeInstanceHistoryAsync(instanceId); // これを呼ぶとInstanceの情報すべてが削除される。この場合StartNewAsyncとWaitForCompletionOrCreateCheckStatusResponseAsyncの必要はない await starter.StartNewAsync( "UpdateDeviceStatus", instanceId, new InputData { State = existingInstance?.CustomStatus?.ToObject <DeviceState>(), Input = new[] { new { Type = "terminate" } } }); var output = await starter.WaitForCompletionOrCreateCheckStatusResponseAsync( req, instanceId, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(1)); } return(req.CreateResponse(HttpStatusCode.OK)); }
public static async Task <IActionResult> PostToServiceBusQueue( [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest request, [DurableClient] IDurableOrchestrationClient client, ILogger log) { var inputObject = JObject.Parse(await request.ReadAsStringAsync()); var numberOfMessagesPerSession = inputObject.Value <int>(@"NumberOfMessagesPerSession"); var numberOfSessions = inputObject.Value <int>(@"NumberOfSessions"); var workTime = -1; if (inputObject.TryGetValue(@"WorkTime", out var workTimeVal)) { workTime = workTimeVal.Value <int>(); } var orchestrationIds = new List <string>(); var testRunId = Guid.NewGuid().ToString(); for (var c = 1; c <= numberOfSessions; c++) { var sessionId = Guid.NewGuid().ToString(); var orchId = await client.StartNewAsync(nameof(GenerateMessagesForServiceBusSession), new SessionCreateRequest { TestRunId = testRunId, SessionId = sessionId, NumberOfMessagesPerSession = numberOfMessagesPerSession, ConsumerWorkTime = workTime, }); log.LogTrace($@"Kicked off message creation for session {sessionId}..."); orchestrationIds.Add(orchId); } return(await client.WaitForCompletionOrCreateCheckStatusResponseAsync(request, orchestrationIds.First(), TimeSpan.FromMinutes(2))); }
public static async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}/wait")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, string functionName, ILogger log) { // Function input comes from the request content. object eventData = await req.Content.ReadAsAsync <object>(); string instanceId = await starter.StartNewAsync(functionName, eventData); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); TimeSpan timeout = GetTimeSpan(req, Timeout) ?? TimeSpan.FromSeconds(30); TimeSpan retryInterval = GetTimeSpan(req, RetryInterval) ?? TimeSpan.FromSeconds(1); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync( req, instanceId, timeout, retryInterval)); }
public async Task <IActionResult> OidcLogin( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "oidc-login/{platformId}")] HttpRequest req, [Platform(PlatformId = "{platformId}")] Platform platform, [LtiAdvantage] OidcClient oidcClient, [DurableClient] IDurableOrchestrationClient orchestrationClient) { NameValueCollection redirectQueryParams = oidcClient.GetRedirectQueryParams(platform.ClientId); string nonce = Guid.NewGuid().ToString(); string state = Guid.NewGuid().ToString(); string instanceId = await orchestrationClient.StartNewAsync(nameof(SaveState), (object)(nonce, state)); await orchestrationClient.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId); redirectQueryParams["nonce"] = nonce; redirectQueryParams["state"] = state; string queryParams = redirectQueryParams.ToString(); string redirectUrl = $"{platform.AuthorizationUrl}?{queryParams}"; return(new RedirectResult(redirectUrl)); }
public static async Task <IActionResult> PostToStorageQueue( [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest request, [DurableClient] IDurableOrchestrationClient client, ILogger log) { var inputObject = JObject.Parse(await request.ReadAsStringAsync()); var numberOfMessages = inputObject.Value <int>(@"NumberOfMessages"); var workTime = -1; if (inputObject.TryGetValue(@"WorkTime", out var workTimeVal)) { workTime = workTimeVal.Value <int>(); } var testRunId = Guid.NewGuid().ToString(); var orchId = await client.StartNewAsync(nameof(GenerateMessagesForStorageQueue), Tuple.Create(numberOfMessages, testRunId, workTime)); log.LogTrace($@"Kicked off {numberOfMessages} message creation..."); return(await client.WaitForCompletionOrCreateCheckStatusResponseAsync(request, orchId, TimeSpan.FromMinutes(2))); }
public async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestMessage req, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var jsonContent = await req.Content.ReadAsStringAsync(); log.LogInformation($"Request:{jsonContent}"); var data = JsonConvert.DeserializeObject <LineRequestInterface>(jsonContent); if (data.Events[0].ReplyToken.Equals("00000000000000000000000000000000")) { return(req.CreateResponse(HttpStatusCode.OK)); } // Function input comes from the request content. string instanceId = await starter.StartNewAsync("LineBotOrchestrator", data); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId)); }
private async Task <HttpResponseMessage> HandleStartOrchestratorRequestAsync( HttpRequestMessage request, string functionName, string instanceId) { try { IDurableOrchestrationClient client = this.GetClient(request); object input = null; if (request.Content != null && request.Content.Headers?.ContentLength != 0) { string json = await request.Content.ReadAsStringAsync(); input = JsonConvert.DeserializeObject(json, this.messageDataConverter.JsonSettings); } string id = await client.StartNewAsync(functionName, instanceId, input); TimeSpan?timeout = GetTimeSpan(request, "timeout"); TimeSpan?pollingInterval = GetTimeSpan(request, "pollingInterval"); if (timeout.HasValue && pollingInterval.HasValue) { return(await client.WaitForCompletionOrCreateCheckStatusResponseAsync(request, id, timeout.Value, pollingInterval.Value)); } else { return(client.CreateCheckStatusResponse(request, id)); } } catch (JsonReaderException e) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid JSON content", e)); } }