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