// Tries to get all SubOrchestration instanceIds for a given Orchestration
private static async Task <IEnumerable <HistoryEntity> > GetSubOrchestrationsAsync(string taskHubName, string instanceId)
{
// Querying the table directly, as there is no other known way
var table = TableClient.GetTableClient().GetTableReference($"{taskHubName}History");
var query = new TableQuery <HistoryEntity>()
.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, instanceId),
TableOperators.And,
TableQuery.GenerateFilterCondition("EventType", QueryComparisons.Equal, "SubOrchestrationInstanceCreated")
));
return((await table.GetAllAsync(query)).OrderBy(he => he._Timestamp));
}
private static async Task <HashSet <string> > GetTaskHubNamesFromStorage(string connStringName)
{
var tableNames = await TableClient.GetTableClient(connStringName).ListTableNamesAsync();
var hubNames = new HashSet <string>(tableNames
.Where(n => n.EndsWith("Instances"))
.Select(n => n.Remove(n.Length - "Instances".Length)),
StringComparer.InvariantCultureIgnoreCase);
hubNames.IntersectWith(tableNames
.Where(n => n.EndsWith("History"))
.Select(n => n.Remove(n.Length - "History".Length)));
return(hubNames);
}
// Lists all allowed Task Hubs. The returned HashSet is configured to ignore case.
public static async Task <HashSet <string> > GetAllowedTaskHubNamesAsync()
{
// Respecting DFM_HUB_NAME, if it is set
string dfmHubName = Environment.GetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME);
if (!string.IsNullOrEmpty(dfmHubName))
{
return(new HashSet <string>(dfmHubName.Split(','), StringComparer.InvariantCultureIgnoreCase));
}
// Also respecting host.json setting, when set
dfmHubName = TryGetHubNameFromHostJson();
if (!string.IsNullOrEmpty(dfmHubName))
{
return(new HashSet <string>(new string[] { dfmHubName }, StringComparer.InvariantCultureIgnoreCase));
}
// Otherwise trying to load table names from the Storage
try
{
var tableNames = await TableClient.GetTableClient().ListTableNamesAsync();
var hubNames = new HashSet <string>(tableNames
.Where(n => n.EndsWith("Instances"))
.Select(n => n.Remove(n.Length - "Instances".Length)),
StringComparer.InvariantCultureIgnoreCase);
hubNames.IntersectWith(tableNames
.Where(n => n.EndsWith("History"))
.Select(n => n.Remove(n.Length - "History".Length)));
return(hubNames);
}
catch (Exception)
{
// Intentionally returning null. Need to skip validation, if for some reason list of tables
// cannot be loaded from Storage. But only in that case.
return(null);
}
}
/// <summary>
/// Fetches orchestration instance history directly from XXXHistory table
/// Tries to mimic this algorithm: https://github.com/Azure/azure-functions-durable-extension/blob/main/src/WebJobs.Extensions.DurableTask/ContextImplementations/DurableClient.cs#L718
/// Intentionally returns IEnumerable<>, because the consuming code not always iterates through all of it.
/// </summary>
public static IEnumerable <HistoryEvent> GetHistoryDirectlyFromTable(IDurableClient durableClient, string connName, string hubName, string instanceId)
{
var tableClient = TableClient.GetTableClient(connName);
// Need to fetch executionId first
var instanceEntity = tableClient.ExecuteAsync($"{hubName}Instances", TableOperation.Retrieve(instanceId, string.Empty))
.Result.Result as DynamicTableEntity;
string executionId = instanceEntity.Properties.ContainsKey("ExecutionId") ?
instanceEntity.Properties["ExecutionId"].StringValue :
null;
var instanceIdFilter = TableQuery.CombineFilters
(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, instanceId),
TableOperators.And,
TableQuery.GenerateFilterCondition("ExecutionId", QueryComparisons.Equal, executionId)
);
// Fetching _all_ correlated events with a separate parallel query. This seems to be the only option.
var correlatedEventsQuery = new TableQuery <HistoryEntity>().Where
(
TableQuery.CombineFilters
(
instanceIdFilter,
TableOperators.And,
TableQuery.GenerateFilterConditionForInt("TaskScheduledId", QueryComparisons.GreaterThanOrEqual, 0)
)
);
var correlatedEventsTask = tableClient.GetAllAsync($"{hubName}History", correlatedEventsQuery)
.ContinueWith(t => t.Result.ToDictionary(e => e.TaskScheduledId));
// Memorizing 'ExecutionStarted' event, to further correlate with 'ExecutionCompleted'
HistoryEntity executionStartedEvent = null;
// Fetching the history
var query = new TableQuery <HistoryEntity>().Where(instanceIdFilter);
foreach (var evt in tableClient.GetAll($"{hubName}History", query))
{
switch (evt.EventType)
{
case "TaskScheduled":
case "SubOrchestrationInstanceCreated":
// Trying to match the completion event
correlatedEventsTask.Result.TryGetValue(evt.EventId, out var correlatedEvt);
if (correlatedEvt != null)
{
yield return(correlatedEvt.ToHistoryEvent
(
evt._Timestamp,
evt.Name,
correlatedEvt.EventType == "GenericEvent" ? evt.EventType : null,
evt.InstanceId
));
}
else
{
yield return(evt.ToHistoryEvent());
}
break;
case "ExecutionStarted":
executionStartedEvent = evt;
yield return(evt.ToHistoryEvent(null, evt.Name));
break;
case "ExecutionCompleted":
case "ExecutionFailed":
case "ExecutionTerminated":
yield return(evt.ToHistoryEvent(executionStartedEvent?._Timestamp));
break;
case "ContinueAsNew":
case "TimerCreated":
case "TimerFired":
case "EventRaised":
case "EventSent":
yield return(evt.ToHistoryEvent());
break;
}
}
}
public static async Task <IActionResult> DfmPostOrchestrationFunction(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = Globals.ApiRoutePrefix + "/orchestrations('{instanceId}')/{action?}")] HttpRequest req,
string instanceId,
string action,
[DurableClient(TaskHub = Globals.TaskHubRouteParamName)] IDurableClient durableClient,
ILogger log)
{
// Checking that the call is authenticated properly
try
{
await Auth.ValidateIdentityAsync(req.HttpContext.User, req.Headers, durableClient.TaskHubName);
}
catch (Exception ex)
{
log.LogError(ex, "Failed to authenticate request");
return(new UnauthorizedResult());
}
// Checking that we're not in ReadOnly mode
if (DfmEndpoint.Settings.Mode == DfmMode.ReadOnly)
{
log.LogError("Endpoint is in ReadOnly mode");
return(new StatusCodeResult(403));
}
string bodyString = await req.ReadAsStringAsync();
switch (action)
{
case "purge":
await durableClient.PurgeInstanceHistoryAsync(instanceId);
break;
case "rewind":
await durableClient.RewindAsync(instanceId, bodyString);
break;
case "terminate":
await durableClient.TerminateAsync(instanceId, bodyString);
break;
case "raise-event":
dynamic bodyObject = JObject.Parse(bodyString);
string eventName = bodyObject.name;
JObject eventData = bodyObject.data;
var match = ExpandedOrchestrationStatus.EntityIdRegex.Match(instanceId);
// if this looks like an Entity
if (match.Success)
{
// then sending signal
var entityId = new EntityId(match.Groups[1].Value, match.Groups[2].Value);
await durableClient.SignalEntityAsync(entityId, eventName, eventData);
}
else
{
// otherwise raising event
await durableClient.RaiseEventAsync(instanceId, eventName, eventData);
}
break;
case "set-custom-status":
// Updating the table directly, as there is no other known way
var table = TableClient.GetTableClient().GetTableReference($"{durableClient.TaskHubName}Instances");
var orcEntity = (await table.ExecuteAsync(TableOperation.Retrieve(instanceId, string.Empty))).Result as DynamicTableEntity;
if (string.IsNullOrEmpty(bodyString))
{
orcEntity.Properties.Remove("CustomStatus");
}
else
{
// Ensuring that it is at least a valid JSON
string customStatus = JObject.Parse(bodyString).ToString();
orcEntity.Properties["CustomStatus"] = new EntityProperty(customStatus);
}
await table.ExecuteAsync(TableOperation.Replace(orcEntity));
break;
case "restart":
bool restartWithNewInstanceId = ((dynamic)JObject.Parse(bodyString)).restartWithNewInstanceId;
await durableClient.RestartAsync(instanceId, restartWithNewInstanceId);
break;
default:
return(new NotFoundResult());
}
return(new OkResult());
}