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;
        }
Пример #15
0
        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);
        }