コード例 #1
0
        public void Initialize(ExtensionConfigContext context)
        {
            using (var scope = _provider.CreateScope())
            {
                var services   = scope.ServiceProvider;
                var dependency = services.GetService <DependencyGraphBravo>();

                Log.LogTrace("Doing 1st work with scoped dependency bravo: {0} a: {1} b: {2}", dependency.GetHashCode(), dependency.A.GetHashCode(), dependency.B.GetHashCode());
            }

            using (var scope = _provider.CreateScope())
            {
                var services   = scope.ServiceProvider;
                var dependency = services.GetService <DependencyGraphBravo>();

                Log.LogTrace("Doing 2nd work with scoped dependency bravo: {0} a: {1} b: {2}", dependency.GetHashCode(), dependency.A.GetHashCode(), dependency.B.GetHashCode());
            }
        }
コード例 #2
0
        public void Initialize(ExtensionConfigContext context)
        {
            EnsureArg.IsNotNull(context);

            foreach (var startable in _provider.GetServices <IStartable>())
            {
                startable.Start();
            }

            var initTasks = _provider.GetServices <IRequireInitializationOnFirstRequest>()
                            .Select(x => x.EnsureInitialized())
                            .ToArray();

            Task.WhenAll(initTasks)
            .ConfigureAwait(false)
            .GetAwaiter()
            .OnCompleted(() => Trace.WriteLine("Functions initialization complete."));
        }
コード例 #3
0
        /// <summary>
        /// This callback is invoked by the WebJobs framework before the host starts execution.
        /// It should add the binding rules and converters for our new <see cref="SampleAttribute"/>
        /// </summary>
        /// <param name="context"></param>
        public void Initialize(ExtensionConfigContext context)
        {
            // Register converters. These help convert between the user's parameter type
            //  and the type specified by the binding rules.

            // This allows a user to bind to IAsyncCollector<string>, and the sdk
            // will convert that to IAsyncCollector<SampleItem>
            context.AddConverter <string, SampleItem>(ConvertToItem);

            // This is useful on input.
            context.AddConverter <SampleItem, string>(ConvertToString);

            // Create 2 binding rules for the Sample attribute.
            var rule = context.AddBindingRule <SampleAttribute>();

            rule.BindToInput <SampleItem>(BuildItemFromAttr);
            rule.BindToCollector <SampleItem>(BuildCollector);
        }
コード例 #4
0
        /// <summary>
        /// Initializes the SQL binding rules
        /// </summary>
        /// <param name="context"> The config context </param>
        /// <exception cref="ArgumentNullException">
        /// Thrown if context is null
        /// </exception>
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }
            var inputOutputRule = context.AddBindingRule <SqlAttribute>();
            var converter       = new SqlConverter(_configuration);

            inputOutputRule.BindToInput <SqlCommand>(converter);
            inputOutputRule.BindToInput <string>(typeof(SqlGenericsConverter <string>), _configuration);
            inputOutputRule.BindToCollector <OpenType>(typeof(SqlAsyncCollectorBuilder <>), _configuration, _loggerFactory);
            inputOutputRule.BindToInput <OpenType>(typeof(SqlGenericsConverter <>), _configuration);

            var triggerRule = context.AddBindingRule <SqlTriggerAttribute>();

            triggerRule.BindToTrigger(new SqlTriggerAttributeBindingProvider(_configuration, _loggerFactory));
        }
        /// <summary>
        /// Internal initialization call from the WebJobs host.
        /// </summary>
        /// <param name="context">Extension context provided by WebJobs.</param>
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            ConfigureLoaderHooks();

            context.ApplyConfig(this, "DurableTask");

            // Register the trigger bindings
            JobHostConfiguration hostConfig = context.Config;
            ILogger logger = context.Config.LoggerFactory.CreateLogger(LoggerCategoryName);

            this.traceHelper    = new EndToEndTraceHelper(hostConfig, logger);
            this.httpApiHandler = new HttpApiHandler(this, logger);

            this.lifeCycleNotificationHelper = new LifeCycleNotificationHelper(this, context);

            // Register the non-trigger bindings, which have a different model.
            var bindings = new BindingHelper(this, this.traceHelper);

            // For 202 support
            if (this.NotificationUrl == null)
            {
#pragma warning disable CS0618 // Type or member is obsolete
                this.NotificationUrl = context.GetWebhookHandler();
#pragma warning restore CS0618 // Type or member is obsolete
            }

            // Note that the order of the rules is important
            var rule = context.AddBindingRule <OrchestrationClientAttribute>()
                       .AddConverter <JObject, StartOrchestrationArgs>(bindings.JObjectToStartOrchestrationArgs);

            rule.BindToCollector <StartOrchestrationArgs>(bindings.CreateAsyncCollector);
            rule.BindToInput <DurableOrchestrationClient>(this.GetClient);

            context.AddBindingRule <OrchestrationTriggerAttribute>()
            .BindToTrigger(new OrchestrationTriggerAttributeBindingProvider(this, context, this.traceHelper));

            context.AddBindingRule <ActivityTriggerAttribute>()
            .BindToTrigger(new ActivityTriggerAttributeBindingProvider(this, context, this.traceHelper));

            AzureStorageOrchestrationServiceSettings settings = this.GetOrchestrationServiceSettings();
            this.orchestrationService = new AzureStorageOrchestrationService(settings);
            this.taskHubWorker        = new TaskHubWorker(this.orchestrationService, this, this);
            this.taskHubWorker.AddOrchestrationDispatcherMiddleware(this.OrchestrationMiddleware);
        }
        private void InitilizeBlobBindings(ExtensionConfigContext context)
        {
#pragma warning disable CS0618 // Type or member is obsolete
            Uri url = context.GetWebhookHandler();
#pragma warning restore CS0618 // Type or member is obsolete
            _logger.LogInformation($"registered http endpoint = {url?.GetLeftPart(UriPartial.Path)}");

            var rule = context.AddBindingRule <BlobAttribute>();

            // Bind to multiple blobs (either via a container; an IEnumerable<T>)
            rule.BindToInput <BlobContainerClient>(this);

            rule.BindToInput <MultiBlobContext>(this); // Intermediate private context to capture state
            rule.AddOpenConverter <MultiBlobContext, IEnumerable <BlobCollectionType> >(typeof(BlobCollectionConverter <>), this);

            // BindToStream will also handle the custom Stream-->T converters.
            rule.BindToStream(CreateStreamAsync, FileAccess.ReadWrite); // Precedence, must beat CloudBlobStream

            // Normal blob
            // These are not converters because Blob/Page/Append affects how we *create* the blob.
            rule.BindToInput <BlockBlobClient>((attr, cts) => CreateBlobReference <BlockBlobClient>(attr, cts));
            rule.BindToInput <PageBlobClient>((attr, cts) => CreateBlobReference <PageBlobClient>(attr, cts));
            rule.BindToInput <AppendBlobClient>((attr, cts) => CreateBlobReference <AppendBlobClient>(attr, cts));
            rule.BindToInput <BlobClient>((attr, cts) => CreateBlobReference <BlobClient>(attr, cts));
            rule.BindToInput <BlobBaseClient>((attr, cts) => CreateBlobReference <BlobBaseClient>(attr, cts));

            // If caching is enabled, create a binding for that
            if (_functionDataCache != null && _functionDataCache.IsEnabled)
            {
                rule.When("Access", FileAccess.Read).
                BindToInput <ICacheAwareReadObject>((attr, ctx) => CreateCacheAwareReadObjectAsync(attr, ctx));

                rule.When("Access", FileAccess.Write).
                BindToInput <ICacheAwareWriteObject>((attr, ctx) => CreateCacheAwareWriteObjectAsync(attr, ctx));
            }

            // CloudBlobStream's derived functionality is only relevant to writing. check derived functionality
            rule.When("Access", FileAccess.Write).
            BindToInput <Stream>(ConvertToCloudBlobStreamAsync);

            RegisterCommonConverters(rule);
            rule.AddConverter(new StorageBlobConverter <BlobClient>());
        }
コード例 #7
0
        private void InitializeForFunctionsV1(ExtensionConfigContext context)
        {
#if FUNCTIONS_V1
            context.ApplyConfig(this.Options, "DurableTask");
            this.nameResolver = context.Config.NameResolver;
            this.ResolveAppSettingOptions();
            ILogger logger = context.Config.LoggerFactory.CreateLogger(LoggerCategoryName);
            this.TraceHelper = new EndToEndTraceHelper(logger, this.Options.Tracing.TraceReplayEvents);
            this.connectionStringResolver    = new WebJobsConnectionStringProvider();
            this.durabilityProviderFactory   = new AzureStorageDurabilityProviderFactory(new OptionsWrapper <DurableTaskOptions>(this.Options), this.connectionStringResolver);
            this.defaultDurabilityProvider   = this.durabilityProviderFactory.GetDurabilityProvider();
            this.LifeCycleNotificationHelper = this.CreateLifeCycleNotificationHelper();
            var messageSerializerSettingsFactory = new MessageSerializerSettingsFactory();
            var errorSerializerSettingsFactory   = new ErrorSerializerSettingsFactory();
            this.MessageDataConverter = new MessagePayloadDataConverter(messageSerializerSettingsFactory.CreateJsonSerializerSettings(), true);
            this.ErrorDataConverter   = new MessagePayloadDataConverter(errorSerializerSettingsFactory.CreateJsonSerializerSettings(), true);
            this.HttpApiHandler       = new HttpApiHandler(this, logger);
#endif
        }
コード例 #8
0
        public void Initialize(ExtensionConfigContext context)
        {
            var bindingRule = context.AddBindingRule <PerperAttribute>();

            bindingRule.BindToValueProvider <OpenType>((a, t) =>
                                                       Task.FromResult <IValueBinder>(new PerperValueBinder(_fabricContext, a, t)));

            var streamTriggerBindingRule = context.AddBindingRule <PerperStreamTriggerAttribute>();

            streamTriggerBindingRule.BindToTrigger(new PerperTriggerBindingProvider <PerperStreamTriggerAttribute>(_fabricContext, _logger));

            var workerTriggerBindingRule = context.AddBindingRule <PerperWorkerTriggerAttribute>();

            workerTriggerBindingRule.BindToTrigger(new PerperTriggerBindingProvider <PerperWorkerTriggerAttribute>(_fabricContext, _logger));

            var moduleTriggerBindingRule = context.AddBindingRule <PerperModuleTriggerAttribute>();

            moduleTriggerBindingRule.BindToTrigger(new PerperTriggerBindingProvider <PerperModuleTriggerAttribute>(_fabricContext, _logger));
        }
コード例 #9
0
        public static void Create(ExtensionConfigContext context)
        {
            var loggerFactory = context.Config.LoggerFactory;

            var traceBinderType    = typeof(JobHostConfiguration).Assembly.GetType("Microsoft.Azure.WebJobs.Host.Bindings.TraceWriterBindingProvider");
            IBindingProvider inner = (IBindingProvider)Activator.CreateInstance(traceBinderType, loggerFactory);

            Func <string, FunctionDescriptor> funcLookup = context.Config.GetService <Func <string, FunctionDescriptor> >();

            // Func<string, FunctionDescriptor> funcLookup = null;

            if (funcLookup != null && inner != null)
            {
                IBindingProvider wrapper = new Wrapper(inner, funcLookup);

                var registry = context.Config.GetService <IExtensionRegistry>();
                registry.RegisterExtension(typeof(IBindingProvider), wrapper);
            }
        }
コード例 #10
0
        private static void InitializeServiceLocator(ExtensionConfigContext context)
        {
            var bootstrapperCollector = new BootstrapperCollector();
            var bootstrappers         = bootstrapperCollector.GetBootstrappers();

            if (bootstrappers.Count == 0)
            {
                throw new BootstrapperNotFoundException("No bootstrapper instances had been recognized.");
            }

            var modules = new List <Module>();

            foreach (var bootstrapper in bootstrappers)
            {
                var instance = (IBootstrapper)Activator.CreateInstance(bootstrapper);
                modules.AddRange(instance.CreateModules());
            }
            InjectConfiguration.Initialize(modules.ToArray());
        }
コード例 #11
0
        /// <inheritdoc />
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            _trace = context.Trace;

            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(AzureWebJobsCosmosDBConnectionStringName);

            BindingFactory factory = new BindingFactory(nameResolver, converterManager);

            IBindingProvider outputProvider = factory.BindToCollector <CosmosDBAttribute, OpenType>(typeof(CosmosDBCollectorBuilder <>), this);

            IBindingProvider outputProviderJObject = factory.BindToCollector <CosmosDBAttribute, JObject>(typeof(CosmosDBCollectorBuilder <>), this);

            IBindingProvider clientProvider = factory.BindToInput <CosmosDBAttribute, DocumentClient>(new CosmosDBClientBuilder(this));

            IBindingProvider jArrayProvider = factory.BindToInput <CosmosDBAttribute, JArray>(typeof(CosmosDBJArrayBuilder), this);

            IBindingProvider enumerableProvider = factory.BindToInput <CosmosDBAttribute, IEnumerable <OpenType> >(typeof(CosmosDBEnumerableBuilder <>), this);

            enumerableProvider = factory.AddValidator <CosmosDBAttribute>(ValidateInputBinding, enumerableProvider);

            IBindingProvider inputProvider = factory.BindToGenericValueProvider <CosmosDBAttribute>((attr, t) => BindForItemAsync(attr, t));

            inputProvider = factory.AddValidator <CosmosDBAttribute>(ValidateInputBinding, inputProvider);

            context.AddBindingRule <CosmosDBAttribute>()
            .AddConverter <JObject, JObject>(s => s);

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

            extensions.RegisterBindingRules <CosmosDBAttribute>(ValidateConnection, nameResolver, outputProvider, outputProviderJObject, clientProvider, jArrayProvider, enumerableProvider, inputProvider);

            context.Config.RegisterBindingExtensions(new CosmosDBTriggerAttributeBindingProvider(nameResolver, this, LeaseOptions));
        }
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            var secretRule = context.AddBindingRule <KeyVaultSecretAttribute>();

            secretRule.BindToInput(new KeyVaultSecretManager());

            var certificateRule = context.AddBindingRule <KeyVaultCertificateAttribute>();

            certificateRule.BindToInput(new KeyVaultCertificateManager());

            var keyRule = context.AddBindingRule <KeyVaultKeyAttribute>();

            keyRule.BindToInput(new KeyVaultKeyManager());
        }
コード例 #13
0
        void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
        {
            IConverterManager cm = context.Config.GetOrCreateConverterManager();

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

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

            var bindingProvider = new FakeQueueBindingProvider(this, cm);

            extensions.RegisterExtension <IBindingProvider>(bindingProvider);

            var triggerBindingProvider = new FakeQueueTriggerBindingProvider(this, cm);

            extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);
        }
コード例 #14
0
 public static ExtensionConfigContext AddAllConverters(this ExtensionConfigContext context, Microsoft.Extensions.Logging.ILogger logger)
 {
     return(context
            .AddJsonConverter(logger)
            .AddByteArrayConverter(logger)
            .AddEventDataConverter(logger)
            .AddJObjectConverter(logger)
            .AddDynamicConverter(logger)
            .AddExpandoObjectConverter(logger)
            .AddResolvedEventListConverter(logger)
            .AddResolvedEventConverter(logger)
            .AddResolvedEventToStringConverter(logger)
            .AddResolvedEventListToStringConverter(logger)
            .AddResolvedEventToByteArrayConverter(logger)
            .AddResolvedEventListToByteArrayListConverter(logger)
            .AddOpenConverter <IList <OpenType>, IList <EventStoreData> >(typeof(ToOpenTypeListConverter <>), logger)
            .AddOpenConverter <OpenType, EventStoreData>(typeof(ToOpenTypeConverter <>), logger)
            .AddOpenConverter <IList <ResolvedEvent>, IList <OpenType> >(typeof(FromOpenTypeConverter <>), logger));
 }
コード例 #15
0
        /// <summary>
        /// Initializes the extension configuration provider.
        /// </summary>
        /// <param name="context">The extension configuration context.</param>
        public void Initialize(ExtensionConfigContext context)
        {
            var logger = context.Config.LoggerFactory.CreateLogger(LogCategories.CreateTriggerCategory("Mqtt"));

            var nameResolver          = context.Config.GetService <INameResolver>();
            var mqttConnectionFactory = new MqttConnectionFactory(logger, new MqttFactory(), nameResolver);

            context.Config.AddService(typeof(IMqttConnectionFactory), mqttConnectionFactory);

            var mqttAttributeBindingRule = context.AddBindingRule <MqttAttribute>();

            mqttAttributeBindingRule.BindToCollector((attr) => new MqttMessageCollector(attr, mqttConnectionFactory.GetMqttConnection(attr)));

            context.Config.RegisterBindingExtension(new MqttTriggerAttributeBindingProvider(nameResolver, mqttConnectionFactory, logger));

            // todo: in later release of the Functions SDK (currently beta 25) replace the line above with the two below
            //var mqttTriggerAttributeBindingRule = context.AddBindingRule<MqttTriggerAttribute>();
            //mqttTriggerAttributeBindingRule.BindToTrigger<IMqttMessage>(new MqttTriggerAttributeBindingProvider(nameResolver, _mqttConnectionFactory, logger));
        }
コード例 #16
0
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            else if (context.Trace == null)
            {
                throw new ArgumentNullException("context.Trace");
            }
            _tracer = context.Trace;

            Uri url = context.GetWebhookHandler();

            _tracer.Trace(new TraceEvent(System.Diagnostics.TraceLevel.Info, $"registered EventGrid Endpoint = {url}"));

            // Register our extension binding providers
            context.Config.RegisterBindingExtension(new EventGridTriggerAttributeBindingProvider(this));
        }
        /// <inheritdoc />
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

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

            // Set defaults, to be used if no other values are found:
            _defaultApiKey = _nameResolver.Resolve(AzureWebJobsMobileAppApiKeyName);

            string uriString = _nameResolver.Resolve(AzureWebJobsMobileAppUriName);

            Uri.TryCreate(uriString, UriKind.Absolute, out _defaultMobileAppUri);

            var rule = context.AddBindingRule <MobileTableAttribute>();

            rule.AddValidator(ValidateMobileAppUri);

            rule.BindToCollector <OpenType>(typeof(MobileTableCollectorBuilder <>), this);
            rule.BindToInput <IMobileServiceClient>(new MobileTableClientBuilder(this));

            // MobileType matching needs to know whether the attribute defines 'TableName', but
            // OpenTypes can't get access to the attribute. So use filters to split into 2 cases.
            rule.WhenIsNotNull(nameof(MobileTableAttribute.TableName)).
            BindToInput <IMobileServiceTableQuery <MobileTypeWithTableName> >(typeof(MobileTableQueryBuilder <>), this);
            rule.WhenIsNull(nameof(MobileTableAttribute.TableName)).
            BindToInput <IMobileServiceTableQuery <MobileTypeWithoutTableName> >(typeof(MobileTableQueryBuilder <>), this);

            rule.BindToInput <IMobileServiceTable>(new MobileTableJObjectTableBuilder(this));

            rule.WhenIsNotNull(nameof(MobileTableAttribute.TableName)).
            BindToInput <IMobileServiceTable <MobileTypeWithTableName> >(typeof(MobileTablePocoTableBuilder <>), this);
            rule.WhenIsNull(nameof(MobileTableAttribute.TableName)).
            BindToInput <IMobileServiceTable <MobileTypeWithoutTableName> >(typeof(MobileTablePocoTableBuilder <>), this);

            rule.WhenIsNotNull(nameof(MobileTableAttribute.TableName)).
            BindToValueProvider <MobileTypeWithTableName>(BindForItemAsync).AddValidator(HasId);
            rule.WhenIsNull(nameof(MobileTableAttribute.TableName)).
            BindToValueProvider <MobileTypeWithoutTableName>(BindForItemAsync).AddValidator(HasId);
        }
コード例 #18
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.
            Options.ExceptionHandler = (e) =>
            {
                LogExceptionReceivedEvent(e, _loggerFactory);
            };

            // register our trigger binding provider
            ServiceBusSessionTriggerAttributeBindingProvider triggerBindingProvider = new ServiceBusSessionTriggerAttributeBindingProvider(_nameResolver, _options, _sessionProvider, _configuration);

            context.AddBindingRule <ServiceBusSessionTriggerAttribute>().BindToTrigger(triggerBindingProvider);
        }
        /// <summary>
        /// This callback is invoked by the WebJobs framework before the host starts execution.
        /// It adds the binding rules and converters for the event stream backed orchestration
        /// classes
        /// </summary>
        /// <param name="context">
        /// The context to which extensions can be registered
        /// </param>
        public void Initialize(ExtensionConfigContext context)
        {
            // Add binding rules ... with converters
            // [Command]
            var commandRule = context.AddBindingRule <EventStreamBackedCommandOrchestrationTriggerAttribute>()
                              .AddConverter <string, StartCommandOrchestrationArgs>(this.StringToStartCommandArgs)
                              .AddConverter <JObject, StartCommandOrchestrationArgs>(this.JObjectToStartCommandArgs);

            commandRule.BindToCollector <StartCommandOrchestrationArgs>(this.CreateCommandAsyncCollector);
            commandRule.BindToInput <EventStreamBackedCommandOrchestrator>(this.GetCommandOrchestration);

            // [Query]
            var queryRule = context.AddBindingRule <EventStreamBackedQueryOrchestrationTriggerAttribute>()
                            .AddConverter <string, StartQueryOrchestrationArgs>(this.StringToStartQueryArgs)
                            .AddConverter <JObject, StartQueryOrchestrationArgs>(this.JObjectToStartQueryArgs);

            queryRule.BindToCollector <StartQueryOrchestrationArgs>(this.CreateQueryAsyncCollector);
            queryRule.BindToInput <EventStreamBackedQueryOrchestrator>(this.GetQueryOrchestration);

            // [Idetifier Group]
            var identifierGroupRule = context.AddBindingRule <EventStreamBackedIdentifierGroupOrchestrationTriggerAttribute>()
                                      .AddConverter <string, StartIdentifierGroupOrchestrationArgs>(this.StringToStartIdentifierGroupArgs)
                                      .AddConverter <JObject, StartIdentifierGroupOrchestrationArgs>(this.JObjectToStartIdentifierGroupArgs);

            identifierGroupRule.BindToCollector <StartIdentifierGroupOrchestrationArgs>(this.CreateIdentifierGroupAsyncCollector);
            identifierGroupRule.BindToInput <EventStreamBackedIdentifierGroupOrchestrator>(this.GetGroupOrchestration);

            // [Classifier]
            var classifierRule = context.AddBindingRule <EventStreamBackedClassifierOrchestrationTriggerAttribute>()
                                 .AddConverter <string, StartClassifierOrchestrationArgs>(this.StringToStartClassifierArgs)
                                 .AddConverter <JObject, StartClassifierOrchestrationArgs>(this.JObjectToStartClassifierArgs);

            classifierRule.BindToCollector <StartClassifierOrchestrationArgs>(this.CreateClassifierAsyncCollector);
            classifierRule.BindToInput <EventStreamBackedClassifierOrchestrator>(this.GetClassifierOrchestration);

            // [Projection]
            var projectionRule = context.AddBindingRule <EventStreamBackedProjectionOrchestrationTriggerAttribute>()
                                 .AddConverter <string, StartProjectionOrchestrationArgs>(this.StringToStartProjectionArgs)
                                 .AddConverter <JObject, StartProjectionOrchestrationArgs>(this.JObjectToStartProjectionArgs);

            projectionRule.BindToCollector <StartProjectionOrchestrationArgs>(this.CreateProjectionAsyncCollector);
            projectionRule.BindToInput <EventStreamBackedProjectionOrchestrator>(this.GetProjectionOrchestration);
        }
コード例 #20
0
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            var fileBindingProvider = new FileAttributeBindingProvider(_options, _nameResolver);

            context.AddBindingRule <FileAttribute>()
            .Bind(fileBindingProvider);

            var triggerBindingProvider = new FileTriggerAttributeBindingProvider(_options, _loggerFactory, _fileProcessorFactory);
            var triggerRule            = context.AddBindingRule <FileTriggerAttribute>();

            triggerRule.BindToTrigger(triggerBindingProvider);
            triggerRule.AddConverter <string, FileSystemEventArgs>(p => FileTriggerBinding.GetFileArgsFromString(p));
            triggerRule.AddConverter <FileSystemEventArgs, Stream>(p => File.OpenRead(p.FullPath));
        }
コード例 #21
0
        public void Initialize(ExtensionConfigContext context)
        {
            configuration.ConfigurationSection.Bind(options);

            context
            .AddConverter <KafkaEventData, string>(ConvertKafkaEventData2String)
            .AddConverter <KafkaEventData, ISpecificRecord>(ConvertKafkaEventData2AvroSpecific)
            .AddConverter <KafkaEventData, byte[]>(ConvertKafkaEventData2Bytes);

            // register our trigger binding provider
            var triggerBindingProvider = new KafkaTriggerAttributeBindingProvider(config, options, converterManager, nameResolver, loggerFactory);

            context.AddBindingRule <KafkaTriggerAttribute>()
            .BindToTrigger(triggerBindingProvider);

            // register output binding
            context.AddBindingRule <KafkaAttribute>()
            .BindToCollector(BuildCollectorFromAttribute);
        }
コード例 #22
0
        public void Initialize(ExtensionConfigContext context)
        {
            var services = new ContainerBuilder();

            RegisterServices(services);
            var container = services.Build();

            //var serviceProvider = services.BuildServiceProvider(true);

            context
            .AddBindingRule <InjectAttribute>()
            .Bind(new InjectBindingProvider(container));

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

            registry.RegisterExtension(typeof(IFunctionInvocationFilter), filter);
            registry.RegisterExtension(typeof(IFunctionExceptionFilter), filter);
        }
コード例 #23
0
        public void Initialize(ExtensionConfigContext context)
        {
            // Register converters. These help convert between the user's parameter type
            //  and the type specified by the binding rules.

            // This allows a user to bind to IAsyncCollector<string>, and the sdk
            // will convert that to IAsyncCollector<SampleItem>
            context.AddConverter <string, FileContent>(ConvertToItem);
            // This is useful on input binding.
            context.AddConverter <FileContent, string>(ConvertToString);

            // Create 2 binding rules for the Sample attribute.
            var rule = context.AddBindingRule <FileAccessAttribute>();

            //On input binding to read from the file
            rule.BindToInput <FileContent>(BuildItemFromAttr);
            //on output binding to make call to AddAsync method in IAyncCollector<FileContent>
            rule.BindToCollector <FileContent>(BuildCollector);
        }
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (string.IsNullOrEmpty(options.ConnectionString))
            {
                options.ConnectionString = nameResolver.Resolve(Constants.AzureSignalRConnectionStringName);
            }

            var serviceTransportTypeStr = nameResolver.Resolve(Constants.ServiceTransportTypeName);

            if (Enum.TryParse <ServiceTransportType>(serviceTransportTypeStr, out var transport))
            {
                options.AzureSignalRServiceTransportType = transport;
            }
            else
            {
                logger.LogWarning($"Unsupported service transport type: {serviceTransportTypeStr}. Use default {options.AzureSignalRServiceTransportType} instead.");
            }

            StaticServiceHubContextStore.ServiceManagerStore = new ServiceManagerStore(options.AzureSignalRServiceTransportType, Configuration, loggerFactory);

            context.AddConverter <string, JObject>(JObject.FromObject)
            .AddConverter <SignalRConnectionInfo, JObject>(JObject.FromObject)
            .AddConverter <JObject, SignalRMessage>(input => input.ToObject <SignalRMessage>())
            .AddConverter <JObject, SignalRGroupAction>(input => input.ToObject <SignalRGroupAction>());

            var signalRConnectionInfoAttributeRule = context.AddBindingRule <SignalRConnectionInfoAttribute>();

            signalRConnectionInfoAttributeRule.AddValidator(ValidateSignalRConnectionInfoAttributeBinding);
            signalRConnectionInfoAttributeRule.BindToInput <SignalRConnectionInfo>(GetClientConnectionInfo);

            var signalRAttributeRule = context.AddBindingRule <SignalRAttribute>();

            signalRAttributeRule.AddValidator(ValidateSignalRAttributeBinding);
            signalRAttributeRule.BindToCollector <SignalROpenType>(typeof(SignalRCollectorBuilder <>), this);

            logger.LogInformation("SignalRService binding initialized");
        }
コード例 #25
0
        /// <summary>
        /// Initializes the specified context.
        /// </summary>
        /// <param name="context">The context.</param>
        public void Initialize(ExtensionConfigContext context)
        {
            // Tell the Functions host that we want to add a new binding based on the KeyVaultSecret attribute class
            context.AddBindingRule <KeyVaultKeyAttribute>()
            // Let funchost know it's an Input binding, and how to convert it to the type the user specifies (eg: string). If you want the user to be able to use other types, you must add more 'BindToInput' calls that return those types as values. Here, I have to use a class implementing the IAsyncConverter because I need to call async methods to perform the conversion
            .BindToInput(KeyVaultKeyInputConverter.Instance)
            // Add a validator on the user's attribute implementation to make sure I can even do the conversion and blow up accordingly if I can't.
            .AddValidator((attrib, t) =>
            {
                if (string.IsNullOrWhiteSpace(attrib.ResourceNameSetting))
                {
                    throw new ArgumentException(nameof(attrib.ResourceNameSetting));
                }

                if (string.IsNullOrWhiteSpace(attrib.KeyIdSetting))
                {
                    throw new ArgumentNullException(nameof(attrib.KeyIdSetting));
                }
            });
        }
コード例 #26
0
        public void Initialize(ExtensionConfigContext context)
        {
            context.Trace.Info($"In {nameof(MyMessageExtensionConfigProvider)}.{nameof(Initialize)}");

            context.AddConverter <string, MyMessage>(s =>
                                                     new MyMessage {
                Name = "Custom-binding (string): " + s
            }
                                                     );

            context.AddConverter <EventData, MyMessage>(s =>
            {
                //var body = Encoding.UTF8.GetString(s.GetBytes());
                //return new MyMessage { Name = "Custom-binding (EventData): " + body };
                return(new MyMessage {
                    Name = "Custom-binding (EventData): " + s.ToString()
                });
            }
                                                        );
        }
        public void Initialize(ExtensionConfigContext context)
        {
            // add converter between JObject and SlackMessage
            // Allows a user to bind to IAsyncCollector<JObject>, and the sdk will convert that to IAsyncCollector<SlackMessage>
            context.AddConverter <JObject, Container>(input => input.ToObject <Container>());

            context.AddConverter <JObject, ContainerGroupDelete>(input => input.ToObject <ContainerGroupDelete>());

            // Add a binding rule for Collector
            context.AddBindingRule <ContainerGroupAttribute>()
            .BindToCollector <Container>(attr => new ContainerCreateAsyncCollector(this, attr));

            // Add a binding rule for Collector
            context.AddBindingRule <ContainerGroupWithPrivateRegistryAttribute>()
            .BindToCollector <Container>(attr => new ContainerCreateAsyncCollector(this, attr));

            // Add a binding rule for Collector
            context.AddBindingRule <DeleteContainerGroupAttribute>()
            .BindToCollector <ContainerGroupDelete>(attr => new ContainerGroupDeleteAsyncCollector(this, attr));
        }
        private static IDependencyConfiguration InitializeContainer(ExtensionConfigContext context)
        {
            var configType = AppDomain.CurrentDomain.GetAssemblies()
                             .SelectMany(x => x.GetTypes())
                             .FirstOrDefault(x =>
                                             typeof(IDependencyConfiguration).IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract);

            IDependencyConfiguration configuration = null;

            if (configType == null)
            {
                return(configuration);
            }

            var configInstance = Activator.CreateInstance(configType);

            configuration = (IDependencyConfiguration)configInstance;

            return(configuration);
        }
コード例 #29
0
            public void Initialize(ExtensionConfigContext context)
            {
                context.AddBindingRule <TestStreamAttribute>().
                BindToStream(this, FileAccess.ReadWrite);

                // Override the Stream --> String converter
                context.AddConverter <Stream, string>(stream => ReadTag);

                context.AddConverter <ApplyConversion <string, Stream>, object>((pair) =>
                {
                    var val    = pair.Value;
                    var stream = pair.Existing;
                    using (var sr = new StreamWriter(stream))
                    {
                        sr.Write("yy");  // custom
                        sr.Write(val);
                    }
                    return(null);
                });
            }
        public void Initialize(ExtensionConfigContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

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

            context.AddConverter <JObject, CreateMessageOptions>(CreateMessageOptions);

            var rule = context.AddBindingRule <TwilioSmsAttribute>();

            rule.AddValidator(ValidateBinding);
            rule.BindToCollector <CreateMessageOptions>((attr) =>
            {
                return(new TwilioSmsMessageAsyncCollector(CreateContext(attr)));
            });
        }