public async Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
QueueTriggerAttribute queueTrigger = parameter.GetCustomAttribute<QueueTriggerAttribute>(inherit: false);
if (queueTrigger == null)
{
return null;
}
string queueName = Resolve(queueTrigger.QueueName);
queueName = NormalizeAndValidate(queueName);
ITriggerDataArgumentBinding<IStorageQueueMessage> argumentBinding = InnerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(
"Can't bind QueueTrigger to type '" + parameter.ParameterType + "'.");
}
IStorageAccount account = await _accountProvider.GetStorageAccountAsync(context.CancellationToken);
IStorageQueueClient client = account.CreateQueueClient();
IStorageQueue queue = client.GetQueueReference(queueName);
ITriggerBinding binding = new QueueTriggerBinding(parameter.Name, queue, argumentBinding,
_queueConfiguration, _backgroundExceptionDispatcher, _messageEnqueuedWatcherSetter,
_sharedContextProvider, _log);
return binding;
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
FakeQueueTriggerAttribute attribute = parameter.GetCustomAttribute<FakeQueueTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
var hooks = new FakeQueueTriggerBindingStrategy();
Func<ListenerFactoryContext, bool, Task<IListener>> createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new FakeQueueListener(factoryContext.Executor, _client, singleDispatch);
return Task.FromResult(listener);
};
ITriggerBinding binding = BindingFactory.GetTriggerBinding<FakeQueueData, FakeQueueDataBatch>(
hooks, parameter, _converterManager, createListener);
return Task.FromResult<ITriggerBinding>(binding);
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
HttpTriggerAttribute attribute = parameter.GetCustomAttribute<HttpTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
// Can bind to user types, HttpRequestMessage, object (for dynamic binding support) and all the Read
// Types supported by StreamValueBinder
IEnumerable<Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.Read)
.Union(new Type[] { typeof(HttpRequestMessage), typeof(object) });
bool isSupportedTypeBinding = ValueBinder.MatchParameterType(parameter, supportedTypes);
bool isUserTypeBinding = !isSupportedTypeBinding && Utility.IsValidUserType(parameter.ParameterType);
if (!isSupportedTypeBinding && !isUserTypeBinding)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind HttpTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<ITriggerBinding>(new HttpTriggerBinding(attribute, context.Parameter, isUserTypeBinding));
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
WebHookTriggerAttribute attribute = parameter.GetCustomAttribute<WebHookTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
// Can bind to user types, HttpRequestMessage, and all the types supported by StreamValueBinder
IEnumerable<Type> supportedTypes = StreamValueBinder.SupportedTypes.Union(new Type[] { typeof(HttpRequestMessage) });
bool isSupportedTypeBinding = ValueBinder.MatchParameterType(parameter, supportedTypes);
bool isUserTypeBinding = !isSupportedTypeBinding && WebHookTriggerBinding.IsValidUserType(parameter.ParameterType);
if (!isSupportedTypeBinding && !isUserTypeBinding)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind WebHookTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
if (!isUserTypeBinding && attribute.FromUri)
{
throw new InvalidOperationException("'FromUri' can only be set to True when binding to custom Types.");
}
return Task.FromResult<ITriggerBinding>(new WebHookTriggerBinding(_dispatcher, context.Parameter, isUserTypeBinding, attribute));
}
/// <inheritdoc/>
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
FileTriggerAttribute attribute = parameter.GetCustomAttribute<FileTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
// next, verify that the type is one of the types we support
IEnumerable<Type> types = StreamValueBinder.GetSupportedTypes(FileAccess.Read)
.Union(new Type[] { typeof(FileStream), typeof(FileSystemEventArgs), typeof(FileInfo) });
if (!ValueBinder.MatchParameterType(context.Parameter, types))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind FileTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<ITriggerBinding>(new FileTriggerBinding(_config, parameter, _trace));
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
EventHubTriggerAttribute attribute = parameter.GetCustomAttribute<EventHubTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
string eventHubName = attribute.EventHubName;
string resolvedName = _nameResolver.ResolveWholeString(eventHubName);
var eventHostListener = _eventHubConfig.GetEventProcessorHost(resolvedName);
var options = _eventHubConfig.GetOptions();
var hooks = new EventHubTriggerBindingStrategy();
Func<ListenerFactoryContext, bool, Task<IListener>> createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new EventHubListener(factoryContext.Executor, eventHostListener, options, singleDispatch);
return Task.FromResult(listener);
};
ITriggerBinding binding = BindingFactory.GetTriggerBinding<EventData, EventHubTriggerInput>(hooks, parameter, _converterManager, createListener);
return Task.FromResult<ITriggerBinding>(binding);
}
public async Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
ServiceBusTriggerAttribute attribute = parameter.GetCustomAttribute<ServiceBusTriggerAttribute>(inherit: false);
if (attribute == null)
{
return null;
}
string queueName = null;
string topicName = null;
string subscriptionName = null;
string entityPath = null;
if (attribute.QueueName != null)
{
queueName = Resolve(attribute.QueueName);
entityPath = queueName;
}
else
{
topicName = Resolve(attribute.TopicName);
subscriptionName = Resolve(attribute.SubscriptionName);
entityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
}
ITriggerDataArgumentBinding<BrokeredMessage> argumentBinding = InnerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ServiceBusTrigger to type '{0}'.", parameter.ParameterType));
}
string connectionName = ServiceBusAccount.GetAccountOverrideOrNull(context.Parameter);
ServiceBusAccount account = new ServiceBusAccount
{
MessagingFactory = await _config.MessagingProvider.CreateMessagingFactoryAsync(entityPath, connectionName),
NamespaceManager = _config.MessagingProvider.CreateNamespaceManager(connectionName)
};
ITriggerBinding binding;
if (queueName != null)
{
binding = new ServiceBusTriggerBinding(parameter.Name, parameter.ParameterType, argumentBinding, account, queueName, attribute.Access, _config);
}
else
{
binding = new ServiceBusTriggerBinding(parameter.Name, argumentBinding, account, topicName, subscriptionName, attribute.Access, _config);
}
return binding;
}
public async Task TryCreateAsync_DefaultAccount()
{
_mockMessagingProvider.Setup(p => p.CreateNamespaceManager(null)).Returns<NamespaceManager>(null);
_mockMessagingProvider.Setup(p => p.CreateMessagingFactoryAsync("test", null)).ReturnsAsync(null);
ParameterInfo parameter = GetType().GetMethod("TestJob").GetParameters()[0];
TriggerBindingProviderContext context = new TriggerBindingProviderContext(parameter, CancellationToken.None);
ITriggerBinding binding = await _provider.TryCreateAsync(context);
_mockMessagingProvider.VerifyAll();
}
public async Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
foreach (ITriggerBindingProvider provider in _providers)
{
ITriggerBinding binding = await provider.TryCreateAsync(context);
if (binding != null)
{
return(binding);
}
}
return(null);
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
ServiceBusTriggerAttribute attribute = parameter.GetCustomAttribute<ServiceBusTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
string queueName = null;
string topicName = null;
string subscriptionName = null;
if (attribute.QueueName != null)
{
queueName = Resolve(attribute.QueueName);
}
else
{
topicName = Resolve(attribute.TopicName);
subscriptionName = Resolve(attribute.SubscriptionName);
}
ITriggerDataArgumentBinding<BrokeredMessage> argumentBinding = InnerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ServiceBusTrigger to type '{0}'.", parameter.ParameterType));
}
ServiceBusAccount account = ServiceBusAccount.CreateFromConnectionString(_config.ConnectionString);
ITriggerBinding binding;
if (queueName != null)
{
binding = new ServiceBusTriggerBinding(parameter.Name, parameter.ParameterType, argumentBinding, account, queueName, attribute.Access);
}
else
{
binding = new ServiceBusTriggerBinding(parameter.Name, argumentBinding, account, topicName, subscriptionName, attribute.Access);
}
return Task.FromResult(binding);
}
public async Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
foreach (ITriggerBindingProvider provider in _providers)
{
ITriggerBinding binding = await provider.TryCreateAsync(context);
if (binding != null)
{
return binding;
}
}
return null;
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
WebHookTriggerAttribute attribute = parameter.GetCustomAttribute<WebHookTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
// Can bind to user types, HttpRequestMessage, WebHookContext, and all the Read
// Types supported by StreamValueBinder
IEnumerable<Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.Read)
.Union(new Type[] { typeof(HttpRequestMessage), typeof(WebHookContext) });
bool isSupportedTypeBinding = ValueBinder.MatchParameterType(parameter, supportedTypes);
bool isUserTypeBinding = !isSupportedTypeBinding && WebHookTriggerBinding.IsValidUserType(parameter.ParameterType);
if (!isSupportedTypeBinding && !isUserTypeBinding)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind WebHookTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
if (!isUserTypeBinding && attribute.FromUri)
{
throw new InvalidOperationException("'FromUri' can only be set to True when binding to custom Types.");
}
// Validate route format
if (!string.IsNullOrEmpty(attribute.Route))
{
string[] routeSegements = attribute.Route.Split('/');
if (routeSegements.Length > 2)
{
throw new InvalidOperationException("WebHook routes can only have a maximum of two segments.");
}
}
return Task.FromResult<ITriggerBinding>(new WebHookTriggerBinding(_dispatcher, context.Parameter, isUserTypeBinding, attribute));
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
RedisTriggerAttribute attribute = parameter.GetCustomAttribute<RedisTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
RedisAccount account = RedisAccount.CreateDbFromConnectionString(_config.ConnectionString);
ITriggerBinding binding = new RedisTriggerBinding(parameter, account, attribute.ChannelOrKey, attribute.Mode, _config, _trace);
return Task.FromResult(binding);
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
TimerTriggerAttribute timerTriggerAttribute = parameter.GetCustomAttribute<TimerTriggerAttribute>(inherit: false);
if (timerTriggerAttribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
if (parameter.ParameterType != typeof(TimerInfo))
{
throw new InvalidOperationException(string.Format("Can't bind TimerTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<ITriggerBinding>(new TimerTriggerBinding(parameter, timerTriggerAttribute, _config, _trace));
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
SampleTriggerAttribute attribute = parameter.GetCustomAttribute<SampleTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
// TODO: Define the types your binding supports here
if (parameter.ParameterType != typeof(SampleTriggerValue) &&
parameter.ParameterType != typeof(string))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind SampleTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<ITriggerBinding>(new SampleTriggerBinding(context.Parameter));
}
public Task<ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
ErrorTriggerAttribute attribute = parameter.GetCustomAttribute<ErrorTriggerAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<ITriggerBinding>(null);
}
if (parameter.ParameterType != typeof(TraceFilter) &&
parameter.ParameterType != typeof(TraceEvent) &&
parameter.ParameterType != typeof(IEnumerable<TraceEvent>))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind ErrorTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<ITriggerBinding>(new ErrorTriggerBinding(_config, context.Parameter));
}