private async Task StartAsyncCore(CancellationToken cancellationToken)
{
ListenerFactoryContext context = new ListenerFactoryContext(cancellationToken);
_listener = await _factory.CreateAsync(context);
_cancellationRegistration = _cancellationSource.Token.Register(_listener.Cancel);
await _listener.StartAsync(cancellationToken);
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return Task.FromResult<IListener>(new FileListener(_config, _attribute, context.Executor));
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return Task.FromResult<IListener>(new TimerListener(_attribute, context.Descriptor.Id, _config, context.Executor, _trace));
}
public async Task CreateAsync_AccessRightsNotManage_DoesNotCreateQueue(AccessRights accessRights)
{
ServiceBusAccount account = new ServiceBusAccount();
Mock<ITriggeredFunctionExecutor> mockExecutor = new Mock<ITriggeredFunctionExecutor>(MockBehavior.Strict);
ServiceBusQueueListenerFactory factory = new ServiceBusQueueListenerFactory(account, "testqueue", mockExecutor.Object, accessRights);
ListenerFactoryContext context = new ListenerFactoryContext(CancellationToken.None);
IListener listener = await factory.CreateAsync(context);
Assert.NotNull(listener);
}
public async Task CreateAsync_AccessRightsNotManage_DoesNotCreateTopicOrSubscription(AccessRights accessRights)
{
ServiceBusAccount account = new ServiceBusAccount();
Mock<ITriggeredFunctionExecutor<BrokeredMessage>> mockExecutor = new Mock<ITriggeredFunctionExecutor<BrokeredMessage>>(MockBehavior.Strict);
ServiceBusSubscriptionListenerFactory factory = new ServiceBusSubscriptionListenerFactory(account, "testtopic", "testsubscription", mockExecutor.Object, accessRights);
ListenerFactoryContext context = new ListenerFactoryContext(CancellationToken.None);
IListener listener = await factory.CreateAsync(context);
Assert.NotNull(listener);
}
public async Task<IListener> CreateAsync(ListenerFactoryContext context)
{
List<IListener> listeners = new List<IListener>();
foreach (IListenerFactory listenerFactory in _listenerFactories)
{
IListener listener = await listenerFactory.CreateAsync(context);
listeners.Add(listener);
}
return new CompositeListener(listeners);
}
public async Task<IListener> CreateAsync(ListenerFactoryContext context)
{
if (_accessRights == AccessRights.Manage)
{
// Must create all messaging entities before creating message receivers and calling OnMessage.
// Otherwise, some function could start to execute and try to output messages to entities that don't yet
// exist.
await _namespaceManager.CreateQueueIfNotExistsAsync(_queueName, context.CancellationToken);
}
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_executor);
return new ServiceBusListener(_messagingFactory, _queueName, triggerExecutor);
}
public async Task<IDelayedException> TryExecuteAsync(IFunctionInstance instance, CancellationToken cancellationToken)
{
IDelayedException result;
ListenerFactoryContext context = new ListenerFactoryContext(cancellationToken);
using (IListener listener = await _abortListenerFactory.CreateAsync(context))
{
await listener.StartAsync(cancellationToken);
result = await _innerExecutor.TryExecuteAsync(instance, cancellationToken);
await listener.StopAsync(cancellationToken);
}
return result;
}
public async Task<IListener> CreateAsync(ListenerFactoryContext context)
{
if (_accessRights == AccessRights.Manage)
{
// Must create all messaging entities before creating message receivers and calling OnMessage.
// Otherwise, some function could start to execute and try to output messages to entities that don't yet
// exist.
await _namespaceManager.CreateTopicIfNotExistsAsync(_topicName, context.CancellationToken);
await _namespaceManager.CreateSubscriptionIfNotExistsAsync(_topicName, _subscriptionName, context.CancellationToken);
}
string entityPath = SubscriptionClient.FormatSubscriptionPath(_topicName, _subscriptionName);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_executor);
return new ServiceBusListener(_messagingFactory, entityPath, triggerExecutor);
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
IListener listener;
if (_mode == Mode.PubSub)
{
listener = new RedisChannelListener(_channelOrKey, context.Executor, _config, _trace);
}
else
{
listener = new RedisCacheListener(_channelOrKey, context.Executor, _config, _trace);
}
return Task.FromResult(listener);
}
public async Task<IListener> CreateAsync(ListenerFactoryContext context)
{
List<IListener> listeners = new List<IListener>();
foreach (IFunctionDefinition functionDefinition in _functionDefinitions)
{
IListenerFactory listenerFactory = functionDefinition.ListenerFactory;
if (listenerFactory == null)
{
continue;
}
IListener listener = await listenerFactory.CreateAsync(context);
listeners.Add(listener);
}
return new CompositeListener(listeners);
}
public Task<IListener> CreateAsync(ListenerFactoryContext context)
{
ITriggerExecutor<IStorageQueueMessage> triggerExecutor = new HostMessageExecutor(_executor, _functionLookup, _functionInstanceLogger);
TimeSpan configuredMaximum = _queueConfiguration.MaxPollingInterval;
// Provide an upper bound on the maximum polling interval for run/abort from dashboard.
// Use the default maximum for host polling (1 minute) unless the configured overall maximum is even faster.
TimeSpan maximum = configuredMaximum < DefaultMaximum ? configuredMaximum : DefaultMaximum;
IDelayStrategy delayStrategy = new RandomizedExponentialBackoffStrategy(Minimum, maximum);
IListener listener = new QueueListener(_queue,
poisonQueue: null,
triggerExecutor: triggerExecutor,
delayStrategy: delayStrategy,
backgroundExceptionDispatcher: _backgroundExceptionDispatcher,
log: _log,
sharedWatcher: null,
queueConfiguration: _queueConfiguration);
return Task.FromResult(listener);
}
public Task<IListener> CreateAsync(ListenerFactoryContext context)
{
IListener listener = new NullListener();
return Task.FromResult(listener);
}
public async Task<IListener> CreateAsync(ListenerFactoryContext context)
{
SharedQueueWatcher sharedQueueWatcher = _sharedContextProvider.GetOrCreate<SharedQueueWatcher>(
new SharedQueueWatcherFactory(_messageEnqueuedWatcherSetter));
SharedBlobListener sharedBlobListener = _sharedContextProvider.GetOrCreate<SharedBlobListener>(
new SharedBlobListenerFactory(_account, _backgroundExceptionDispatcher, _blobWrittenWatcherSetter));
// Note that these clients are intentionally for the storage account rather than for the dashboard account.
// We use the storage, not dashboard, account for the blob receipt container and blob trigger queues.
IStorageQueueClient queueClient = _account.CreateQueueClient();
IStorageBlobClient blobClient = _account.CreateBlobClient();
string hostId = await _hostIdProvider.GetHostIdAsync(context.CancellationToken);
string hostBlobTriggerQueueName = HostQueueNames.GetHostBlobTriggerQueueName(hostId);
IStorageQueue hostBlobTriggerQueue = queueClient.GetQueueReference(hostBlobTriggerQueueName);
IListener blobDiscoveryToQueueMessageListener = await CreateBlobDiscoveryToQueueMessageListenerAsync(
hostId, sharedBlobListener, blobClient, hostBlobTriggerQueue, sharedQueueWatcher, context.CancellationToken);
IListener queueMessageToTriggerExecutionListener = CreateQueueMessageToTriggerExecutionListener(
_sharedContextProvider, sharedQueueWatcher, queueClient, hostBlobTriggerQueue, blobClient,
sharedBlobListener.BlobWritterWatcher);
IListener compositeListener = new CompositeListener(
blobDiscoveryToQueueMessageListener,
queueMessageToTriggerExecutionListener);
return compositeListener;
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
IStorageBlobContainer container = _client.GetContainerReference(_path.ContainerNamePattern);
var factory = new BlobListenerFactory(_hostIdProvider, _queueConfiguration,
_backgroundExceptionDispatcher, _blobWrittenWatcherSetter, _messageEnqueuedWatcherSetter,
_sharedContextProvider, _log, context.Descriptor.Id, _account, container, _path, context.Executor);
return factory.CreateAsync(context.CancellationToken);
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
WebHookListener listener = new WebHookListener(_dispatcher, (MethodInfo)_parameter.Member, _route, context.Executor);
return Task.FromResult<IListener>(listener);
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var factory = new QueueListenerFactory(_queue, _queueConfiguration, _backgroundExceptionDispatcher,
_messageEnqueuedWatcherSetter, _sharedContextProvider, _log, context.Executor);
return factory.CreateAsync(context.CancellationToken);
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
return Task.FromResult<IListener>(new Listener(context.Executor));
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return Task.FromResult<IListener>(new ErrorTriggerListener(_config, _parameter, context.Executor));
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return Task.FromResult<IListener>(new NullListener());
}
public Task<IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
IListenerFactory factory = null;
if (_queueName != null)
{
factory = new ServiceBusQueueListenerFactory(_account, _queueName, context.Executor, _accessRights);
}
else
{
factory = new ServiceBusSubscriptionListenerFactory(_account, _topicName, _subscriptionName, context.Executor, _accessRights);
}
return factory.CreateAsync(context.CancellationToken);
}
