public static void RegisterBindingRules(JobHostConfiguration hostConfig)
{
IConverterManager cm = hostConfig.ConverterManager;
cm.AddConverter <DurableActivityContext, string>(ActivityContextToString);
cm.AddConverter <DurableActivityContext, JObject>(ActivityContextToJObject);
}
public static IConverterManager AddNotificationHubConverters(this IConverterManager converterManager)
{
converterManager.AddConverter <TemplateNotification, Notification>(templateNotification => templateNotification);
converterManager.AddConverter <string, Notification>(messageProperties => BuildTemplateNotificationFromJsonString(messageProperties));
converterManager.AddConverter <IDictionary <string, string>, Notification>(messageProperties => BuildTemplateNotificationFromDictionary(messageProperties));
return(converterManager);
}
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);
}
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);
}
/// <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);
}
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);
}
public static void AddNotificationHubConverters(this IConverterManager converterManager)
{
converterManager.AddConverter <TemplateNotification, Notification>(templateNotification => templateNotification);
converterManager.AddConverter <string, Notification>(messageProperties => BuildTemplateNotificationFromJsonString(messageProperties));
converterManager.AddConverter <string, Notification, NotificationHubAttribute>((notificationAsString, notificationHubAttr) => BuildNotificationFromString(notificationAsString, notificationHubAttr.Platform));
converterManager.AddConverter <IDictionary <string, string>, Notification>(messageProperties => BuildTemplateNotificationFromDictionary(messageProperties));
}
public static void RegisterBindingRules(JobHostConfiguration hostConfig)
{
#pragma warning disable CS0618 // Type or member is obsolete
IConverterManager cm = hostConfig.ConverterManager;
#pragma warning restore CS0618 // Type or member is obsolete
cm.AddConverter <DurableActivityContext, string>(ActivityContextToString);
cm.AddConverter <DurableActivityContext, JObject>(ActivityContextToJObject);
}
public static void RegisterBindingRules(JobHostConfiguration hostConfig)
{
IConverterManager cm = hostConfig.ConverterManager;
cm.AddConverter <DurableActivityContext, string>(ActivityContextToString);
cm.AddConverter <DurableActivityContext, JObject>(ActivityContextToJObject);
// TODO: Add support for open types - i.e. POCO objects
}
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 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);
}
/// <summary>
/// Register a new converter function that is influenced by the attribute.
/// If TSource is object, then this converter is applied to any attempt to convert to TDestination.
/// </summary>
/// <typeparam name="TSource">Source type.</typeparam>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <typeparam name="TAttribute">Attribute on the binding. </typeparam>
/// <param name="converterManager"></param>
/// <param name="converter">A function to convert from the source to the destination type.</param>
public static void AddConverter <TSource, TDestination, TAttribute>(this IConverterManager converterManager, Func <TSource, TAttribute, TDestination> converter)
where TAttribute : Attribute
{
FuncConverter <TSource, TAttribute, TDestination> func = (src, attr, context) => converter(src, attr);
converterManager.AddConverter(func);
}
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);
}
public static IBindingProvider Build(INameResolver nameResolver, IConverterManager converterManager, IStorageAccountProvider accountProvider, IExtensionRegistry extensions)
{
var original = new TableAttributeBindingProvider(nameResolver, accountProvider, extensions);
converterManager.AddConverter <JObject, ITableEntity, TableAttribute>(original.JObjectToTableEntityConverterFunc);
converterManager.AddConverter <object, ITableEntity, TableAttribute>(typeof(ObjectToITableEntityConverter <>));
// IStorageTable --> IQueryable<ITableEntity>
converterManager.AddConverter <IStorageTable, IQueryable <OpenType>, TableAttribute>(typeof(TableToIQueryableConverter <>));
var bindingFactory = new BindingFactory(nameResolver, converterManager);
// Includes converter manager, which provides access to IQueryable<ITableEntity>
var bindToExactCloudTable = bindingFactory.BindToInput <TableAttribute, CloudTable>(typeof(JObjectBuilder))
.SetPostResolveHook <TableAttribute>(original.ToParameterDescriptorForCollector, original.CollectAttributeInfo);
var bindToExactTestCloudTable = bindingFactory.BindToInput <TableAttribute, IStorageTable>(typeof(JObjectBuilder))
.SetPostResolveHook <TableAttribute>(original.ToParameterDescriptorForCollector, original.CollectAttributeInfo);
var bindAsyncCollector = bindingFactory.BindToCollector <TableAttribute, ITableEntity>(original.BuildFromTableAttribute)
.SetPostResolveHook <TableAttribute>(null, original.CollectAttributeInfo);
var bindToJobject = bindingFactory.BindToInput <TableAttribute, JObject>(typeof(JObjectBuilder))
.SetPostResolveHook <TableAttribute>(null, original.CollectAttributeInfo);
var bindToJArray = bindingFactory.BindToInput <TableAttribute, JArray>(typeof(JObjectBuilder))
.SetPostResolveHook <TableAttribute>(null, original.CollectAttributeInfo);
var bindingProvider = new GenericCompositeBindingProvider <TableAttribute>(
ValidateAttribute, nameResolver,
new IBindingProvider[]
{
bindAsyncCollector,
AllowMultipleRows(bindingFactory, bindToExactCloudTable),
AllowMultipleRows(bindingFactory, bindToExactTestCloudTable),
bindToJArray,
bindToJobject,
original
});
return(bindingProvider);
}
public void Initialize(ExtensionConfigContext context)
{
IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();
var bf = context.Config.BindingFactory;
// Add [Test] support
var rule = bf.BindToExactType <TestAttribute, string>(attr => attr.Path);
extensions.RegisterBindingRules <TestAttribute>(rule);
// Add [FakeQueueTrigger] support.
IConverterManager cm = context.Config.GetService <IConverterManager>();
cm.AddConverter <string, FakeQueueData>(x => new FakeQueueData {
Message = x
});
cm.AddConverter <FakeQueueData, string>(msg => msg.Message);
var triggerBindingProvider = new FakeQueueTriggerBindingProvider(new FakeQueueClient(), cm);
extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);
}
// Helper to allocate a binding provider for [Queue].
// private instance method since it's refering to lambdas that close over the instance fields.
private IBindingProvider New(
INameResolver nameResolver,
IConverterManager converterManager)
{
// IStorageQueueMessage is the core testing interface
converterManager.AddConverter <byte[], IStorageQueueMessage, QueueAttribute>(ConvertByteArrayToCloudQueueMessage);
converterManager.AddConverter <IStorageQueueMessage, byte[]>(ConvertCloudQueueMessageToByteArray);
converterManager.AddConverter <object, JObject, QueueAttribute>(SerializeToJobject);
converterManager.AddConverter <string, IStorageQueueMessage, QueueAttribute>(ConvertStringToCloudQueueMessage);
converterManager.AddConverter <IStorageQueueMessage, string>(ConvertCloudQueueMessageToString);
converterManager.AddConverter <CloudQueueMessage, IStorageQueueMessage>(ConvertToStorageQueueMessage);
var bindingFactory = new BindingFactory(nameResolver, converterManager);
var bindAsyncCollector = bindingFactory.BindToCollector <QueueAttribute, IStorageQueueMessage>(BuildFromQueueAttribute)
.SetPostResolveHook <QueueAttribute>(ToWriteParameterDescriptorForCollector, CollectAttributeInfo);
var bindClient = bindingFactory.BindToInput <QueueAttribute, IStorageQueue>(typeof(QueueBuilder))
.SetPostResolveHook <QueueAttribute>(ToReadWriteParameterDescriptorForCollector, CollectAttributeInfo);
var bindSdkClient = bindingFactory.BindToInput <QueueAttribute, CloudQueue>(typeof(QueueBuilder))
.SetPostResolveHook <QueueAttribute>(ToReadWriteParameterDescriptorForCollector, CollectAttributeInfo);
var bindingProvider = new GenericCompositeBindingProvider <QueueAttribute>(
ValidateQueueAttribute, nameResolver, bindClient, bindSdkClient, bindAsyncCollector);
return(bindingProvider);
}
private static void AddConverterBuilder <TSource, TDestination, TAttribute>(
this IConverterManager converterManager,
PatternMatcher patternMatcher)
where TAttribute : Attribute
{
if (converterManager == null)
{
throw new ArgumentNullException("converterManager");
}
converterManager.AddConverter <TSource, TDestination, TAttribute>((typeSource, typeDest) =>
{
var converter = patternMatcher.TryGetConverterFunc(typeSource, typeDest);
return(converter);
});
}
public void Initialize(ExtensionConfigContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// Register our extension binding providers
context.Config.RegisterBindingExtensions(
new SampleAttributeBindingProvider(),
new SampleTriggerAttributeBindingProvider());
IConverterManager converterManager = context.Config.GetService <IConverterManager>();
converterManager.AddConverter <CloudTable, Table <OpenType>, TableAttribute>(typeof(CustomTableBindingConverter <>));
}
public void Table_IfBoundToCustomTableBindingExtension_BindsCorrectly()
{
// Arrange
IStorageAccount account = CreateFakeStorageAccount();
var config = TestHelpers.NewConfig(typeof(CustomTableBindingExtensionProgram), account);
IConverterManager cm = config.GetService <IConverterManager>();
// Add a rule for binding CloudTable --> CustomTableBinding<TEntity>
cm.AddConverter <CloudTable, CustomTableBinding <OpenType>, TableAttribute>(
typeof(CustomTableBindingConverter <>));
var host = new TestJobHost <CustomTableBindingExtensionProgram>(config);
host.Call("Run"); // Act
// Assert
Assert.Equal(TableName, CustomTableBinding <Poco> .Table.Name);
Assert.True(CustomTableBinding <Poco> .AddInvoked);
Assert.True(CustomTableBinding <Poco> .DeleteInvoked);
}
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);
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)
.SetPostResolveHook(ToWriteParameterDescriptorForCollector)
.BindToCollector <IStorageQueueMessage>(BuildFromQueueAttribute);
binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector)
.BindToInput <IStorageQueue>(builder);
binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector)
.BindToInput <CloudQueue>(builder);
binding.SetPostResolveHook(ToReadWriteParameterDescriptorForCollector)
.BindToInput <CloudQueue>(builder);
IConverterManager converterManager = context.Config.ConverterManager;
converterManager.AddConverter <object, JObject, QueueAttribute>(SerializeToJobject);
}
public static IBindingProvider Build(INameResolver nameResolver, IConverterManager converterManager, IStorageAccountProvider accountProvider, IExtensionRegistry extensions)
{
var original = new TableAttributeBindingProvider(nameResolver, accountProvider, extensions);
converterManager.AddConverter <JObject, ITableEntity, TableAttribute>(original.JObjectToTableEntityConverterFunc);
var bindingFactory = new BindingFactory(nameResolver, converterManager);
var bindAsyncCollector = bindingFactory.BindToAsyncCollector <TableAttribute, ITableEntity>(original.BuildFromTableAttribute, null, original.CollectAttributeInfo);
var bindToJobject = bindingFactory.BindToExactAsyncType <TableAttribute, JObject>(original.BuildJObject, null, original.CollectAttributeInfo);
var bindToJArray = bindingFactory.BindToExactAsyncType <TableAttribute, JArray>(original.BuildJArray, null, original.CollectAttributeInfo);
// Filter to just support JObject, and use legacy bindings for everything else.
// Once we have ITableEntity converters for pocos, we can remove the filter.
// https://github.com/Azure/azure-webjobs-sdk/issues/887
bindAsyncCollector = bindingFactory.AddFilter <TableAttribute>(
(attr, type) => (type == typeof(IAsyncCollector <JObject>) || type == typeof(ICollector <JObject>)),
bindAsyncCollector);
var bindingProvider = new GenericCompositeBindingProvider <TableAttribute>(
new IBindingProvider[] { bindToJArray, bindToJobject, bindAsyncCollector, original });
return(bindingProvider);
}
static void AddItem2ByteConverter(IConverterManager cm)
{
cm.AddConverter <FakeQueueData, byte>(msg => msg.Byte);
}
static void AddItem2ByteArrayConverter(IConverterManager cm)
{
cm.AddConverter <FakeQueueData, byte[]>(msg => System.Text.Encoding.UTF8.GetBytes(msg.Message));
}
