public static async Task ProcessOrdersStart(
[TimerTrigger("*/20 * * * * *")] TimerInfo myTimer,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
//don't try to play catchup
if (!myTimer.IsPastDue)
{
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("ProcessOrders", null);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
}
else
{
log.LogWarning("Processing Orders skipped: ignore IsPastDue invocations");
}
}
public static async Task <HttpResponseMessage> PartitionManager_HttpStart(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
dynamic eventData = await req.Content.ReadAsAsync <object>();
if (eventData != null)
{
_modelConfigurationIDs = eventData;
}
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("PartitionManager", null);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "orchestrators/{functionName}")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
string functionName,
TraceWriter log)
{
// Function input comes from the request content.
dynamic eventData = await req.Content.ReadAsAsync <object>();
string instanceId = await starter.StartNewAsync(functionName, eventData);
log.Info($"Started orchestration with ID = '{instanceId}'.");
var res = starter.CreateCheckStatusResponse(req, instanceId);
res.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(10));
return(res);
}
public static async Task <IActionResult> TerminateTripDemo([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "tripdemos/{code}/terminate")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient context,
string code,
ILogger log)
{
try
{
await TeminateInstance(context, code, log);
return((ActionResult) new OkObjectResult("Ok"));
}
catch (Exception ex)
{
var error = $"TerminateTripDemo failed: {ex.Message}";
log.LogError(error);
return(new BadRequestObjectResult(error));
}
}
public static async Task <HttpResponseMessage> PostCluster([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter, ILogger log)
{
// Get request body
dynamic data = await req.Content.ReadAsAsync <object>();
var scale = (int)data?.scale;
var name = (string)data?.name;
if (scale == 0 || string.IsNullOrEmpty(name))
{
return(req.CreateResponse(HttpStatusCode.BadRequest, $"Bad input. please supply name and scale > 0"));
}
log.LogInformation($"post cluster client: {name} scale: {scale}");
var response = starter.StartNewAsync("CreateCluster", new Tuple <string, int>(name, scale));
return(req.CreateResponse(HttpStatusCode.OK, $"started create process id:{response.Id}"));
}
public static async Task <HttpResponseMessage> GetAllStatus(
[HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient client,
TraceWriter log)
{
IList <DurableOrchestrationStatus> instances = await client.GetStatusAsync(); // You can pass CancellationToken as a parameter.
foreach (var instance in instances)
{
log.Info(JsonConvert.SerializeObject(instance));
}
;
var resp = req.CreateResponse(HttpStatusCode.OK);
resp.Content = new StringContent(JsonConvert.SerializeObject(instances));
AddCORSHeaders(req, ref resp, "GET", log);
return(resp);
}
public static async Task <HttpResponseMessage> ClientStatus(
[HttpTrigger] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient client,
TraceWriter log)
{
var body = await req.Content.ReadAsStringAsync();
var restored = JsonConvert.DeserializeObject <JObject>(body);
var status = await client.GetStatusAsync(restored["instanceId"].ToString());
var result = $"clients status. -> {JsonConvert.SerializeObject(status)}";
return(new HttpResponseMessage()
{
Content = new StringContent(result, System.Text.Encoding.UTF8, "application/text")
});
}
public static async Task <IActionResult> NewUser(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)]
HttpRequest req,
[Queue(Global.QUEUE)] IAsyncCollector <string> console,
[Table(nameof(User))] CloudTable table,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
log.LogInformation("NewUser called.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
string name = data?.name;
if (string.IsNullOrWhiteSpace(name))
{
await console.AddAsync("An attempt to create a user with no name was made.");
return(new BadRequestObjectResult("User name is required."));
}
var client = table.AsClientFor <User>();
var tempUser = new User {
Name = name
};
var userCheck = await client.GetAsync(tempUser.PartitionKey, name);
if (userCheck != null)
{
await console.AddAsync($"Attempt to add duplicate user {name} failed.");
return(new BadRequestObjectResult("Duplicate username is not allowed."));
}
await starter.StartNewAsync(nameof(NewUserParallelFunctions.RunUserParallelWorkflow), name);
log.LogInformation("Started new parallel workflow for user {user}", name);
await starter.StartNewAsync(nameof(MonitorFunctions.UserMonitorWorkflow), name);
log.LogInformation("Started new monitor workflow for user {user}", name);
return(new OkResult());
}
public static async Task <IActionResult> AcceptJobOffer(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "careers/application/accept")] HttpRequestMessage request,
[OrchestrationClient] DurableOrchestrationClient durableOrchestrationClient,
ILogger log)
{
string requestBody = await request.Content.ReadAsStringAsync();
if (string.IsNullOrEmpty(requestBody))
{
return(new BadRequestResult());
}
Offer data = JsonConvert.DeserializeObject <Offer>(requestBody);
await durableOrchestrationClient.RaiseEventAsync(data.OrchestratorInstanceId, "JobOfferAccepted", data.Accepted);
return(new NoContentResult());
}
public static async Task <HttpResponseMessage> ClientStarter(
[HttpTrigger] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
TraceWriter log)
{
log.Info($"Start: {DateTime.UtcNow.ToLongDateString()}");
dynamic eventData = await req.Content.ReadAsAsync <object>();
var instanceId = await starter.StartNewAsync("AgentExpansionOrchestrator", eventData); // eventData is not needed. However, the interface requires.
var result = JsonConvert.SerializeObject(new JObject {
["instanceId"] = instanceId
});
return(new HttpResponseMessage()
{
Content = new StringContent(result, System.Text.Encoding.UTF8, "application/text")
});
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
var stream = await req.Content.ReadAsStreamAsync();
var dto = stream.Deserialize <JournalDTO>();
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("DurableFunctionsOrchestration", dto);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
var response = starter.CreateCheckStatusResponse(req, instanceId);
response.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(2));
return(response);
}
public static Task Run([CosmosDBTrigger(
databaseName: "masterdata",
collectionName: "product",
ConnectionStringSetting = "COSMOSDB_CONNECTION",
LeaseCollectionName = "leases",
CreateLeaseCollectionIfNotExists = true)]
IReadOnlyList <Document> input,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
if (input == null || input.Count <= 0)
{
return(Task.CompletedTask);
}
var products = input.Select(x => x.ToString());
return(starter.StartNewAsync(nameof(ConsumerEgressFuncs.OrchestrateConsumersFunc), products));
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("DurableFunctionsOrchestrationCSharp", new[] {
new X {
name = "London"
},
new X {
name = "New York"
}
});
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient client)
{
string instanceId = req.GetQueryNameValuePairs()
.FirstOrDefault(q => string.Compare(q.Key, "instanceId", true) == 0)
.Value;
var durableJobStatus = await client.GetStatusAsync(instanceId);
HttpStatusCode returnStatusCode = HttpStatusCode.InternalServerError;
// parse appropriate status code
switch (durableJobStatus.RuntimeStatus)
{
case OrchestrationRuntimeStatus.Canceled:
returnStatusCode = HttpStatusCode.NoContent;
break;
case OrchestrationRuntimeStatus.Completed:
returnStatusCode = HttpStatusCode.OK;
break;
case OrchestrationRuntimeStatus.Pending:
returnStatusCode = HttpStatusCode.Created;
break;
case OrchestrationRuntimeStatus.ContinuedAsNew:
case OrchestrationRuntimeStatus.Running:
returnStatusCode = HttpStatusCode.Accepted;
break;
case OrchestrationRuntimeStatus.Failed:
returnStatusCode = HttpStatusCode.InternalServerError;
break;
case OrchestrationRuntimeStatus.Terminated:
returnStatusCode = HttpStatusCode.ServiceUnavailable;
break;
}
return(req.CreateResponse(returnStatusCode));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = "hotelgroups/{code}/terminate")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient context,
string code,
TraceWriter log)
{
try
{
log.Info($"Terminating instance '{code}'....");
// Not sure why terminating causes a timeout event at the actor!!! Question in forums
await context.TerminateAsync(code, "Via an API request");
return(req.CreateResponse(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Admin, "post", Route = "clearschedule")] ClearScheduleModel clearScheduleModel,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
if (!clearScheduleModel.IsValid())
{
return(new BadRequestResult());
}
if (await starter.TryStartSingletonAsync(nameof(ClearScheduleOrchestrator), clearScheduleModel.InstanceId, clearScheduleModel))
{
return(new OkResult());
}
else
{
return(new ConflictResult());
}
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
// Function input comes from the request content.
string instanceId = await starter.StartNewAsync("E3_Monitor", new MonitorRequest
{
Phone = "0643787755",
Location = new Location {
City = "Amsterdam",
State = "NoordHolland"
}
});
log.LogWarning($"Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Admin, "post", Route = "start/{teamId}")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient starter,
string teamId,
ILogger log)
{
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId);
var teamModel = TeamModel.FromConnection(connectionModel);
if (await starter.TryStartSingletonAsync(nameof(TeamOrchestrator), teamModel.TeamId, teamModel))
{
return(new OkResult());
}
else
{
return(new ConflictResult());
}
}
public static async void Run([BlobTrigger("sample-items/{name}")] Stream req,
[OrchestrationClient] DurableOrchestrationClient starter, string name,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
RequestApplication blobDetails = new RequestApplication();
string fileName = name;
string storagePath = Environment.GetEnvironmentVariable("StorageaccountBaseURL") + Environment.GetEnvironmentVariable("inputStorageContainer") + name;
blobDetails.name = fileName;
blobDetails.LocationUrl = storagePath;
await starter.StartNewAsync("Orchestration_Function", blobDetails);
// string id = await Starter.StartNewAsync("Orchestration_Function", blobDetails);
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
var request = await req.Content.ReadAsAsync <AddCertificateRequest>();
if (request?.Domains == null || request.Domains.Length == 0)
{
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, $"{nameof(request.Domains)} is empty."));
}
// Function input comes from the request content.
var instanceId = await starter.StartNewAsync(nameof(SharedFunctions.IssueCertificate), request.Domains);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(req, instanceId, TimeSpan.FromMinutes(5)));
}
protected override async Task OnLaunchRequestAsync(Session session, CancellationToken cancellationToken)
{
// check status
var status = await DurableOrchestrationClient.GetStatusAsync(session.User.UserId);
if (status?.RuntimeStatus == OrchestrationRuntimeStatus.ContinuedAsNew ||
status?.RuntimeStatus == OrchestrationRuntimeStatus.Pending ||
status?.RuntimeStatus == OrchestrationRuntimeStatus.Running)
{
Response.AddText("Counting has not finished yet.");
}
else
{
Response
.AddText("How many counts?")
.AddRepromptText("Please specify the number of counts.")
.KeepListening();
}
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Admin, "post", Route = "purge")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
var runtimeStatus = new List <OrchestrationRuntimeStatus>
{
OrchestrationRuntimeStatus.Running,
OrchestrationRuntimeStatus.ContinuedAsNew
};
var instances = await starter.GetStatusAsync(DateTime.MinValue, DateTime.MaxValue, runtimeStatus);
foreach (var instance in instances)
{
await starter.TerminateAsync(instance.InstanceId, nameof(PurgeTrigger));
}
return(new OkResult());
}
public async Task <IActionResult> GetTestOutput(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "GetTestOutput/{instanceId}")] HttpRequestMessage req,
string instanceId,
[OrchestrationClient] DurableOrchestrationClient durableClient,
ILogger log
)
{
log.LogInformation($"Getting test output for orchestration with ID = '{instanceId}'.");
DurableOrchestrationStatus status = await durableClient.GetStatusAsync(instanceId, true);
if (status?.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
{
var res = status.Output.ToObject <NailResult[]>();
return(new OkObjectResult(res));
}
return(new OkObjectResult(status?.Output));
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
var data = await req.Content.ReadAsStringAsync();
var msg = JsonConvert.DeserializeObject <GetCellDataMessageInput>(data);
string instanceId = await starter.StartNewAsync("GetCellDataOrchestrator", msg);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
var res = starter.CreateCheckStatusResponse(req, instanceId);
res.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(5));
return(res);
}
public static async Task <IActionResult> AcknowledgeTrip([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "tripmanagers/{code}/acknowledge/drivers/{drivercode}")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient context,
string code,
string drivercode,
ILogger log)
{
try
{
await context.RaiseEventAsync(code, Constants.TRIP_DRIVER_ACCEPT_EVENT, drivercode);
return((ActionResult) new OkObjectResult("Ok"));
}
catch (Exception ex)
{
var error = $"AcknowledgeTrip failed: {ex.Message}";
log.LogError(error);
return(new BadRequestObjectResult(error));
}
}
public static async Task <IActionResult> OnPaymentReceived2(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req,
[OrchestrationClient] DurableOrchestrationClient durableClient,
ILogger log)
{
log.LogInformation("Received a payment.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var order = JsonConvert.DeserializeObject <Order>(requestBody);
log.LogInformation($"Order {order.Id} received from {order.Email}" +
$" for product {order.ProductId}");
var orchestrationId = await durableClient.StartNewAsync(
nameof(NewOrderWorkflow), order);
var response = durableClient.CreateHttpManagementPayload(orchestrationId);
return(new OkObjectResult(response));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "delete", Route = "job/{jobId}")] HttpRequestMessage req,
string jobId,
[OrchestrationClient] DurableOrchestrationClient JobsOrchestrator,
ILogger log)
{
var status = await JobsOrchestrator.GetStatusAsync(jobId);
if (status != null)
{
switch (req.Method.ToString())
{
//get status of job
case "GET":
var tmp = new { id = status.InstanceId, status = status.RuntimeStatus, output = status.Output != null?status.Output.ToString() : "" };
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(tmp))
});
case "DELETE":
await JobsOrchestrator.TerminateAsync(jobId, "user requested termination");
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(jobId)
});
default:
return(new HttpResponseMessage(HttpStatusCode.NotImplemented)
{
Content = new StringContent(jobId)
});
}
}
else
{
return(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(jobId)
});
}
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, methods: "post", Route = "OrdineCliente")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
Microsoft.Extensions.Logging.ILogger logger)
{
// Registrazione del tracewriter su Serilog
logger.UseSerilog();
OrdiniAcquistoModel ordiniAcquisto = await req.Content.ReadAsAsync <OrdiniAcquistoModel>();
string instanceId = await starter.StartNewAsync(Workflow.OrdineClienteManager, ordiniAcquisto);
// Verifica completamento lavoro...
Log.Information($"Inizio Orchestratore con ID = '{instanceId}'.");
var res = starter.CreateCheckStatusResponse(req, instanceId);
res.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromMinutes(10));
return(res);
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
log.LogInformation("LOG-MESSAGE: 1. Starting orchestration...");
var jsonStr = await req.Content.ReadAsStringAsync();
log.LogInformation($"LOG-MESSAGE: 3. STARTING data = '{jsonStr}'.");
var data = JsonConvert.DeserializeObject <VirtualMachineIds>(jsonStr);
string instanceId = await starter.StartNewAsync("vmManagementOrchestration", data);
log.LogInformation($"LOG-MESSAGE: Started orchestration with ID = '{instanceId}'.");
return(starter.CreateCheckStatusResponse(req, instanceId));
}
public static async Task <HttpResponseMessage> ReceiveApprovalResponse([HttpTrigger(AuthorizationLevel.Function, methods: "get", Route = "verify")] HttpRequestMessage req,
[OrchestrationClient] DurableOrchestrationClient orchestrationClient,
ILogger log)
{
log.LogInformation($"Received an E-Mail Confirmation");
string instanceId = req.RequestUri.ParseQueryString().GetValues("corelationId")[0];
string confirmationCode = req.RequestUri.ParseQueryString().GetValues("confirmationCode")[0];
string action = req.RequestUri.ParseQueryString().GetValues("action")[0];
log.LogInformation($"InstanceId: {instanceId}, Confirmation Code: {confirmationCode}, Action: {action}");
var status = await orchestrationClient.GetStatusAsync(instanceId);
log.LogInformation($"Orchestration status: {status}");
if (status != null && (status.RuntimeStatus == OrchestrationRuntimeStatus.Running || status.RuntimeStatus == OrchestrationRuntimeStatus.Pending))
{
bool isApproved = false;
string message = "The request has been cancelled.";
if (action.ToLower() == "confirm")
{
isApproved = true;
message = "Thanks for confirming your email!";
}
var request = new ConfirmationResponse()
{
Approved = isApproved,
ConfirmationCode = confirmationCode
};
await orchestrationClient.RaiseEventAsync(instanceId, "ReceiveApprovalResponse", request);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(message)
});
}
else
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("Whoops! Something went wrong!")
});
}
}
