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