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 BlobTriggerAttributeBindingProvider(INameResolver nameResolver,
IStorageAccountProvider accountProvider,
IExtensionTypeLocator extensionTypeLocator,
IHostIdProvider hostIdProvider,
IQueueConfiguration queueConfiguration,
JobHostBlobsConfiguration blobsConfiguration,
IWebJobsExceptionHandler exceptionHandler,
IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
IContextSetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
ISharedContextProvider sharedContextProvider,
SingletonManager singletonManager,
ILoggerFactory loggerFactory)
{
if (extensionTypeLocator == null)
{
throw new ArgumentNullException(nameof(extensionTypeLocator));
}
_accountProvider = accountProvider ?? throw new ArgumentNullException(nameof(accountProvider));
_hostIdProvider = hostIdProvider ?? throw new ArgumentNullException(nameof(hostIdProvider));
_queueConfiguration = queueConfiguration ?? throw new ArgumentNullException(nameof(queueConfiguration));
_blobsConfiguration = blobsConfiguration ?? throw new ArgumentNullException(nameof(blobsConfiguration));
_exceptionHandler = exceptionHandler ?? throw new ArgumentNullException(nameof(exceptionHandler));
_blobWrittenWatcherSetter = blobWrittenWatcherSetter ?? throw new ArgumentNullException(nameof(blobWrittenWatcherSetter));
_messageEnqueuedWatcherSetter = messageEnqueuedWatcherSetter ?? throw new ArgumentNullException(nameof(messageEnqueuedWatcherSetter));
_sharedContextProvider = sharedContextProvider ?? throw new ArgumentNullException(nameof(sharedContextProvider));
_singletonManager = singletonManager ?? throw new ArgumentNullException(nameof(singletonManager));
_nameResolver = nameResolver;
_loggerFactory = loggerFactory;
}
public void GetHostIdAsync_IfStorageAccountProviderThrowsInvalidOperationException_WrapsException()
{
// Arrange
Mock <IStorageAccountProvider> storageAccountProviderMock = new Mock <IStorageAccountProvider>(
MockBehavior.Strict);
TaskCompletionSource <IStorageAccount> taskSource = new TaskCompletionSource <IStorageAccount>();
InvalidOperationException innerException = new InvalidOperationException();
taskSource.SetException(innerException);
storageAccountProviderMock
.Setup(p => p.GetAccountAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(taskSource.Task);
IStorageAccountProvider storageAccountProvider = storageAccountProviderMock.Object;
IFunctionIndexProvider functionIndexProvider = CreateDummyFunctionIndexProvider();
IHostIdProvider product = new DynamicHostIdProvider(storageAccountProvider, () => functionIndexProvider);
CancellationToken cancellationToken = CancellationToken.None;
// Act & Assert
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(
() => product.GetHostIdAsync(cancellationToken).GetAwaiter().GetResult());
Assert.Equal("A host ID is required. Either set JobHostConfiguration.HostId or provide a valid storage " +
"connection string.", exception.Message);
Assert.Same(innerException, exception.InnerException);
}
public static async Task <IStorageAccount> GetStorageAccountAsync(this IStorageAccountProvider provider, ParameterInfo parameter, CancellationToken cancellationToken, INameResolver nameResolver = null)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
string connectionStringName = GetAccountOverrideOrNull(parameter);
if (string.IsNullOrEmpty(connectionStringName))
{
connectionStringName = ConnectionStringNames.Storage;
}
if (nameResolver != null)
{
string resolved = null;
if (nameResolver.TryResolveWholeString(connectionStringName, out resolved))
{
connectionStringName = resolved;
}
}
IStorageAccount account = await provider.TryGetAccountAsync(connectionStringName, cancellationToken);
ValidateStorageAccount(account, connectionStringName);
return(account);
}
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 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 FakeQueueProcessorFactory(IStorageAccountProvider accountProvider)
{
CancellationToken token = new CancellationToken();
Task <IStorageAccount> task = accountProvider.GetStorageAccountAsync(token);
_storageAccount = task.Result;
}
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 FakeQueueProcessorFactory(IStorageAccountProvider accountProvider)
{
CancellationToken token = new CancellationToken();
Task<IStorageAccount> task = accountProvider.GetStorageAccountAsync(token);
task.Wait();
_storageAccount = task.Result;
}
public static ITriggerBindingProvider Create(INameResolver nameResolver,
IStorageAccountProvider storageAccountProvider,
IServiceBusAccountProvider serviceBusAccountProvider,
IExtensionTypeLocator extensionTypeLocator,
IHostIdProvider hostIdProvider,
IQueueConfiguration queueConfiguration,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
IContextSetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
IContextSetter <IBlobWrittenWatcher> blobWrittenWatcherSetter,
ISharedContextProvider sharedContextProvider,
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));
Type serviceBusProviderType = ServiceBusExtensionTypeLoader.Get(
"Microsoft.Azure.WebJobs.ServiceBus.Triggers.ServiceBusTriggerAttributeBindingProvider");
if (serviceBusProviderType != null)
{
ITriggerBindingProvider serviceBusAttributeBindingProvider =
(ITriggerBindingProvider)Activator.CreateInstance(serviceBusProviderType, nameResolver,
serviceBusAccountProvider);
innerProviders.Add(serviceBusAttributeBindingProvider);
}
return(new CompositeTriggerBindingProvider(innerProviders));
}
public void Initialize(ExtensionConfigContext context)
{
_messageEnqueuedWatcherGetter = context.PerHostServices.GetService <ContextAccessor <IMessageEnqueuedWatcher> >();
_accountProvider = context.Config.GetService <IStorageAccountProvider>();
context.ApplyConfig(context.Config.Queues, "queues");
// IStorageQueueMessage is the core testing interface
var binding = context.AddBindingRule <QueueAttribute>();
binding
.AddConverter <byte[], IStorageQueueMessage>(ConvertByteArrayToCloudQueueMessage)
.AddConverter <string, IStorageQueueMessage>(ConvertStringToCloudQueueMessage)
.AddOpenConverter <OpenType.Poco, IStorageQueueMessage>(ConvertPocoToCloudQueueMessage);
context // global converters, apply to multiple attributes.
.AddConverter <IStorageQueueMessage, byte[]>(ConvertCloudQueueMessageToByteArray)
.AddConverter <IStorageQueueMessage, string>(ConvertCloudQueueMessageToString)
.AddConverter <CloudQueueMessage, IStorageQueueMessage>(ConvertToStorageQueueMessage);
var builder = new QueueBuilder(this);
binding.AddValidator(ValidateQueueAttribute);
binding.SetPostResolveHook(ToWriteParameterDescriptorForCollector)
.BindToCollector <IStorageQueueMessage>(this);
binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector)
.BindToInput <IStorageQueue>(builder);
binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector)
.BindToInput <CloudQueue>(builder);
}
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;
}
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;
_tableBindingProvider = new CompositeArgumentBindingProvider(
new StorageTableArgumentBindingProvider(),
new CloudTableArgumentBindingProvider(),
new QueryableArgumentBindingProvider(),
new CollectorArgumentBindingProvider(),
new AsyncCollectorArgumentBindingProvider(),
new TableArgumentBindingExtensionProvider(extensions));
_entityBindingProvider =
new CompositeEntityArgumentBindingProvider(
new TableEntityArgumentBindingProvider(),
new PocoEntityArgumentBindingProvider()); // Supports all types; must come after other providers
}
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
}
// Use the static Build method to create.
// Constructor is just for capturing instance fields used in func closures.
private QueueBindingProvider(
IStorageAccountProvider accountProvider,
IContextGetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherGetter)
{
_accountProvider = accountProvider;
_messageEnqueuedWatcherGetter = messageEnqueuedWatcherGetter;
}
public SingletonManager(IStorageAccountProvider accountProvider, IBackgroundExceptionDispatcher backgroundExceptionDispatcher, SingletonConfiguration config, TraceWriter trace, INameResolver nameResolver = null)
{
_accountProvider = accountProvider;
_nameResolver = nameResolver;
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_config = config;
_trace = trace;
}
public SingletonManager(IStorageAccountProvider accountProvider, IBackgroundExceptionDispatcher backgroundExceptionDispatcher, SingletonConfiguration config, TraceWriter trace, INameResolver nameResolver = null)
{
_accountProvider = accountProvider;
_nameResolver = nameResolver;
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_config = config;
_trace = trace;
}
public DefaultLoggerProvider(IStorageAccountProvider storageAccountProvider)
{
if (storageAccountProvider == null)
{
throw new ArgumentNullException("storageAccountProvider");
}
_storageAccountProvider = storageAccountProvider;
}
public DefaultLoggerProvider(IStorageAccountProvider storageAccountProvider)
{
if (storageAccountProvider == null)
{
throw new ArgumentNullException("storageAccountProvider");
}
_storageAccountProvider = storageAccountProvider;
}
public BlobLeaseDistributedLockManager(
IStorageAccountProvider accountProvider,
TraceWriter trace,
ILogger logger)
{
_accountProvider = accountProvider;
_trace = trace;
_logger = logger;
}
public SingletonManager(IStorageAccountProvider accountProvider, IWebJobsExceptionHandler exceptionHandler, SingletonConfiguration config, TraceWriter trace, IHostIdProvider hostIdProvider, INameResolver nameResolver = null)
{
_accountProvider = accountProvider;
_nameResolver = nameResolver;
_exceptionHandler = exceptionHandler;
_config = config;
_trace = trace;
_hostIdProvider = hostIdProvider;
}
public static Task <IStorageAccount> GetStorageAccountAsync(this IStorageAccountProvider provider, CancellationToken cancellationToken)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
return(provider.GetAccountAsync(ConnectionStringNames.Storage, cancellationToken));
}
public CloudStorageAccountBindingProvider(IStorageAccountProvider accountProvider)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
_accountProvider = accountProvider;
}
public CloudStorageAccountBindingProvider(IStorageAccountProvider accountProvider)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
_accountProvider = accountProvider;
}
public TableAttributeBindingProvider(INameResolver nameResolver, IStorageAccountProvider accountProvider)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
_nameResolver = nameResolver;
_accountProvider = accountProvider;
}
private static TestJobHostConfiguration CreateConfiguration(IStorageAccountProvider storageAccountProvider)
{
return(new TestJobHostConfiguration
{
ContextFactory = new TestJobHostContextFactory
{
StorageAccountProvider = storageAccountProvider
}
});
}
public static IBindingProvider Build(
IStorageAccountProvider accountProvider,
IContextGetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherGetter,
INameResolver nameResolver,
IConverterManager converterManager)
{
var closure = new QueueBindingProvider(accountProvider, messageEnqueuedWatcherGetter);
var bindingProvider = closure.New(nameResolver, converterManager);
return(bindingProvider);
}
private static JobHostConfiguration CreateConfiguration(IStorageAccountProvider storageAccountProvider)
{
var singletonManager = new SingletonManager();
return(TestHelpers.NewConfig(
storageAccountProvider,
singletonManager,
new NullConsoleProvider(),
new FixedHostIdProvider(Guid.NewGuid().ToString("N")),
new EmptyFunctionIndexProvider()
));
}
public static async Task <IStorageAccount> GetAccountAsync(this IStorageAccountProvider provider, string connectionStringName, CancellationToken cancellationToken)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
IStorageAccount account = await provider.TryGetAccountAsync(connectionStringName, cancellationToken);
ValidateStorageAccount(account, connectionStringName);
return(account);
}
public SingletonManager(IStorageAccountProvider accountProvider, IWebJobsExceptionHandler exceptionHandler, SingletonConfiguration config,
TraceWriter trace, ILoggerFactory loggerFactory, IHostIdProvider hostIdProvider, INameResolver nameResolver = null)
{
_accountProvider = accountProvider;
_nameResolver = nameResolver;
_exceptionHandler = exceptionHandler;
_config = config;
_trace = trace;
_loggerFactory = loggerFactory;
_logger = _loggerFactory?.CreateLogger(LogCategories.Singleton);
_hostIdProvider = hostIdProvider;
}
public JobHostContextFactory(IStorageAccountProvider storageAccountProvider, IServiceBusAccountProvider
serviceBusAccountProvider, ITypeLocator typeLocator, INameResolver nameResolver, IJobActivator activator,
string hostId, IQueueConfiguration queueConfiguration, IConsoleProvider consoleProvider)
{
_storageAccountProvider = storageAccountProvider;
_serviceBusAccountProvider = serviceBusAccountProvider;
_typeLocator = typeLocator;
_activator = activator;
_nameResolver = nameResolver;
_hostId = hostId;
_queueConfiguration = queueConfiguration;
_consoleProvider = consoleProvider;
}
public DefaultLoggerProvider(IStorageAccountProvider storageAccountProvider, TraceWriter trace)
{
if (storageAccountProvider == null)
{
throw new ArgumentNullException("storageAccountProvider");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
_storageAccountProvider = storageAccountProvider;
_trace = trace;
}
public DefaultLoggerProvider(IStorageAccountProvider storageAccountProvider, TraceWriter trace)
{
if (storageAccountProvider == null)
{
throw new ArgumentNullException("storageAccountProvider");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
_storageAccountProvider = storageAccountProvider;
_trace = trace;
}
public TableAttributeBindingProvider(INameResolver nameResolver, IStorageAccountProvider accountProvider)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
_nameResolver = nameResolver;
_accountProvider = accountProvider;
_entityBindingProvider =
new CompositeEntityArgumentBindingProvider(
new TableEntityArgumentBindingProvider(),
new PocoEntityArgumentBindingProvider()); // Supports all types; must come after other providers
}
public QueueTriggerAttributeBindingProvider(INameResolver nameResolver,
IStorageAccountProvider accountProvider,
IQueueConfiguration queueConfiguration,
IWebJobsExceptionHandler exceptionHandler,
IContextSetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
ISharedContextProvider sharedContextProvider,
TraceWriter trace,
ILoggerFactory loggerFactory)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
if (queueConfiguration == null)
{
throw new ArgumentNullException("queueConfiguration");
}
if (exceptionHandler == null)
{
throw new ArgumentNullException("exceptionHandler");
}
if (messageEnqueuedWatcherSetter == null)
{
throw new ArgumentNullException("messageEnqueuedWatcherSetter");
}
if (sharedContextProvider == null)
{
throw new ArgumentNullException("sharedContextProvider");
}
if (trace == null)
{
throw new ArgumentNullException("trace");
}
_nameResolver = nameResolver;
_accountProvider = accountProvider;
_queueConfiguration = queueConfiguration;
_exceptionHandler = exceptionHandler;
_messageEnqueuedWatcherSetter = messageEnqueuedWatcherSetter;
_sharedContextProvider = sharedContextProvider;
_trace = trace;
_loggerFactory = loggerFactory;
}
public static Task <IStorageAccount> GetStorageAccountAsync(this IStorageAccountProvider provider, ParameterInfo parameter, CancellationToken cancellationToken)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
string connectionStringName = GetAccountOverrideOrNull(parameter);
if (string.IsNullOrEmpty(connectionStringName))
{
connectionStringName = ConnectionStringNames.Storage;
}
return(provider.GetAccountAsync(connectionStringName, cancellationToken));
}
public DynamicHostIdProvider(IStorageAccountProvider storageAccountProvider,
Func <IFunctionIndexProvider> getFunctionIndexProvider)
{
if (storageAccountProvider == null)
{
throw new ArgumentNullException("storageAccountProvider");
}
if (getFunctionIndexProvider == null)
{
throw new ArgumentNullException("getFunctionIndexProvider");
}
_storageAccountProvider = storageAccountProvider;
_getFunctionIndexProvider = getFunctionIndexProvider;
}
public DynamicHostIdProvider(IStorageAccountProvider storageAccountProvider,
Func<IFunctionIndexProvider> getFunctionIndexProvider)
{
if (storageAccountProvider == null)
{
throw new ArgumentNullException("storageAccountProvider");
}
if (getFunctionIndexProvider == null)
{
throw new ArgumentNullException("getFunctionIndexProvider");
}
_storageAccountProvider = storageAccountProvider;
_getFunctionIndexProvider = getFunctionIndexProvider;
}
public static IBindingProvider Create(
INameResolver nameResolver,
IConverterManager converterManager,
IStorageAccountProvider storageAccountProvider,
IExtensionTypeLocator extensionTypeLocator,
IContextGetter <IMessageEnqueuedWatcher> messageEnqueuedWatcherGetter,
IContextGetter <IBlobWrittenWatcher> blobWrittenWatcherGetter,
IExtensionRegistry extensions)
{
List <IBindingProvider> innerProviders = new List <IBindingProvider>();
if (converterManager == null)
{
converterManager = new ConverterManager();
}
// Wire up new bindings
var ruleQueueOutput = QueueBindingProvider.Build(storageAccountProvider, messageEnqueuedWatcherGetter, nameResolver, converterManager);
innerProviders.Add(ruleQueueOutput);
innerProviders.Add(new BlobAttributeBindingProvider(nameResolver, storageAccountProvider, extensionTypeLocator, blobWrittenWatcherGetter));
innerProviders.Add(TableAttributeBindingProvider.Build(nameResolver, converterManager, 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 TraceWriter binder handles all remaining TraceWriter/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 TraceWriterBindingProvider());
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);
}
public QueueTriggerAttributeBindingProvider(INameResolver nameResolver,
IStorageAccountProvider accountProvider,
IQueueConfiguration queueConfiguration,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher,
IContextSetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherSetter,
ISharedContextProvider sharedContextProvider,
TextWriter log)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
if (queueConfiguration == null)
{
throw new ArgumentNullException("queueConfiguration");
}
if (backgroundExceptionDispatcher == null)
{
throw new ArgumentNullException("backgroundExceptionDispatcher");
}
if (messageEnqueuedWatcherSetter == null)
{
throw new ArgumentNullException("messageEnqueuedWatcherSetter");
}
if (sharedContextProvider == null)
{
throw new ArgumentNullException("sharedContextProvider");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
_nameResolver = nameResolver;
_accountProvider = accountProvider;
_queueConfiguration = queueConfiguration;
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_messageEnqueuedWatcherSetter = messageEnqueuedWatcherSetter;
_sharedContextProvider = sharedContextProvider;
_log = log;
}
public QueueAttributeBindingProvider(INameResolver nameResolver, IStorageAccountProvider accountProvider,
IContextGetter<IMessageEnqueuedWatcher> messageEnqueuedWatcherGetter)
{
if (accountProvider == null)
{
throw new ArgumentNullException("accountProvider");
}
if (messageEnqueuedWatcherGetter == null)
{
throw new ArgumentNullException("messageEnqueuedWatcherGetter");
}
_nameResolver = nameResolver;
_accountProvider = accountProvider;
_innerProvider = CreateInnerProvider(messageEnqueuedWatcherGetter);
}
public static async Task<JobHostContext> CreateAndLogHostStartedAsync(
JobHost host,
IStorageAccountProvider storageAccountProvider,
IQueueConfiguration queueConfiguration,
ITypeLocator typeLocator,
IJobActivator activator,
INameResolver nameResolver,
IConsoleProvider consoleProvider,
JobHostConfiguration config,
CancellationToken shutdownToken,
CancellationToken cancellationToken,
IHostIdProvider hostIdProvider = null,
FunctionExecutor functionExecutor = null,
IFunctionIndexProvider functionIndexProvider = null,
IBindingProvider bindingProvider = null,
IHostInstanceLoggerProvider hostInstanceLogerProvider = null,
IFunctionInstanceLoggerProvider functionInstanceLoggerProvider = null,
IFunctionOutputLoggerProvider functionOutputLoggerProvider = null,
IBackgroundExceptionDispatcher backgroundExceptionDispatcher = null,
SingletonManager singletonManager = null)
{
if (hostIdProvider == null)
{
hostIdProvider = new DynamicHostIdProvider(storageAccountProvider, () => functionIndexProvider);
}
IExtensionTypeLocator extensionTypeLocator = new ExtensionTypeLocator(typeLocator);
if (backgroundExceptionDispatcher == null)
{
backgroundExceptionDispatcher = BackgroundExceptionDispatcher.Instance;
}
ContextAccessor<IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor = new ContextAccessor<IMessageEnqueuedWatcher>();
ContextAccessor<IBlobWrittenWatcher> blobWrittenWatcherAccessor = new ContextAccessor<IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
// Create a wrapper TraceWriter that delegates to both the user
// TraceWriter specified on Config (if present), as well as to Console
TraceWriter trace = new ConsoleTraceWriter(config.Tracing, consoleProvider.Out);
// Register system services with the service container
config.AddService<INameResolver>(nameResolver);
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
Trace = trace,
Host = host
};
InvokeExtensionConfigProviders(context);
IExtensionRegistry extensions = config.GetExtensions();
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider, queueConfiguration, backgroundExceptionDispatcher,
messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, sharedContextProvider, extensions, trace);
if (bindingProvider == null)
{
bindingProvider = DefaultBindingProvider.Create(nameResolver, storageAccountProvider, extensionTypeLocator, messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, extensions);
}
DefaultLoggerProvider loggerProvider = new DefaultLoggerProvider(storageAccountProvider, trace);
if (singletonManager == null)
{
singletonManager = new SingletonManager(storageAccountProvider, backgroundExceptionDispatcher, config.Singleton, trace, config.NameResolver);
}
using (CancellationTokenSource combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, shutdownToken))
{
CancellationToken combinedCancellationToken = combinedCancellationSource.Token;
await WriteSiteExtensionManifestAsync(combinedCancellationToken);
IStorageAccount dashboardAccount = await storageAccountProvider.GetDashboardAccountAsync(combinedCancellationToken);
IHostInstanceLogger hostInstanceLogger = null;
if (hostInstanceLogerProvider != null)
{
hostInstanceLogger = await hostInstanceLogerProvider.GetAsync(combinedCancellationToken);
}
else
{
hostInstanceLogger = await((IHostInstanceLoggerProvider)loggerProvider).GetAsync(combinedCancellationToken);
}
IFunctionInstanceLogger functionInstanceLogger = null;
if (functionInstanceLoggerProvider != null)
{
functionInstanceLogger = await functionInstanceLoggerProvider.GetAsync(combinedCancellationToken);
}
else
{
functionInstanceLogger = (IFunctionInstanceLogger)(await((IFunctionInstanceLoggerProvider)loggerProvider).GetAsync(combinedCancellationToken));
}
IFunctionOutputLogger functionOutputLogger = null;
if (functionOutputLoggerProvider != null)
{
functionOutputLogger = await functionOutputLoggerProvider.GetAsync(combinedCancellationToken);
}
else
{
functionOutputLogger = (IFunctionOutputLogger)(await((IFunctionOutputLoggerProvider)loggerProvider).GetAsync(combinedCancellationToken));
}
if (functionExecutor == null)
{
functionExecutor = new FunctionExecutor(functionInstanceLogger, functionOutputLogger, backgroundExceptionDispatcher, trace);
}
if (functionIndexProvider == null)
{
functionIndexProvider = new FunctionIndexProvider(typeLocator, triggerBindingProvider, bindingProvider, activator, functionExecutor, extensions, singletonManager);
}
IFunctionIndex functions = await functionIndexProvider.GetAsync(combinedCancellationToken);
IListenerFactory functionsListenerFactory = new HostListenerFactory(functions.ReadAll(), singletonManager, activator, nameResolver, trace);
IFunctionExecutor hostCallExecutor;
IListener listener;
HostOutputMessage hostOutputMessage;
if (dashboardAccount != null)
{
string hostId = await hostIdProvider.GetHostIdAsync(cancellationToken);
string sharedQueueName = HostQueueNames.GetHostQueueName(hostId);
IStorageQueueClient dashboardQueueClient = dashboardAccount.CreateQueueClient();
IStorageQueue sharedQueue = dashboardQueueClient.GetQueueReference(sharedQueueName);
IListenerFactory sharedQueueListenerFactory = new HostMessageListenerFactory(sharedQueue,
queueConfiguration, backgroundExceptionDispatcher, trace, functions,
functionInstanceLogger, functionExecutor);
Guid hostInstanceId = Guid.NewGuid();
string instanceQueueName = HostQueueNames.GetHostQueueName(hostInstanceId.ToString("N"));
IStorageQueue instanceQueue = dashboardQueueClient.GetQueueReference(instanceQueueName);
IListenerFactory instanceQueueListenerFactory = new HostMessageListenerFactory(instanceQueue,
queueConfiguration, backgroundExceptionDispatcher, trace, functions,
functionInstanceLogger, functionExecutor);
HeartbeatDescriptor heartbeatDescriptor = new HeartbeatDescriptor
{
SharedContainerName = HostContainerNames.Hosts,
SharedDirectoryName = HostDirectoryNames.Heartbeats + "/" + hostId,
InstanceBlobName = hostInstanceId.ToString("N"),
ExpirationInSeconds = (int)HeartbeatIntervals.ExpirationInterval.TotalSeconds
};
IStorageBlockBlob blob = dashboardAccount.CreateBlobClient()
.GetContainerReference(heartbeatDescriptor.SharedContainerName)
.GetBlockBlobReference(heartbeatDescriptor.SharedDirectoryName + "/" + heartbeatDescriptor.InstanceBlobName);
IRecurrentCommand heartbeatCommand = new UpdateHostHeartbeatCommand(new HeartbeatCommand(blob));
IEnumerable<MethodInfo> indexedMethods = functions.ReadAllMethods();
Assembly hostAssembly = GetHostAssembly(indexedMethods);
string displayName = hostAssembly != null ? hostAssembly.GetName().Name : "Unknown";
hostOutputMessage = new DataOnlyHostOutputMessage
{
HostInstanceId = hostInstanceId,
HostDisplayName = displayName,
SharedQueueName = sharedQueueName,
InstanceQueueName = instanceQueueName,
Heartbeat = heartbeatDescriptor,
WebJobRunIdentifier = WebJobRunIdentifier.Current
};
hostCallExecutor = CreateHostCallExecutor(instanceQueueListenerFactory, heartbeatCommand,
backgroundExceptionDispatcher, shutdownToken, functionExecutor);
IListenerFactory hostListenerFactory = new CompositeListenerFactory(functionsListenerFactory,
sharedQueueListenerFactory, instanceQueueListenerFactory);
listener = CreateHostListener(hostListenerFactory, heartbeatCommand, backgroundExceptionDispatcher, shutdownToken);
// Publish this to Azure logging account so that a web dashboard can see it.
await LogHostStartedAsync(functions, hostOutputMessage, hostInstanceLogger, combinedCancellationToken);
}
else
{
hostCallExecutor = new ShutdownFunctionExecutor(shutdownToken, functionExecutor);
IListener factoryListener = new ListenerFactoryListener(functionsListenerFactory);
IListener shutdownListener = new ShutdownListener(shutdownToken, factoryListener);
listener = shutdownListener;
hostOutputMessage = new DataOnlyHostOutputMessage();
}
functionExecutor.HostOutputMessage = hostOutputMessage;
IEnumerable<FunctionDescriptor> descriptors = functions.ReadAllDescriptors();
int descriptorsCount = descriptors.Count();
if (descriptorsCount == 0)
{
trace.Warning("No functions found. Try making job classes and methods public.", TraceSource.Indexing);
}
else
{
StringBuilder functionsTrace = new StringBuilder();
functionsTrace.AppendLine("Found the following functions:");
foreach (FunctionDescriptor descriptor in descriptors)
{
functionsTrace.AppendLine(descriptor.FullName);
}
trace.Info(functionsTrace.ToString(), TraceSource.Indexing);
}
return new JobHostContext(functions, hostCallExecutor, listener, trace);
}
}
public JobHostContextFactory(IStorageAccountProvider storageAccountProvider, IConsoleProvider consoleProvider, JobHostConfiguration config)
{
_storageAccountProvider = storageAccountProvider;
_consoleProvider = consoleProvider;
_config = config;
}
public FakeQueueConfiguration(IStorageAccountProvider accountProvider)
{
_queueProcessorFactory = new FakeQueueProcessorFactory(accountProvider);
}
private static TestJobHostConfiguration CreateConfiguration(IStorageAccountProvider storageAccountProvider)
{
return new TestJobHostConfiguration
{
ContextFactory = new TestJobHostContextFactory
{
StorageAccountProvider = storageAccountProvider,
SingletonManager = new SingletonManager()
}
};
}
