public static ITriggerBindingProvider Create(INameResolver nameResolver,
            IStorageAccountProvider storageAccountProvider,
            IExtensionTypeLocator extensionTypeLocator,
            IHostIdProvider hostIdProvider,
            IQueueConfiguration queueConfiguration,
            IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
            IContextSetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
            IContextSetter<IBlobWrittenWatcher> blobWrittenWatcherSetter,
            ISharedContextProvider sharedContextProvider,
            IExtensionRegistry extensions,
            TextWriter log)
        {
            List<ITriggerBindingProvider> innerProviders = new List<ITriggerBindingProvider>();
            innerProviders.Add(new QueueTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
                queueConfiguration, backgroundExceptionDispatcher, messageEnqueuedWatcherSetter,
                sharedContextProvider, log));
            innerProviders.Add(new BlobTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
                extensionTypeLocator, hostIdProvider, queueConfiguration, backgroundExceptionDispatcher,
                blobWrittenWatcherSetter, messageEnqueuedWatcherSetter, sharedContextProvider, log));

            // add any registered extension binding providers
            foreach (ITriggerBindingProvider provider in extensions.GetExtensions(typeof(ITriggerBindingProvider)))
            {
                innerProviders.Add(provider);
            }

            return new CompositeTriggerBindingProvider(innerProviders);
        }
Beispiel #2
0
        /// <inheritdoc />
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            INameResolver nameResolver = context.Config.NameResolver;

            _defaultApiKey = nameResolver.Resolve(AzureWebJobsSendGridApiKeyName);

            IConverterManager converterManager = context.Config.GetService <IConverterManager>();

            converterManager.AddConverter <string, Mail>(SendGridHelpers.CreateMessage);
            converterManager.AddConverter <JObject, Mail>(SendGridHelpers.CreateMessage);

            BindingFactory   factory        = new BindingFactory(nameResolver, converterManager);
            IBindingProvider outputProvider = factory.BindToAsyncCollector <SendGridAttribute, Mail>((attr) =>
            {
                string apiKey            = FirstOrDefault(attr.ApiKey, ApiKey, _defaultApiKey);
                ISendGridClient sendGrid = _sendGridClientCache.GetOrAdd(apiKey, a => ClientFactory.Create(a));
                return(new SendGridMailAsyncCollector(this, attr, sendGrid));
            });

            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

            extensions.RegisterBindingRules <SendGridAttribute>(ValidateBinding, nameResolver, outputProvider);
        }
Beispiel #3
0
 private static IHost CreateConfigurationForManualCompletion <TResult>(
     StorageAccount storageAccount, Type programType, TaskCompletionSource <TResult> taskSource,
     IEnumerable <string> ignoreFailureFunctions, IExtensionRegistry extensions = null, params Type[] cloudBlobStreamBinderTypes)
 {
     return(CreateConfigurationForManualCompletion <TResult>(storageAccount, programType,
                                                             new DefaultJobActivator(), taskSource, ignoreFailureFunctions, extensions));
 }
Beispiel #4
0
        /// <summary>
        /// Initialize the IServiceProvider and add binding rule for the function framework. This is called by the framework.
        /// </summary>
        /// <param name="context">Context for function execution</param>
        public virtual void Initialize(ExtensionConfigContext context)
        {
            var path = System.Reflection.Assembly.GetExecutingAssembly().Location.Split(new[] { @"\bin" }, StringSplitOptions.None)[0];

            var builder = new ConfigurationBuilder()
                          .SetBasePath(path)
                          .AddJsonFile("settings.json");

            Configuration = builder.Build();

            IServiceCollection services = new ServiceCollection();

            services.AddDbContext <DatabaseContext>(options => options.UseSqlServer(Configuration["Storage:ConnectionString"]));
            RegisterServices(services);
            IServiceProvider serviceProvider = services.BuildServiceProvider(true);

            context
            .AddBindingRule <TAttribute>()
            .Bind(new InjectBindingProvider(serviceProvider));

            IExtensionRegistry registry = context.Config.GetService <IExtensionRegistry>();
            ScopeCleanupFilter filter   = new ScopeCleanupFilter();

            registry.RegisterExtension(typeof(IFunctionInvocationFilter), filter);
            registry.RegisterExtension(typeof(IFunctionExceptionFilter), filter);
        }
Beispiel #5
0
        public FunctionIndexProvider(ITypeLocator typeLocator,
                                     ITriggerBindingProvider triggerBindingProvider,
                                     IBindingProvider bindingProvider,
                                     IJobActivator activator,
                                     IFunctionExecutor executor,
                                     IExtensionRegistry extensions,
                                     SingletonManager singletonManager,
                                     ILoggerFactory loggerFactory,
                                     SharedQueueHandler sharedQueue,
                                     TimeoutAttribute defaultTimeout,
                                     bool allowPartialHostStartup = false)
        {
            _typeLocator            = typeLocator ?? throw new ArgumentNullException(nameof(typeLocator));
            _triggerBindingProvider = triggerBindingProvider ?? throw new ArgumentNullException(nameof(triggerBindingProvider));
            _bindingProvider        = bindingProvider ?? throw new ArgumentNullException(nameof(bindingProvider));
            _activator        = activator ?? throw new ArgumentNullException(nameof(activator));
            _executor         = executor ?? throw new ArgumentNullException(nameof(executor));
            _extensions       = extensions ?? throw new ArgumentNullException(nameof(extensions));
            _singletonManager = singletonManager ?? throw new ArgumentNullException(nameof(singletonManager));
            _sharedQueue      = sharedQueue ?? throw new ArgumentNullException(nameof(sharedQueue));

            _loggerFactory           = loggerFactory;
            _defaultTimeout          = defaultTimeout;
            _allowPartialHostStartup = allowPartialHostStartup;
        }
        public static FunctionIndexer Create(CloudStorageAccount account = null, INameResolver nameResolver = null, IExtensionRegistry extensionRegistry = null)
        {
            IStorageAccount storageAccount = account != null ? new StorageAccount(account) : null;
            IStorageAccountProvider storageAccountProvider = new SimpleStorageAccountProvider
            {
                StorageAccount = account
            };
            IExtensionTypeLocator extensionTypeLocator = new NullExtensionTypeLocator();
            ContextAccessor<IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor =
                new ContextAccessor<IMessageEnqueuedWatcher>();
            ContextAccessor<IBlobWrittenWatcher> blobWrittenWatcherAccessor =
                new ContextAccessor<IBlobWrittenWatcher>();
            ISharedContextProvider sharedContextProvider = new SharedContextProvider();
            ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
                storageAccountProvider, extensionTypeLocator,
                new FixedHostIdProvider("test"), new SimpleQueueConfiguration(maxDequeueCount: 5),
                BackgroundExceptionDispatcher.Instance, messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor,
                sharedContextProvider, new DefaultExtensionRegistry(), TextWriter.Null);
            IBindingProvider bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider,
                extensionTypeLocator, messageEnqueuedWatcherAccessor,
                blobWrittenWatcherAccessor, new DefaultExtensionRegistry());

            IFunctionOutputLoggerProvider outputLoggerProvider = new NullFunctionOutputLoggerProvider();
            var task = outputLoggerProvider.GetAsync(CancellationToken.None);
            task.Wait();
            IFunctionOutputLogger outputLogger = task.Result;
            IFunctionExecutor executor = new FunctionExecutor(new NullFunctionInstanceLogger(), outputLogger, BackgroundExceptionDispatcher.Instance);

            if (extensionRegistry == null)
            {
                extensionRegistry = new DefaultExtensionRegistry();
            }

            return new FunctionIndexer(triggerBindingProvider, bindingProvider, DefaultJobActivator.Instance, executor, extensionRegistry);
        }
Beispiel #7
0
        /// <inheritdoc />
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            // Set the default exception handler for background exceptions
            // coming from MessageReceivers.
            Config.ExceptionHandler = (e) =>
            {
                LogExceptionReceivedEvent(e, context.Config.LoggerFactory);
            };

            // get the services we need to construct our binding providers
            INameResolver      nameResolver = context.Config.GetService <INameResolver>();
            IExtensionRegistry extensions   = context.Config.GetService <IExtensionRegistry>();

            // register our trigger binding provider
            ServiceBusTriggerAttributeBindingProvider triggerBindingProvider = new ServiceBusTriggerAttributeBindingProvider(nameResolver, _serviceBusConfig);

            extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);

            // register our binding provider
            ServiceBusAttributeBindingProvider bindingProvider = new ServiceBusAttributeBindingProvider(nameResolver, _serviceBusConfig);

            extensions.RegisterExtension <IBindingProvider>(bindingProvider);
        }
Beispiel #8
0
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            INameResolver     nameResolver = context.Config.GetService <INameResolver>();
            IConverterManager cm           = context.Config.GetService <IConverterManager>();

            cm.AddConverter <string, FakeQueueData>(x => new FakeQueueData {
                Message = x
            });

            if (this.SetConverters != null)
            {
                this.SetConverters(cm);
            }

            cm.AddConverter <FakeQueueData, string>(msg => msg.Message);
            cm.AddConverter <OtherFakeQueueData, FakeQueueData>(OtherFakeQueueData.ToEvent);

            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

            var bf = new BindingFactory(nameResolver, cm);

            // Binds [FakeQueue] --> IAsyncCollector<FakeQueueData>
            var ruleOutput = bf.BindToAsyncCollector <FakeQueueAttribute, FakeQueueData>(BuildFromAttr);

            // Binds [FakeQueue] --> FakeQueueClient
            var ruleClient = bf.BindToExactType <FakeQueueAttribute, FakeQueueClient>((attr) => this);

            extensions.RegisterBindingRules <FakeQueueAttribute>(ruleOutput, ruleClient);

            var triggerBindingProvider = new FakeQueueTriggerBindingProvider(this, cm);

            extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);
        }
Beispiel #9
0
        // Helper to send items to the listener, and return what they collected
        private object[] Run <TFunction>(params FakeQueueData[] items) where TFunction : FunctionsBase, new()
        {
            var activator = new FakeActivator();
            var func1     = new TFunction();

            activator.Add(func1);

            JobHostConfiguration config = new JobHostConfiguration()
            {
                TypeLocator  = new FakeTypeLocator(typeof(TFunction)),
                JobActivator = activator
            };

            FakeQueueClient    client     = new FakeQueueClient();
            IExtensionRegistry extensions = config.GetService <IExtensionRegistry>();

            extensions.RegisterExtension <IExtensionConfigProvider>(client);

            JobHost host = new JobHost(config);

            foreach (var item in items)
            {
                client.AddAsync(item).Wait();
            }

            host.Start();
            TestHelpers.WaitOne(func1._stopEvent);
            host.Stop();

            return(func1._collected.ToArray());
        }
        public void UseServiceBus_NoServiceBusConfiguration_PerformsExpectedRegistration()
        {
            JobHostConfiguration config = new JobHostConfiguration();
            string serviceBusConnection = "test service bus connection";

#pragma warning disable 0618
            config.ServiceBusConnectionString = serviceBusConnection;
#pragma warning restore 0618

            IExtensionRegistry         extensions      = config.GetService <IExtensionRegistry>();
            IExtensionConfigProvider[] configProviders = extensions.GetExtensions <IExtensionConfigProvider>().ToArray();
            Assert.Equal(0, configProviders.Length);

            config.UseServiceBus();

            // verify that the service bus config provider was registered
            configProviders = extensions.GetExtensions <IExtensionConfigProvider>().ToArray();
            Assert.Equal(1, configProviders.Length);

            ServiceBusExtensionConfig serviceBusExtensionConfig = (ServiceBusExtensionConfig)configProviders.Single();

            // verify that a default ServiceBusConfiguration was created, with the host (obsolete)
            // service bus connection string propagated
#pragma warning disable 0618
            Assert.Equal(serviceBusConnection, serviceBusExtensionConfig.Config.ConnectionString);
#pragma warning restore 0618
        }
        public static ITriggerBindingProvider Create(INameResolver nameResolver,
                                                     IStorageAccountProvider storageAccountProvider,
                                                     IExtensionTypeLocator extensionTypeLocator,
                                                     IHostIdProvider hostIdProvider,
                                                     IQueueConfiguration queueConfiguration,
                                                     IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
                                                     IContextSetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
                                                     IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
                                                     ISharedContextProvider sharedContextProvider,
                                                     IExtensionRegistry extensions,
                                                     TextWriter log)
        {
            List <ITriggerBindingProvider> innerProviders = new List <ITriggerBindingProvider>();

            innerProviders.Add(new QueueTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
                                                                        queueConfiguration, backgroundExceptionDispatcher, messageEnqueuedWatcherSetter,
                                                                        sharedContextProvider, log));
            innerProviders.Add(new BlobTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
                                                                       extensionTypeLocator, hostIdProvider, queueConfiguration, backgroundExceptionDispatcher,
                                                                       blobWrittenWatcherSetter, messageEnqueuedWatcherSetter, sharedContextProvider, log));

            // add any registered extension binding providers
            foreach (ITriggerBindingProvider provider in extensions.GetExtensions(typeof(ITriggerBindingProvider)))
            {
                innerProviders.Add(provider);
            }

            return(new CompositeTriggerBindingProvider(innerProviders));
        }
        public static FunctionIndexer Create(CloudStorageAccount account          = null, INameResolver nameResolver = null,
                                             IExtensionRegistry extensionRegistry = null, TraceWriter traceWriter    = null, ILoggerFactory loggerFactory = null)
        {
            IStorageAccountProvider storageAccountProvider = GetStorageAccountProvider(account);

            var config   = TestHelpers.NewConfig(storageAccountProvider, nameResolver, extensionRegistry);
            var services = config.CreateStaticServices();

            ITriggerBindingProvider triggerBindingProvider = services.GetService <ITriggerBindingProvider>();
            IBindingProvider        bindingProvider        = services.GetService <IBindingProvider>();
            IJobActivator           activator = services.GetService <IJobActivator>();

            extensionRegistry = services.GetService <IExtensionRegistry>();

            SingletonManager              singletonManager     = new SingletonManager();
            TraceWriter                   logger               = traceWriter ?? new TestTraceWriter(TraceLevel.Verbose);
            IWebJobsExceptionHandler      exceptionHandler     = new WebJobsExceptionHandler();
            IFunctionOutputLoggerProvider outputLoggerProvider = new NullFunctionOutputLoggerProvider();
            IFunctionOutputLogger         outputLogger         = outputLoggerProvider.GetAsync(CancellationToken.None).Result;

            IFunctionExecutor executor = new FunctionExecutor(new NullFunctionInstanceLogger(), outputLogger, exceptionHandler, logger);

            return(new FunctionIndexer(triggerBindingProvider, bindingProvider, DefaultJobActivator.Instance, executor,
                                       extensionRegistry, singletonManager, logger, loggerFactory));
        }
        public static IBindingProvider Create(INameResolver nameResolver,
            IStorageAccountProvider storageAccountProvider,
            IExtensionTypeLocator extensionTypeLocator,
            IContextGetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherGetter,
            IContextGetter<IBlobWrittenWatcher> blobWrittenWatcherGetter,
            IExtensionRegistry extensions)
        {
            List<IBindingProvider> innerProviders = new List<IBindingProvider>();
            innerProviders.Add(new QueueAttributeBindingProvider(nameResolver, storageAccountProvider, messageEnqueuedWatcherGetter));
            innerProviders.Add(new BlobAttributeBindingProvider(nameResolver, storageAccountProvider, extensionTypeLocator, blobWrittenWatcherGetter));
            innerProviders.Add(new TableAttributeBindingProvider(nameResolver, storageAccountProvider, extensions));

            // add any registered extension binding providers
            foreach (IBindingProvider provider in extensions.GetExtensions(typeof(IBindingProvider)))
            {
                innerProviders.Add(provider);
            }

            innerProviders.Add(new CloudStorageAccountBindingProvider(storageAccountProvider));
            innerProviders.Add(new CancellationTokenBindingProvider());

            // The console output binder below will handle all remaining TextWriter parameters. It must come after the
            // Blob binding provider; otherwise bindings like Do([Blob("a/b")] TextWriter blob) wouldn't work.
            innerProviders.Add(new ConsoleOutputBindingProvider());

            ContextAccessor<IBindingProvider> bindingProviderAccessor = new ContextAccessor<IBindingProvider>();
            innerProviders.Add(new RuntimeBindingProvider(bindingProviderAccessor));
            innerProviders.Add(new DataBindingProvider());

            IBindingProvider bindingProvider = new CompositeBindingProvider(innerProviders);
            bindingProviderAccessor.SetValue(bindingProvider);
            return bindingProvider;
        }
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            // Deferred list
            foreach (var action in _deferredWork)
            {
                action(context.Config);
            }
            _deferredWork.Clear();

            // get the services we need to construct our binding providers
            INameResolver      nameResolver = context.Config.NameResolver;
            IExtensionRegistry extensions   = context.Config.GetService <IExtensionRegistry>();

            IConverterManager cm = context.Config.GetService <IConverterManager>();

            cm.AddConverter <string, EventData>(ConvertString2EventData);
            cm.AddConverter <EventData, string>(ConvertEventData2String);
            cm.AddConverter <byte[], EventData>(ConvertBytes2EventData); // direct, handles non-string representations

            // register our trigger binding provider
            var triggerBindingProvider = new EventHubTriggerAttributeBindingProvider(nameResolver, cm, this);

            extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);

            // register our binding provider
            var bindingProvider = new EventHubAttributeBindingProvider(nameResolver, cm, this);

            extensions.RegisterExtension <IBindingProvider>(bindingProvider);
        }
            public void Initialize(ExtensionConfigContext context)
            {
                if (context == null)
                {
                    throw new ArgumentNullException("context");
                }

                if (string.IsNullOrEmpty(_sendGridConfig.ApiKey))
                {
                    throw new InvalidOperationException(
                              string.Format("The SendGrid ApiKey must be set either via a '{0}' app setting, via a '{0}' environment variable, or directly in code via SendGridConfiguration.ApiKey.",
                                            SendGridConfiguration.AzureWebJobsSendGridApiKeyName));
                }
                _sendGrid = new Web(_sendGridConfig.ApiKey);

                IConverterManager converterManager = context.Config.GetService <IConverterManager>();

                converterManager.AddConverter <JObject, SendGridMessage>(SendGridHelpers.CreateMessage);

                INameResolver    nameResolver   = context.Config.GetService <INameResolver>();
                BindingFactory   factory        = new BindingFactory(nameResolver, converterManager);
                IBindingProvider outputProvider = factory.BindToAsyncCollector <SendGridAttribute, SendGridMessage>((attr) =>
                {
                    return(new SendGridMessageAsyncCollector(_sendGridConfig, attr, _sendGrid));
                });

                IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

                extensions.RegisterBindingRules <SendGridAttribute>(outputProvider);
            }
        public FunctionIndexProvider(ITypeLocator typeLocator,
                                     ITriggerBindingProvider triggerBindingProvider,
                                     IBindingProvider bindingProvider,
                                     IJobActivator activator,
                                     IFunctionExecutor executor,
                                     IExtensionRegistry extensions,
                                     SingletonManager singletonManager,
                                     TraceWriter trace,
                                     ILoggerFactory loggerFactory)
        {
            if (typeLocator == null)
            {
                throw new ArgumentNullException("typeLocator");
            }

            if (triggerBindingProvider == null)
            {
                throw new ArgumentNullException("triggerBindingProvider");
            }

            if (bindingProvider == null)
            {
                throw new ArgumentNullException("bindingProvider");
            }

            if (activator == null)
            {
                throw new ArgumentNullException("activator");
            }

            if (executor == null)
            {
                throw new ArgumentNullException("executor");
            }

            if (extensions == null)
            {
                throw new ArgumentNullException("extensions");
            }

            if (singletonManager == null)
            {
                throw new ArgumentNullException("singletonManager");
            }

            if (trace == null)
            {
                throw new ArgumentNullException("trace");
            }

            _typeLocator            = typeLocator;
            _triggerBindingProvider = triggerBindingProvider;
            _bindingProvider        = bindingProvider;
            _activator        = activator;
            _executor         = executor;
            _extensions       = extensions;
            _singletonManager = singletonManager;
            _trace            = trace;
            _loggerFactory    = loggerFactory;
        }
        /// <inheritdoc />
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            INameResolver     nameResolver     = context.Config.GetService <INameResolver>();
            IConverterManager converterManager = context.Config.GetService <IConverterManager>();

            BindingFactory factory = new BindingFactory(nameResolver, converterManager);

            IBindingProvider outputProvider = factory.BindToGenericAsyncCollector <MobileTableAttribute>(BindForOutput, ThrowIfInvalidOutputItemType);

            IBindingProvider clientProvider = factory.BindToExactType <MobileTableAttribute, IMobileServiceClient>(BindForClient);

            IBindingProvider queryProvider = factory.BindToGenericItem <MobileTableAttribute>(BindForQueryAsync);

            queryProvider = factory.AddFilter <MobileTableAttribute>(IsQueryType, queryProvider);

            IBindingProvider jObjectTableProvider = factory.BindToExactType <MobileTableAttribute, IMobileServiceTable>(BindForTable);

            IBindingProvider tableProvider = factory.BindToGenericItem <MobileTableAttribute>(BindForTableAsync);

            tableProvider = factory.AddFilter <MobileTableAttribute>(IsTableType, tableProvider);

            IBindingProvider itemProvider = factory.BindToGenericValueProvider <MobileTableAttribute>(BindForItemAsync);

            itemProvider = factory.AddFilter <MobileTableAttribute>(IsItemType, itemProvider);

            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

            extensions.RegisterBindingRules <MobileTableAttribute>(ValidateMobileAppUri, nameResolver, outputProvider, clientProvider, jObjectTableProvider, queryProvider, tableProvider, itemProvider);
        }
Beispiel #18
0
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            var rule = context.AddBindingRule <FakeQueueAttribute>();

            context.AddConverter <string, FakeQueueData>(x => new FakeQueueData {
                Message = x
            });
            context.AddConverter <FakeQueueData, string>(msg => msg.Message);
            context.AddConverter <OtherFakeQueueData, FakeQueueData>(OtherFakeQueueData.ToEvent);

            rule.AddOpenConverter <OpenType.Poco, FakeQueueData>(ConvertPocoToFakeQueueMessage);

            INameResolver     nameResolver = context.Config.GetService <INameResolver>();
            IConverterManager cm           = context.Config.GetService <IConverterManager>();

            if (this.SetConverters != null)
            {
                this.SetConverters(context);
            }

            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

            // Binds [FakeQueue] --> IAsyncCollector<FakeQueueData>
            rule.BindToCollector <FakeQueueData>(BuildFromAttr);

            // Binds [FakeQueue] --> FakeQueueClient
            rule.BindToInput <FakeQueueClient>(this);

            var triggerBindingProvider = new FakeQueueTriggerBindingProvider(this, cm);

            extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);
        }
        public TableAttributeBindingProvider(INameResolver nameResolver, IStorageAccountProvider accountProvider, IExtensionRegistry extensions)
        {
            if (accountProvider == null)
            {
                throw new ArgumentNullException("accountProvider");
            }

            if (extensions == null)
            {
                throw new ArgumentNullException("extensions");
            }

            _nameResolver = nameResolver;
            _accountProvider = accountProvider;

            _tableProvider = new CompositeArgumentBindingProvider(
                new StorageTableArgumentBindingProvider(),
                new CloudTableArgumentBindingProvider(),
                new QueryableArgumentBindingProvider(),
                new CollectorArgumentBindingProvider(),
                new AsyncCollectorArgumentBindingProvider(),
                new TableArgumentBindingExtensionProvider(extensions));

            _entityProvider =
                new CompositeEntityArgumentBindingProvider(
                new TableEntityArgumentBindingProvider(),
                new PocoEntityArgumentBindingProvider()); // Supports all types; must come after other providers
        }
 private static IServiceProvider CreateServiceProviderForManualCompletion <TResult>(
     IStorageAccount storageAccount, Type programType, TaskCompletionSource <TResult> taskSource,
     IEnumerable <string> ignoreFailureFunctions, IExtensionRegistry extensions = null, params Type[] cloudBlobStreamBinderTypes)
 {
     return(CreateServiceProviderForManualCompletion <TResult>(storageAccount, programType,
                                                               DefaultJobActivator.Instance, taskSource, ignoreFailureFunctions, extensions, cloudBlobStreamBinderTypes));
 }
Beispiel #21
0
        public static ITriggerBindingProvider Create(INameResolver nameResolver,
                                                     IStorageAccountProvider storageAccountProvider,
                                                     IExtensionTypeLocator extensionTypeLocator,
                                                     IHostIdProvider hostIdProvider,
                                                     IQueueConfiguration queueConfiguration,
                                                     JobHostBlobsConfiguration blobsConfiguration,
                                                     IWebJobsExceptionHandler exceptionHandler,
                                                     IContextSetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
                                                     IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
                                                     ISharedContextProvider sharedContextProvider,
                                                     IExtensionRegistry extensions,
                                                     SingletonManager singletonManager,
                                                     TraceWriter trace,
                                                     ILoggerFactory loggerFactory)
        {
            List <ITriggerBindingProvider> innerProviders = new List <ITriggerBindingProvider>();

            innerProviders.Add(new QueueTriggerAttributeBindingProvider(nameResolver, storageAccountProvider,
                                                                        queueConfiguration, exceptionHandler, messageEnqueuedWatcherSetter,
                                                                        sharedContextProvider, trace, loggerFactory));
            innerProviders.Add(new BlobTriggerAttributeBindingProvider(nameResolver, storageAccountProvider, extensionTypeLocator,
                                                                       hostIdProvider, queueConfiguration, blobsConfiguration, exceptionHandler, blobWrittenWatcherSetter,
                                                                       messageEnqueuedWatcherSetter, sharedContextProvider, singletonManager, trace, loggerFactory));

            // add any registered extension binding providers
            foreach (ITriggerBindingProvider provider in extensions.GetExtensions(typeof(ITriggerBindingProvider)))
            {
                innerProviders.Add(provider);
            }

            return(new CompositeTriggerBindingProvider(innerProviders));
        }
        public FunctionIndexProvider(ITypeLocator typeLocator,
                                     ITriggerBindingProvider triggerBindingProvider,
                                     CompositeBindingProvider bindingProviderFactory,
                                     IJobActivator activator,
                                     IFunctionExecutor executor,
                                     IExtensionRegistry extensions,
                                     SingletonManager singletonManager,
                                     ILoggerFactory loggerFactory,
                                     SharedQueueHandler sharedQueue,
                                     IOptions <JobHostFunctionTimeoutOptions> timeoutOptions,
                                     IOptions <JobHostOptions> hostOptions)
        {
            _typeLocator            = typeLocator ?? throw new ArgumentNullException(nameof(typeLocator));
            _triggerBindingProvider = triggerBindingProvider ?? throw new ArgumentNullException(nameof(triggerBindingProvider));
            _bindingProviderFactory = bindingProviderFactory ?? throw new ArgumentNullException(nameof(bindingProviderFactory));
            _activator        = activator ?? throw new ArgumentNullException(nameof(activator));
            _executor         = executor ?? throw new ArgumentNullException(nameof(executor));
            _extensions       = extensions ?? throw new ArgumentNullException(nameof(extensions));
            _singletonManager = singletonManager ?? throw new ArgumentNullException(nameof(singletonManager));
            _sharedQueue      = sharedQueue ?? throw new ArgumentNullException(nameof(sharedQueue));

            _loggerFactory           = loggerFactory;
            _defaultTimeout          = timeoutOptions.Value.ToAttribute();
            _allowPartialHostStartup = hostOptions.Value.AllowPartialHostStartup;
        }
Beispiel #23
0
        public async Task Initialize_PerformsExpectedRegistrations()
        {
            JobHostConfiguration config = new JobHostConfiguration();

            config.AddService <INameResolver>(new RandomNameResolver());

            TestLoggerProvider loggerProvider = new TestLoggerProvider();
            ILoggerFactory     loggerFactory  = new LoggerFactory();

            loggerFactory.AddProvider(loggerProvider);
            config.LoggerFactory = loggerFactory;

            ServiceBusConfiguration   serviceBusConfig          = new ServiceBusConfiguration();
            ServiceBusExtensionConfig serviceBusExtensionConfig = new ServiceBusExtensionConfig(serviceBusConfig);

            IExtensionRegistry extensions = config.GetService <IExtensionRegistry>();

            ITriggerBindingProvider[] triggerBindingProviders = extensions.GetExtensions <ITriggerBindingProvider>().ToArray();
            Assert.Empty(triggerBindingProviders);
            IBindingProvider[] bindingProviders = extensions.GetExtensions <IBindingProvider>().ToArray();
            Assert.Empty(bindingProviders);

            ExtensionConfigContext context = new ExtensionConfigContext
            {
                Config = config,
            };

            serviceBusExtensionConfig.Initialize(context);

            // ensure the ServiceBusTriggerAttributeBindingProvider was registered
            triggerBindingProviders = extensions.GetExtensions <ITriggerBindingProvider>().ToArray();
            Assert.Single(triggerBindingProviders);
            ServiceBusTriggerAttributeBindingProvider triggerBindingProvider = (ServiceBusTriggerAttributeBindingProvider)triggerBindingProviders[0];

            Assert.NotNull(triggerBindingProvider);

            // ensure the ServiceBusAttributeBindingProvider was registered
            bindingProviders = extensions.GetExtensions <IBindingProvider>().ToArray();
            Assert.Single(bindingProviders);
            ServiceBusAttributeBindingProvider bindingProvider = (ServiceBusAttributeBindingProvider)bindingProviders[0];

            Assert.NotNull(bindingProvider);

            // ensure the default MessageOptions exception handler is wired up
            var messageOptions = serviceBusConfig.MessageOptions;
            var ex             = new ServiceBusException(false);
            var args           = new ExceptionReceivedEventArgs(ex, "TestAction", "TestEndpoint", "TestEntityPath", "TestClientId");

            Assert.NotNull(serviceBusConfig.ExceptionHandler);

            // invoke the handler and make sure it logs
            await serviceBusConfig.MessageOptions.ExceptionReceivedHandler(args);

            string expectedMessage = "MessageReceiver error (Action=TestAction, ClientId=TestClientId, EntityPath=TestEntityPath, Endpoint=TestEndpoint)";
            var    logMessage      = loggerProvider.GetAllLogMessages().Single();

            Assert.Equal(LogLevel.Error, logMessage.Level);
            Assert.Equal(expectedMessage, logMessage.FormattedMessage);
            Assert.Same(ex, logMessage.Exception);
        }
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            _defaultStorageString = context.Config.StorageConnectionString;

            // get the services we need to construct our binding providers
            INameResolver      nameResolver = context.Config.NameResolver;
            IExtensionRegistry extensions   = context.Config.GetService <IExtensionRegistry>();

            IConverterManager cm = context.Config.GetService <IConverterManager>();

            cm.AddConverter <string, EventData>(ConvertString2EventData);
            cm.AddConverter <EventData, string>(ConvertEventData2String);
            cm.AddConverter <byte[], EventData>(ConvertBytes2EventData); // direct, handles non-string representations
            cm.AddConverter <EventData, byte[]>(ConvertEventData2Bytes); // direct, handles non-string representations

            var bf = new BindingFactory(nameResolver, cm);

            // register our trigger binding provider
            var triggerBindingProvider = new EventHubTriggerAttributeBindingProvider(nameResolver, cm, this);

            extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);

            // register our binding provider
            var ruleOutput = bf.BindToAsyncCollector <EventHubAttribute, EventData>(BuildFromAttribute);

            extensions.RegisterBindingRules <EventHubAttribute>(ruleOutput);
        }
Beispiel #25
0
 public JobHostMetadataProvider(IFunctionIndexProvider functionIndexProvider, IExtensionRegistry extensionRegistry, IBindingProvider bindingProvider, IConverterManager converter)
 {
     _functionIndexProvider = functionIndexProvider;
     _extensionRegistry = extensionRegistry;
     _bindingProvider = bindingProvider;
     _converter = converter;
 }
Beispiel #26
0
 public CompositeBindingProviderFactory(
     IEnumerable <IBindingProvider> existingProviders,
     IExtensionRegistry extensions)
 {
     _existingProviders = existingProviders.ToArray();
     _extensions        = extensions;
 }
        /// <inheritdoc />
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            INameResolver     nameResolver     = context.Config.GetService <INameResolver>();
            IConverterManager converterManager = context.Config.GetService <IConverterManager>();

            // Use this if there is no other connection string set.
            _defaultConnectionString = nameResolver.Resolve(AzureWebJobsDocumentDBConnectionStringName);

            BindingFactory factory = new BindingFactory(nameResolver, converterManager);

            IBindingProvider outputProvider = factory.BindToGenericAsyncCollector <DocumentDBAttribute>((attr, t) => BindForOutput(attr, t, context.Trace));

            IBindingProvider clientProvider = factory.BindToExactType <DocumentDBAttribute, DocumentClient>(BindForClient);

            IBindingProvider itemProvider = factory.BindToGenericValueProvider <DocumentDBAttribute>((attr, t) => BindForItemAsync(attr, t, context.Trace));

            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

            extensions.RegisterBindingRules <DocumentDBAttribute>(ValidateConnection, nameResolver, outputProvider, clientProvider, itemProvider);
        }
 internal FluentBindingRule(IConfiguration configuration, INameResolver nameResolver, IConverterManager converterManager, IExtensionRegistry extensionRegistry)
 {
     _configuration     = configuration;
     _nameResolver      = nameResolver;
     _converterManager  = converterManager;
     _extensionRegistry = extensionRegistry;
 }
Beispiel #29
0
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            INameResolver nameResolver = context.Config.GetService <INameResolver>();

            _defaultAccountSid = nameResolver.Resolve(AzureWebJobsTwilioAccountSidKeyName);
            _defaultAuthToken  = nameResolver.Resolve(AzureWebJobsTwilioAccountAuthTokenName);

            IConverterManager converterManager = context.Config.GetService <IConverterManager>();

            converterManager.AddConverter <JObject, SMSMessage>(CreateSmsMessage);

            BindingFactory   factory        = new BindingFactory(nameResolver, converterManager);
            IBindingProvider outputProvider = factory.BindToAsyncCollector <TwilioSmsAttribute, SMSMessage>((attr) =>
            {
                return(new TwilioSmsMessageAsyncCollector(CreateContext(attr)));
            });

            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();

            extensions.RegisterBindingRules <TwilioSmsAttribute>(ValidateBinding, nameResolver, outputProvider);
        }
 public ExtensionConfigContext(INameResolver nameResolver, IConverterManager converterManager, IWebHookProvider webHookProvider, IExtensionRegistry extensionRegistry)
 {
     _converterManager  = converterManager;
     _webHookProvider   = webHookProvider;
     _extensionRegistry = extensionRegistry;
     _nameResolver      = nameResolver;
 }
        private JobHost CreateTestJobHost(int hostId)
        {
            TestJobActivator activator = new TestJobActivator(hostId);

            JobHostConfiguration config = new JobHostConfiguration
            {
                HostId       = TestHostId,
                NameResolver = _resolver,
                TypeLocator  = new FakeTypeLocator(typeof(TestJobs)),
                JobActivator = activator
            };

            config.AddService <IWebJobsExceptionHandler>(new TestExceptionHandler());
            config.Queues.MaxPollingInterval                = TimeSpan.FromSeconds(2);
            config.Singleton.LockAcquisitionTimeout         = TimeSpan.FromSeconds(10);
            config.Singleton.LockAcquisitionPollingInterval = TimeSpan.FromMilliseconds(500);

            IExtensionRegistry registry = config.GetService <IExtensionRegistry>();

            registry.RegisterExtension <ITriggerBindingProvider>(new TestTriggerAttributeBindingProvider());

            JobHost host = new JobHost(config);

            return(host);
        }
        public FunctionIndexProvider(ITypeLocator typeLocator,
            ITriggerBindingProvider triggerBindingProvider,
            IBindingProvider bindingProvider,
            IJobActivator activator,
            IFunctionExecutor executor,
            IExtensionRegistry extensions,
            SingletonManager singletonManager,
            TraceWriter trace)
        {
            if (typeLocator == null)
            {
                throw new ArgumentNullException("typeLocator");
            }

            if (triggerBindingProvider == null)
            {
                throw new ArgumentNullException("triggerBindingProvider");
            }

            if (bindingProvider == null)
            {
                throw new ArgumentNullException("bindingProvider");
            }

            if (activator == null)
            {
                throw new ArgumentNullException("activator");
            }

            if (executor == null)
            {
                throw new ArgumentNullException("executor");
            }

            if (extensions == null)
            {
                throw new ArgumentNullException("extensions");
            }

            if (singletonManager == null)
            {
                throw new ArgumentNullException("singletonManager");
            }

            if (trace == null)
            {
                throw new ArgumentNullException("trace");
            }

            _typeLocator = typeLocator;
            _triggerBindingProvider = triggerBindingProvider;
            _bindingProvider = bindingProvider;
            _activator = activator;
            _executor = executor;
            _extensions = extensions;
            _singletonManager = singletonManager;
            _trace = trace;
        }
        /// <summary>
        /// Returns the collection of extension instances registered for the specified type.
        /// </summary>
        /// <typeparam name="TExtension">The service type to get extensions for.</typeparam>
        /// <param name="registry">The registry instance.</param>
        /// <returns>The collection of extension instances.</returns>
        public static IEnumerable <TExtension> GetExtensions <TExtension>(this IExtensionRegistry registry)
        {
            if (registry == null)
            {
                throw new ArgumentNullException("registry");
            }

            return(registry.GetExtensions(typeof(TExtension)).Cast <TExtension>());
        }
        /// <summary>
        /// Registers the specified instance.
        /// </summary>
        /// <typeparam name="TExtension">The service type to register the instance for.</typeparam>
        /// <param name="registry">The registry instance.</param>
        /// <param name="extension">The instance to register.</param>
        public static void RegisterExtension <TExtension>(this IExtensionRegistry registry, TExtension extension)
        {
            if (registry == null)
            {
                throw new ArgumentNullException("registry");
            }

            registry.RegisterExtension(typeof(TExtension), extension);
        }
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();
            var bf = context.Config.BindingFactory;

            var rule = bf.BindToGenericValueProvider <FakeItemAttribute>(BuildFromAttribute);

            extensions.RegisterBindingRules <FakeItemAttribute>(rule);
        }
        public DefaultTypeLocator(TextWriter log, IExtensionRegistry extensions)
        {
            if (log == null)
            {
                throw new ArgumentNullException("log");
            }
            if (extensions == null)
            {
                throw new ArgumentNullException("extensions");
            }

            _log = log;
            _extensions = extensions;
        }
 public SharpMessagingClient(string identity, IExtensionRegistry extensionRegistry)
 {
     _extensionService = new ExtensionService(extensionRegistry, DeliverMessage);
     _state = ClientState.ClientToServerHandshake1;
     _connection = new Connection.Connection(identity, _extensionService, false, _bufferManager)
     {
         ExtensionFrameReceived = OnExtensionFrame,
         MessageFrameReceived = OnMessageFrame,
         WriteCompleted = OnWriteCompleted,
         //ReceiveBufferSize = 65535
     };
     _connection.HandshakeReceived += OnServerHandshakeFrame;
     _connection.Disconnected += OnDisconnected;
     _connection.Fault += OnConnectionFault;
 }
        public ServerClient(string identity, IExtensionRegistry extensionRegistry, BufferManager bufferManager)
        {
            ServerName = identity;
            _bufferManager = bufferManager;
            _extensionService = new ExtensionService(extensionRegistry, DeliverMessage);
            _connection = new Connection.Connection(ServerName, _extensionService, true, _bufferManager)
            {
                ExtensionFrameReceived = OnExtensionFrame,
                MessageFrameReceived = OnMessageFrame,
                WriteCompleted = OnWriteCompleted,

            };
            _connection.HandshakeReceived += OnHandshakeFrame;
            _connection.Disconnected += HandleRemoteDisconnect;
            _state = ServerState.WaitingOnInitialHandshake;
            ServerName = "FastSocket v" + Major + "." + Minor;
        }
        public static FunctionIndexer Create(CloudStorageAccount account = null, INameResolver nameResolver = null, IExtensionRegistry extensionRegistry = null)
        {
            Mock<IServiceProvider> services = new Mock<IServiceProvider>(MockBehavior.Strict);
            StorageClientFactory clientFactory = new StorageClientFactory();
            services.Setup(p => p.GetService(typeof(StorageClientFactory))).Returns(clientFactory);
            IStorageAccount storageAccount = account != null ? new StorageAccount(account, services.Object) : null;
            IStorageAccountProvider storageAccountProvider = new SimpleStorageAccountProvider(services.Object)
            {
                StorageAccount = account
            };
            IExtensionTypeLocator extensionTypeLocator = new NullExtensionTypeLocator();
            ContextAccessor<IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor =
                new ContextAccessor<IMessageEnqueuedWatcher>();
            ContextAccessor<IBlobWrittenWatcher> blobWrittenWatcherAccessor =
                new ContextAccessor<IBlobWrittenWatcher>();
            ISharedContextProvider sharedContextProvider = new SharedContextProvider();
            TestTraceWriter logger = new TestTraceWriter(TraceLevel.Verbose);
            SingletonManager singletonManager = new SingletonManager();
            ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
                storageAccountProvider, extensionTypeLocator,
                new FixedHostIdProvider("test"), new SimpleQueueConfiguration(maxDequeueCount: 5),
                BackgroundExceptionDispatcher.Instance, messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor,
                sharedContextProvider, new DefaultExtensionRegistry(), singletonManager, logger);
            IBindingProvider bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider,
                extensionTypeLocator, messageEnqueuedWatcherAccessor,
                blobWrittenWatcherAccessor, new DefaultExtensionRegistry());

            TraceWriter trace = new TestTraceWriter(TraceLevel.Verbose);
            IFunctionOutputLoggerProvider outputLoggerProvider = new NullFunctionOutputLoggerProvider();
            IFunctionOutputLogger outputLogger = outputLoggerProvider.GetAsync(CancellationToken.None).Result;
            IFunctionExecutor executor = new FunctionExecutor(new NullFunctionInstanceLogger(), outputLogger, BackgroundExceptionDispatcher.Instance, trace, null);

            if (extensionRegistry == null)
            {
                extensionRegistry = new DefaultExtensionRegistry();
            }

            return new FunctionIndexer(triggerBindingProvider, bindingProvider, DefaultJobActivator.Instance, executor, extensionRegistry, new SingletonManager(), trace);
        }
 public SharpMessagingServer(IExtensionRegistry extensionProvider)
 {
     _extensionProvider = extensionProvider;
     //ServerName = "FastSocket v" + Major + "." + Minor;
     ServerName = "SERVER";
 }
 public TableArgumentBindingExtensionProvider(IExtensionRegistry extensions)
 {
     _bindingExtensionsProviders = extensions.GetExtensions<IArgumentBindingProvider<ITableArgumentBinding>>();
 }
 public ExtensionService(IExtensionRegistry registry, Action<MessageFrame> sendDirectly)
 {
     _registry = registry;
     _sendDirectly = sendDirectly;
 }