Task IDurableOrchestrationClient.RaiseEventAsync(string taskHubName, string instanceId, string eventName, object eventData, string connectionName)
{
if (string.IsNullOrEmpty(taskHubName))
{
throw new ArgumentNullException(nameof(taskHubName));
}
if (string.IsNullOrEmpty(eventName))
{
throw new ArgumentNullException(nameof(eventName));
}
if (string.IsNullOrEmpty(connectionName))
{
connectionName = this.attribute.ConnectionName;
}
var attribute = new DurableClientAttribute
{
TaskHub = taskHubName,
ConnectionName = connectionName,
};
TaskHubClient taskHubClient = ((DurableClient)this.config.GetClient(attribute)).client;
return(this.RaiseEventInternalAsync(taskHubClient, taskHubName, instanceId, eventName, eventData));
}
private IDurableClient GetClient(HttpRequestMessage request)
{
string taskHub = null;
string connectionName = null;
NameValueCollection pairs = request.GetQueryNameValuePairs();
foreach (string key in pairs.AllKeys)
{
if (taskHub == null &&
key.Equals(TaskHubParameter, StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrWhiteSpace(pairs[key]))
{
taskHub = pairs[key];
}
else if (connectionName == null &&
key.Equals(ConnectionParameter, StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrWhiteSpace(pairs[key]))
{
connectionName = pairs[key];
}
}
var attribute = new DurableClientAttribute
{
TaskHub = taskHub,
ConnectionName = connectionName,
};
return(this.GetClient(attribute));
}
private AzureStorageDurabilityProvider GetAzureStorageStorageProvider(DurableClientAttribute attribute)
{
string connectionName = attribute.ConnectionName ?? this.defaultConnectionName;
AzureStorageOrchestrationServiceSettings settings = this.GetAzureStorageOrchestrationServiceSettings(connectionName, attribute.TaskHub);
AzureStorageDurabilityProvider innerClient;
// Need to check this.defaultStorageProvider != null for external clients that call GetDurabilityProvider(attribute)
// which never initializes the defaultStorageProvider.
if (string.Equals(this.defaultSettings?.TaskHubName, settings.TaskHubName, StringComparison.OrdinalIgnoreCase) &&
string.Equals(this.defaultSettings?.StorageConnectionString, settings.StorageConnectionString, StringComparison.OrdinalIgnoreCase) &&
this.defaultStorageProvider != null)
{
// It's important that clients use the same AzureStorageOrchestrationService instance
// as the host when possible to ensure we any send operations can be picked up
// immediately instead of waiting for the next queue polling interval.
innerClient = this.defaultStorageProvider;
}
else
{
ILogger logger = this.loggerFactory.CreateLogger(LoggerName);
innerClient = new AzureStorageDurabilityProvider(
new AzureStorageOrchestrationService(settings),
connectionName,
this.azureStorageOptions,
logger);
}
return(innerClient);
}
private AzureStorageDurabilityProvider GetAzureStorageStorageProvider(DurableClientAttribute attribute)
{
string connectionName = attribute.ConnectionName ?? this.defaultConnectionName;
AzureStorageOrchestrationServiceSettings settings = this.GetAzureStorageOrchestrationServiceSettings(connectionName, attribute.TaskHub);
AzureStorageDurabilityProvider innerClient;
if (string.Equals(this.defaultSettings.TaskHubName, settings.TaskHubName, StringComparison.OrdinalIgnoreCase) &&
string.Equals(this.defaultSettings.StorageConnectionString, settings.StorageConnectionString, StringComparison.OrdinalIgnoreCase))
{
// It's important that clients use the same AzureStorageOrchestrationService instance
// as the host when possible to ensure we any send operations can be picked up
// immediately instead of waiting for the next queue polling interval.
innerClient = this.defaultStorageProvider;
}
else
{
innerClient = new AzureStorageDurabilityProvider(
new AzureStorageOrchestrationService(settings),
connectionName,
this.azureStorageOptions);
}
return(innerClient);
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var parameter = context.Parameter;
var parameterType = parameter.ParameterType;
if (parameterType.Name != TypedCodeProvider.ITypedDurableClient)
{
return(Task.FromResult <IBinding>(null));
}
DurableClientAttribute clientAttr = parameter.GetCustomAttribute <DurableClientAttribute>(inherit: false);
if (clientAttr == null)
{
return(Task.FromResult <IBinding>(null));
}
var client = this.clientGenerator(clientAttr);
if (client == null)
{
return(Task.FromResult <IBinding>(null));
}
return(Task.FromResult <IBinding>(new TypedDurableClientBinding(this.typedCodeProvider, client, parameter)));
}
// Get a response that will point to our webhook handler.
internal HttpResponseMessage CreateCheckStatusResponse(
HttpRequestMessage request,
string instanceId,
DurableClientAttribute attribute,
bool returnInternalServerErrorOnFailure = false)
{
return(this.httpApiHandler.CreateCheckStatusResponse(request, instanceId, attribute, returnInternalServerErrorOnFailure));
}
public virtual DurabilityProvider GetDurabilityProvider(DurableClientAttribute attribute)
{
if (!attribute.ExternalClient)
{
this.EnsureDefaultClientSettingsInitialized();
}
return(this.GetAzureStorageStorageProvider(attribute));
}
internal DurableClient(
DurabilityProvider serviceClient,
DurableTaskExtension config,
HttpApiHandler httpHandler,
DurableClientAttribute attribute)
: this(serviceClient, httpHandler, attribute, config.MessageDataConverter, config.TraceHelper, config.Options)
{
this.config = config;
}
internal async Task <HttpResponseMessage> WaitForCompletionOrCreateCheckStatusResponseAsync(
HttpRequestMessage request,
string instanceId,
DurableClientAttribute attribute,
TimeSpan timeout,
TimeSpan retryInterval)
{
if (retryInterval > timeout)
{
throw new ArgumentException($"Total timeout {timeout.TotalSeconds} should be bigger than retry timeout {retryInterval.TotalSeconds}");
}
HttpManagementPayload httpManagementPayload = this.GetClientResponseLinks(request, instanceId, attribute?.TaskHub, attribute?.ConnectionName);
IDurableOrchestrationClient client = this.GetClient(request);
Stopwatch stopwatch = Stopwatch.StartNew();
while (true)
{
DurableOrchestrationStatus status = await client.GetStatusAsync(instanceId);
if (status != null)
{
if (status.RuntimeStatus == OrchestrationRuntimeStatus.Completed)
{
return(request.CreateResponse(HttpStatusCode.OK, status.Output));
}
if (status.RuntimeStatus == OrchestrationRuntimeStatus.Canceled ||
status.RuntimeStatus == OrchestrationRuntimeStatus.Failed ||
status.RuntimeStatus == OrchestrationRuntimeStatus.Terminated)
{
return(await this.HandleGetStatusRequestAsync(request, instanceId));
}
}
TimeSpan elapsed = stopwatch.Elapsed;
if (elapsed < timeout)
{
TimeSpan remainingTime = timeout.Subtract(elapsed);
await Task.Delay(remainingTime > retryInterval?retryInterval : remainingTime);
}
else
{
return(this.CreateCheckStatusResponseMessage(
request,
instanceId,
httpManagementPayload.StatusQueryGetUri,
httpManagementPayload.SendEventPostUri,
httpManagementPayload.TerminatePostUri,
httpManagementPayload.PurgeHistoryDeleteUri));
}
}
}
/// <summary>
/// Gets a <see cref="IDurableClient"/> using configuration from a <see cref="DurableClientAttribute"/> instance.
/// </summary>
/// <param name="attribute">The attribute containing the client configuration parameters.</param>
/// <returns>Returns a <see cref="IDurableClient"/> instance. The returned instance may be a cached instance.</returns>
protected internal virtual IDurableClient GetClient(DurableClientAttribute attribute)
{
DurableClient client = this.cachedClients.GetOrAdd(
attribute,
attr =>
{
DurabilityProvider innerClient = this.durabilityProviderFactory.GetDurabilityProvider(attribute);
return(new DurableClient(innerClient, this, this.HttpApiHandler, attr));
});
return(client);
}
// Get a response that will point to our webhook handler.
internal HttpResponseMessage CreateCheckStatusResponse(
HttpRequestMessage request,
string instanceId,
DurableClientAttribute attribute,
bool returnInternalServerErrorOnFailure = false)
{
if (this.httpApiHandler == null)
{
throw new InvalidOperationException("IDurableClient.CreateCheckStatusResponse is not supported for IDurableClient instances created outside of a Durable Functions application.");
}
return(this.httpApiHandler.CreateCheckStatusResponse(request, instanceId, attribute, returnInternalServerErrorOnFailure));
}
// Get a response that will wait for response from the durable function for predefined period of time before
// pointing to our webhook handler.
internal async Task <HttpResponseMessage> WaitForCompletionOrCreateCheckStatusResponseAsync(
HttpRequestMessage request,
string instanceId,
DurableClientAttribute attribute,
TimeSpan timeout,
TimeSpan retryInterval)
{
return(await this.httpApiHandler.WaitForCompletionOrCreateCheckStatusResponseAsync(
request,
instanceId,
attribute,
timeout,
retryInterval));
}
private readonly DurableClientAttribute attribute; // for rehydrating a Client after a webhook
internal DurableClient(
DurabilityProvider serviceClient,
DurableTaskExtension config,
HttpApiHandler httpHandler,
DurableClientAttribute attribute)
{
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.client = new TaskHubClient(serviceClient);
this.durabilityProvider = serviceClient;
this.traceHelper = config.TraceHelper;
this.httpApiHandler = httpHandler;
this.hubName = attribute.TaskHub ?? config.Options.HubName;
this.attribute = attribute;
}
internal HttpResponseMessage CreateCheckStatusResponse(
HttpRequestMessage request,
string instanceId,
DurableClientAttribute attribute,
bool returnInternalServerErrorOnFailure = false)
{
HttpManagementPayload httpManagementPayload = this.GetClientResponseLinks(request, instanceId, attribute?.TaskHub, attribute?.ConnectionName, returnInternalServerErrorOnFailure);
return(this.CreateCheckStatusResponseMessage(
request,
httpManagementPayload.Id,
httpManagementPayload.StatusQueryGetUri,
httpManagementPayload.SendEventPostUri,
httpManagementPayload.TerminatePostUri,
httpManagementPayload.PurgeHistoryDeleteUri));
}
internal DurableClient(
DurabilityProvider serviceClient,
HttpApiHandler httpHandler,
DurableClientAttribute attribute,
MessagePayloadDataConverter messageDataConverter,
EndToEndTraceHelper traceHelper,
DurableTaskOptions durableTaskOptions)
{
this.messageDataConverter = messageDataConverter;
this.client = new TaskHubClient(serviceClient, this.messageDataConverter);
this.durabilityProvider = serviceClient;
this.traceHelper = traceHelper;
this.httpApiHandler = httpHandler;
this.durableTaskOptions = durableTaskOptions;
this.hubName = attribute.TaskHub ?? this.durableTaskOptions.HubName;
this.attribute = attribute;
}
public DurabilityProvider GetDurabilityProvider(DurableClientAttribute attribute)
{
if (string.IsNullOrEmpty(attribute.TaskHub) && string.IsNullOrEmpty(attribute.ConnectionName))
{
return(this.defaultProvider);
}
if (string.Equals(attribute.TaskHub, this.defaultHubName) && string.Equals(attribute.ConnectionName, this.defaultConnectionName))
{
return(this.defaultProvider);
}
string redisConnectionString = this.connectionResolver.Resolve(attribute.ConnectionName);
var redisOrchestartionService = new RedisOrchestrationService(new RedisOrchestrationServiceSettings()
{
TaskHubName = attribute.TaskHub,
RedisConnectionString = redisConnectionString,
});
return(new DurabilityProvider("Redis", redisOrchestartionService, redisOrchestartionService, attribute.ConnectionName));
}
/// <inheritdoc />
Task IDurableEntityClient.SignalEntityAsync(EntityId entityId, string operationName, object operationInput, string taskHubName, string connectionName)
{
if (string.IsNullOrEmpty(taskHubName))
{
return(this.SignalEntityAsync(this.client, this.TaskHubName, entityId, operationName, operationInput));
}
else
{
if (string.IsNullOrEmpty(connectionName))
{
connectionName = this.attribute.ConnectionName;
}
var attribute = new DurableClientAttribute
{
TaskHub = taskHubName,
ConnectionName = connectionName,
};
TaskHubClient taskHubClient = ((DurableClient)this.config.GetClient(attribute)).client;
return(this.SignalEntityAsync(taskHubClient, taskHubName, entityId, operationName, operationInput));
}
}
Task <EntityStateResponse <T> > IDurableEntityClient.ReadEntityStateAsync <T>(EntityId entityId, string taskHubName, string connectionName)
{
if (string.IsNullOrEmpty(taskHubName))
{
return(this.ReadEntityStateAsync <T>(this.DurabilityProvider, entityId));
}
else
{
if (string.IsNullOrEmpty(connectionName))
{
connectionName = this.attribute.ConnectionName;
}
var attribute = new DurableClientAttribute
{
TaskHub = taskHubName,
ConnectionName = connectionName,
};
DurabilityProvider durabilityProvider = ((DurableClient)this.config.GetClient(attribute)).DurabilityProvider;
return(this.ReadEntityStateAsync <T>(durabilityProvider, entityId));
}
}
/// <inheritdoc />
Task IDurableEntityClient.SignalEntityAsync(EntityId entityId, DateTime scheduledTimeUtc, string operationName, object operationInput, string taskHubName, string connectionName)
{
if (string.IsNullOrEmpty(taskHubName))
{
return(this.SignalEntityAsyncInternal(this, this.TaskHubName, entityId, scheduledTimeUtc, operationName, operationInput));
}
else
{
if (string.IsNullOrEmpty(connectionName))
{
connectionName = this.attribute.ConnectionName;
}
var attribute = new DurableClientAttribute
{
TaskHub = taskHubName,
ConnectionName = connectionName,
};
var durableClient = (DurableClient)this.config.GetClient(attribute);
return(this.SignalEntityAsyncInternal(durableClient, taskHubName, entityId, scheduledTimeUtc, operationName, operationInput));
}
}
public StartOrchestrationArgs StringToStartOrchestrationArgs(string input, DurableClientAttribute attr)
{
return(!string.IsNullOrEmpty(input) ? JsonConvert.DeserializeObject <StartOrchestrationArgs>(input) : null);
}
public StartOrchestrationArgs JObjectToStartOrchestrationArgs(JObject input, DurableClientAttribute attr)
{
return(input?.ToObject <StartOrchestrationArgs>());
}
public string DurableOrchestrationClientToString(IDurableOrchestrationClient client, DurableClientAttribute attr)
{
var payload = new OrchestrationClientInputData
{
TaskHubName = client.TaskHubName,
CreationUrls = this.config.HttpApiHandler.GetInstanceCreationLinks(),
ManagementUrls = this.config.HttpApiHandler.CreateHttpManagementPayload(InstanceIdPlaceholder, attr?.TaskHub, attr?.ConnectionName),
BaseUrl = this.config.HttpApiHandler.GetBaseUrl(),
RequiredQueryStringParameters = this.config.HttpApiHandler.GetUniversalQueryStrings(),
};
if (this.config.HttpApiHandler.TryGetRpcBaseUrl(out Uri rpcBaseUrl))
{
// If an RPC URL is not available, the out-of-proc durable client SDK is expected to fail.
// In the case of JavaScript, however, the client SDK is expected to revert to legacy behavior.
payload.RpcBaseUrl = rpcBaseUrl.OriginalString;
}
return(JsonConvert.SerializeObject(payload));
}
public IAsyncCollector <StartOrchestrationArgs> CreateAsyncCollector(DurableClientAttribute clientAttribute)
{
IDurableOrchestrationClient client = this.config.GetClient(clientAttribute);
return(new OrchestrationClientAsyncCollector(client));
}
public string DurableOrchestrationClientToString(IDurableOrchestrationClient client, DurableClientAttribute attr)
{
var payload = new OrchestrationClientInputData
{
TaskHubName = client.TaskHubName,
CreationUrls = this.config.HttpApiHandler.GetInstanceCreationLinks(),
ManagementUrls = this.config.HttpApiHandler.CreateHttpManagementPayload(InstanceIdPlaceholder, attr?.TaskHub, attr?.ConnectionName),
BaseUrl = this.config.HttpApiHandler.GetBaseUrl(),
RequiredQueryStringParameters = this.config.HttpApiHandler.GetUniversalQueryStrings(),
};
return(JsonConvert.SerializeObject(payload));
}
public DurabilityProvider GetDurabilityProvider(DurableClientAttribute attribute)
{
return(this.GetAzureStorageStorageProvider(attribute));
}
// protected virtual to allow mocking in unit tests.
protected virtual IDurableClient GetClient(DurableClientAttribute attribute)
{
return(this.config.GetClient(attribute));
}
public DurabilityProvider GetDurabilityProvider(DurableClientAttribute attribute)
{
this.EnsureInitialized();
return(this.GetAzureStorageStorageProvider(attribute));
}
public DurabilityProvider GetDurabilityProvider(DurableClientAttribute attribute)
{
return(this.provider);
}
