/// <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)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// apply at eventProcessorOptions level (maxBatchSize, prefetchCount)
context.ApplyConfig(_options, "eventHub");
// apply at config level (batchCheckpointFrequency)
context.ApplyConfig(this, "eventHub");
_defaultStorageString = context.Config.StorageConnectionString;
context
.AddConverter <string, EventData>(ConvertString2EventData)
.AddConverter <EventData, string>(ConvertEventData2String)
.AddConverter <byte[], EventData>(ConvertBytes2EventData)
.AddConverter <EventData, byte[]>(ConvertEventData2Bytes)
.AddOpenConverter <OpenType.Poco, EventData>(ConvertPocoToEventData);
// register our trigger binding provider
INameResolver nameResolver = context.Config.NameResolver;
IConverterManager cm = context.Config.GetService <IConverterManager>();
var triggerBindingProvider = new EventHubTriggerAttributeBindingProvider(nameResolver, cm, this, context.Config.LoggerFactory);
context.AddBindingRule <EventHubTriggerAttribute>()
.BindToTrigger(triggerBindingProvider);
// register our binding provider
context.AddBindingRule <EventHubAttribute>()
.BindToCollector(BuildFromAttribute);
}
private static bool HasConverterWorker <TAttribute, TSrc, TDest>(IConverterManager converterManager)
where TAttribute : Attribute
{
var func = converterManager.GetConverter <TSrc, TDest, TAttribute>();
return(func != null);
}
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);
}
/// <summary>
/// Creates a binding that binds to an <see cref="IAsyncCollector{T}"/> with the specified argument type. Allows for a binding
/// to be generated for any POCO type.
/// </summary>
/// <param name="parameter">The ParameterInfo for the binding</param>
/// <param name="collectorGenericType">The generic type that must implement <see cref="IAsyncCollector{T}"/> and have a public constructor with at most one parameter.</param>
/// <param name="collectorGenericArgumentType">The generic argument type for the <see cref="IAsyncCollector{T}"/></param>
/// <param name="converterManager">A converter manager to pass along.</param>
/// <param name="invokeStringBinder">A <see cref="Func{T, TContext}"/> that returns the TContext to be used by the <see cref="IAsyncCollector{T}"/></param>
/// <returns></returns>
public static IBinding BindGenericCollector <TContext>(ParameterInfo parameter, Type collectorGenericType, Type collectorGenericArgumentType,
IConverterManager converterManager, Func <string, TContext> invokeStringBinder)
{
if (collectorGenericType == null)
{
throw new ArgumentNullException("collectorGenericType");
}
if (!collectorGenericType.IsGenericTypeDefinition)
{
throw new ArgumentException("The parameter 'collectorGenericType' must be a generic type definition.");
}
if (collectorGenericType.GetInterface(typeof(IAsyncCollector <>).Name) == null)
{
throw new ArgumentException("The Type specified by parameter 'collectorGenericType' must implement IAsyncCollector<T>.");
}
Type asyncCollectorInterfaceType = typeof(IAsyncCollector <>).MakeGenericType(collectorGenericArgumentType);
Type actualCollectorType = collectorGenericType.MakeGenericType(collectorGenericArgumentType);
// Create a delegate to pass as the builder func to BindCollector
Type funcType = typeof(Func <, ,>).MakeGenericType(typeof(object), typeof(ValueBindingContext), asyncCollectorInterfaceType);
MethodInfo getCollector = typeof(BindingFactory).GetMethod("GetCollector", BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(actualCollectorType, collectorGenericArgumentType);
var del = Delegate.CreateDelegate(funcType, getCollector);
// Create the method and parameters.
MethodInfo bindCollectorMethod = typeof(BindingFactory).GetMethod("BindCollector").MakeGenericMethod(collectorGenericArgumentType, typeof(TContext));
object[] parameters = new object[] { parameter, converterManager, del, null, invokeStringBinder };
return(bindCollectorMethod.Invoke(null, parameters) as IBinding);
}
public void Initialize(ExtensionConfigContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
INameResolver nameResolver = context.Config.GetService <INameResolver>();
_defaultAccountSid = nameResolver.Resolve(AzureWebJobsTwilioAccountSidKeyName);
_defaultAuthToken = nameResolver.Resolve(AzureWebJobsTwilioAccountAuthTokenName);
IConverterManager converterManager = context.Config.GetService <IConverterManager>();
converterManager.AddConverter <JObject, SMSMessage>(CreateSmsMessage);
BindingFactory factory = new BindingFactory(nameResolver, converterManager);
IBindingProvider outputProvider = factory.BindToAsyncCollector <TwilioSmsAttribute, SMSMessage>((attr) =>
{
return(new TwilioSmsMessageAsyncCollector(CreateContext(attr)));
});
IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();
extensions.RegisterBindingRules <TwilioSmsAttribute>(ValidateBinding, nameResolver, outputProvider);
}
public 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 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);
}
// 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);
}
/// <inheritdoc />
public void Initialize(ExtensionConfigContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
INameResolver nameResolver = context.Config.GetService <INameResolver>();
IConverterManager converterManager = context.Config.GetService <IConverterManager>();
BindingFactory factory = new BindingFactory(nameResolver, converterManager);
IBindingProvider outputProvider = factory.BindToGenericAsyncCollector <MobileTableAttribute>(BindForOutput, ThrowIfInvalidOutputItemType);
IBindingProvider clientProvider = factory.BindToExactType <MobileTableAttribute, IMobileServiceClient>(BindForClient);
IBindingProvider queryProvider = factory.BindToGenericItem <MobileTableAttribute>(BindForQueryAsync);
queryProvider = factory.AddFilter <MobileTableAttribute>(IsQueryType, queryProvider);
IBindingProvider jObjectTableProvider = factory.BindToExactType <MobileTableAttribute, IMobileServiceTable>(BindForTable);
IBindingProvider tableProvider = factory.BindToGenericItem <MobileTableAttribute>(BindForTableAsync);
tableProvider = factory.AddFilter <MobileTableAttribute>(IsTableType, tableProvider);
IBindingProvider itemProvider = factory.BindToGenericValueProvider <MobileTableAttribute>(BindForItemAsync);
itemProvider = factory.AddFilter <MobileTableAttribute>(IsItemType, itemProvider);
IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();
extensions.RegisterBindingRules <MobileTableAttribute>(ValidateMobileAppUri, nameResolver, outputProvider, clientProvider, jObjectTableProvider, queryProvider, tableProvider, itemProvider);
}
// Bind a T.
private static SimpleTriggerArgumentBinding <TMessage, TTriggerValue> GetTriggerArgumentElementBinding <TMessage, TTriggerValue>(
Type elementType,
ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy,
IConverterManager converterManager)
{
var argumentBinding = GetDirectTriggerBinding <TMessage, TTriggerValue>(elementType, bindingStrategy, converterManager);
if (argumentBinding != null)
{
// Exact match in converter manager. Always takes precedence.
return(argumentBinding);
}
if (elementType == typeof(TMessage))
{
return(new SimpleTriggerArgumentBinding <TMessage, TTriggerValue>(bindingStrategy, converterManager));
}
if (elementType == typeof(string))
{
return(new StringTriggerArgumentBinding <TMessage, TTriggerValue>(bindingStrategy, converterManager));
}
else
{
// Catch-all.
// Default, assume a Poco
return(new PocoTriggerArgumentBinding <TMessage, TTriggerValue>(bindingStrategy, converterManager, elementType));
}
}
public FirebaseCloudMessageTriggerAttributeBindingProvider(INameResolver nameResolver, IConverterManager converterManager, FirebaseCloudMessagingConfiguration configuration, ILoggerFactory loggerFactory)
{
_nameResolver = nameResolver;
_converterManager = converterManager;
_configuration = configuration;
_logger = loggerFactory.CreateLogger(LogCategories.CreateTriggerCategory("FirebaseCloudMessaging"));
}
public static void RegisterBindingRules(JobHostConfiguration hostConfig)
{
IConverterManager cm = hostConfig.ConverterManager;
cm.AddConverter <DurableActivityContext, string>(ActivityContextToString);
cm.AddConverter <DurableActivityContext, JObject>(ActivityContextToJObject);
}
void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
_defaultStorageString = context.Config.StorageConnectionString;
context
.AddConverter <string, EventData>(ConvertString2EventData)
.AddConverter <EventData, string>(ConvertEventData2String)
.AddConverter <byte[], EventData>(ConvertBytes2EventData)
.AddConverter <EventData, byte[]>(ConvertEventData2Bytes);
// register our trigger binding provider
INameResolver nameResolver = context.Config.NameResolver;
IConverterManager cm = context.Config.GetService <IConverterManager>();
var triggerBindingProvider = new EventHubTriggerAttributeBindingProvider(nameResolver, cm, this);
context.AddBindingRule <EventHubTriggerAttribute>()
.BindToTrigger(triggerBindingProvider);
// register our binding provider
context.AddBindingRule <EventHubAttribute>()
.BindToCollector(BuildFromAttribute);
}
/// <summary>
/// Bind a parameter to an IAsyncCollector. Use this for things that have discrete output items (like sending messages or writing table rows)
/// This will add additional adapters to connect the user's parameter type to an IAsyncCollector.
/// </summary>
/// <typeparam name="TMessage">The 'core type' for the IAsyncCollector.</typeparam>
/// <typeparam name="TTriggerValue">The type of the trigger object to pass to the listener.</typeparam>
/// <param name="bindingStrategy">A strategy object that describes how to do the binding</param>
/// <param name="parameter">The user's parameter being bound to</param>
/// <param name="converterManager">The converter manager, used to convert between the user parameter's type and the underlying native types used by the trigger strategy</param>
/// <param name="createListener">A function to create the underlying listener for this parameter</param>
/// <returns>A trigger binding</returns>
public static ITriggerBinding GetTriggerBinding <TMessage, TTriggerValue>(
ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy,
ParameterInfo parameter,
IConverterManager converterManager,
Func <ListenerFactoryContext, bool, Task <IListener> > createListener)
{
if (bindingStrategy == null)
{
throw new ArgumentNullException("bindingStrategy");
}
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
bool singleDispatch;
var argumentBinding = BindingFactoryHelpers.GetTriggerArgumentBinding(bindingStrategy, parameter, converterManager, out singleDispatch);
var parameterDescriptor = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = singleDispatch ? "message" : "messages"
}
};
ITriggerBinding binding = new StrategyTriggerBinding <TMessage, TTriggerValue>(
bindingStrategy, argumentBinding, createListener, parameterDescriptor, singleDispatch);
return(binding);
}
private static Func <TAttribute, IValueProvider> BuildICollectorArgument <TAttribute, TMessage, TMessageSrc>(
IConverterManager cm,
Func <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute,
AttributeCloner <TAttribute> cloner)
where TAttribute : Attribute
{
// Other
Func <TMessageSrc, TAttribute, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage, TAttribute>();
if (convert == null)
{
ThrowMissingConversionError(typeof(TMessageSrc));
}
Func <TAttribute, IValueProvider> argumentBuilder = (attrResolved) =>
{
IAsyncCollector <TMessage> raw = buildFromAttribute(attrResolved);
IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage, TAttribute>(
raw, convert, attrResolved);
ICollector <TMessageSrc> obj2 = new SyncAsyncCollectorAdapter <TMessageSrc>(obj);
string invokeString = cloner.GetInvokeString(attrResolved);
return(new AsyncCollectorValueProvider <ICollector <TMessageSrc>, TMessage>(obj2, raw, invokeString));
};
return(argumentBuilder);
}
public JobHostMetadataProvider(IFunctionIndexProvider functionIndexProvider, IExtensionRegistry extensionRegistry, IBindingProvider bindingProvider, IConverterManager converter)
{
_functionIndexProvider = functionIndexProvider;
_extensionRegistry = extensionRegistry;
_bindingProvider = bindingProvider;
_converter = converter;
}
// Bind a trigger argument to various parameter types.
// Handles either T or T[],
internal static ITriggerDataArgumentBinding <TTriggerValue> GetTriggerArgumentBinding <TMessage, TTriggerValue>(
ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy,
ParameterInfo parameter,
IConverterManager converterManager,
out bool singleDispatch)
{
ITriggerDataArgumentBinding <TTriggerValue> argumentBinding = null;
if (parameter.ParameterType.IsArray)
{
// dispatch the entire batch in a single call.
singleDispatch = false;
var elementType = parameter.ParameterType.GetElementType();
var innerArgumentBinding = GetTriggerArgumentElementBinding <TMessage, TTriggerValue>(elementType, bindingStrategy, converterManager);
argumentBinding = new ArrayTriggerArgumentBinding <TMessage, TTriggerValue>(bindingStrategy, innerArgumentBinding, converterManager);
return(argumentBinding);
}
else
{
// Dispatch each item one at a time
singleDispatch = true;
var elementType = parameter.ParameterType;
argumentBinding = GetTriggerArgumentElementBinding <TMessage, TTriggerValue>(elementType, bindingStrategy, converterManager);
return(argumentBinding);
}
}
internal FluentBindingRule(IConfiguration configuration, INameResolver nameResolver, IConverterManager converterManager, IExtensionRegistry extensionRegistry)
{
_configuration = configuration;
_nameResolver = nameResolver;
_converterManager = converterManager;
_extensionRegistry = extensionRegistry;
}
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 ArrayTriggerArgumentBinding(
ITriggerBindingStrategy <TMessage, TTriggerValue> hooks,
SimpleTriggerArgumentBinding <TMessage, TTriggerValue> innerBinding,
IConverterManager converterManager) : base(hooks, converterManager, false)
{
this._innerBinding = innerBinding;
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
IConverterManager cm = this.parent.extensionContext.Config.ConverterManager;
MethodInfo getConverterMethod = cm.GetType().GetMethod(nameof(cm.GetConverter));
getConverterMethod = getConverterMethod.MakeGenericMethod(
typeof(DurableActivityContext),
this.parameterInfo.ParameterType,
typeof(ActivityTriggerAttribute));
Delegate d = (Delegate)getConverterMethod.Invoke(cm, null);
object convertedValue = d.DynamicInvoke(value, this.attribute, context);
var valueProvider = new ObjectValueProvider(
convertedValue,
this.parameterInfo.ParameterType);
DurableActivityContext activityContext = (DurableActivityContext)value;
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)
{
{ nameof(DurableActivityContext.InstanceId), activityContext.InstanceId }
};
var triggerData = new TriggerData(valueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
/// <inheritdoc />
public void Initialize(ExtensionConfigContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
INameResolver nameResolver = context.Config.GetService <INameResolver>();
IConverterManager converterManager = context.Config.GetService <IConverterManager>();
// Use this if there is no other connection string set.
_defaultConnectionString = nameResolver.Resolve(AzureWebJobsDocumentDBConnectionStringName);
BindingFactory factory = new BindingFactory(nameResolver, converterManager);
IBindingProvider outputProvider = factory.BindToGenericAsyncCollector <DocumentDBAttribute>((attr, t) => BindForOutput(attr, t, context.Trace));
IBindingProvider clientProvider = factory.BindToExactType <DocumentDBAttribute, DocumentClient>(BindForClient);
IBindingProvider itemProvider = factory.BindToGenericValueProvider <DocumentDBAttribute>((attr, t) => BindForItemAsync(attr, t, context.Trace));
IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();
extensions.RegisterBindingRules <DocumentDBAttribute>(ValidateConnection, nameResolver, outputProvider, clientProvider, itemProvider);
}
/// <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);
}
public SimpleTriggerArgumentBinding(ITriggerBindingStrategy <TMessage, TTriggerValue> hooks, IConverterManager converterManager)
{
this._hooks = hooks;
this.Contract = Hooks.GetStaticBindingContract();
this.ElementType = typeof(TMessage);
_converterManager = converterManager;
}
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);
}
void IExtensionConfigProvider.Initialize(ExtensionConfigContext context)
{
var rule = context.AddBindingRule <FakeQueueAttribute>();
context.AddConverter <string, FakeQueueData>(x => new FakeQueueData {
Message = x
});
context.AddConverter <FakeQueueData, string>(msg => msg.Message);
context.AddConverter <OtherFakeQueueData, FakeQueueData>(OtherFakeQueueData.ToEvent);
rule.AddOpenConverter <OpenType.Poco, FakeQueueData>(ConvertPocoToFakeQueueMessage);
INameResolver nameResolver = context.Config.GetService <INameResolver>();
IConverterManager cm = context.Config.GetService <IConverterManager>();
if (this.SetConverters != null)
{
this.SetConverters(context);
}
IExtensionRegistry extensions = context.Config.GetService <IExtensionRegistry>();
// Binds [FakeQueue] --> IAsyncCollector<FakeQueueData>
rule.BindToCollector <FakeQueueData>(BuildFromAttr);
// Binds [FakeQueue] --> FakeQueueClient
rule.BindToInput <FakeQueueClient>(this);
var triggerBindingProvider = new FakeQueueTriggerBindingProvider(this, cm);
extensions.RegisterExtension <ITriggerBindingProvider>(triggerBindingProvider);
}
public 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 ExtensionConfigContext(INameResolver nameResolver, IConverterManager converterManager, IWebHookProvider webHookProvider, IExtensionRegistry extensionRegistry)
{
_converterManager = converterManager;
_webHookProvider = webHookProvider;
_extensionRegistry = extensionRegistry;
_nameResolver = nameResolver;
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
var activityContext = (DurableActivityContext)value;
Type destinationType = this.parameterInfo.ParameterType;
object convertedValue;
if (destinationType == typeof(object))
{
// Straight assignment
convertedValue = value;
}
else
{
// Try using the converter manager
IConverterManager cm = this.parent.extensionContext.Config.ConverterManager;
MethodInfo getConverterMethod = cm.GetType().GetMethod(nameof(cm.GetConverter));
getConverterMethod = getConverterMethod.MakeGenericMethod(
typeof(DurableActivityContext),
destinationType,
typeof(ActivityTriggerAttribute));
Delegate d = (Delegate)getConverterMethod.Invoke(cm, null);
if (d != null)
{
convertedValue = d.DynamicInvoke(value, this.attribute, context);
}
else if (!destinationType.IsInterface)
{
MethodInfo getInputMethod = activityContext.GetType()
.GetMethod(nameof(activityContext.GetInput))
.MakeGenericMethod(destinationType);
convertedValue = getInputMethod.Invoke(activityContext, null);
}
else
{
throw new ArgumentException(
$"Activity triggers cannot be bound to {destinationType}.",
this.parameterInfo.Name);
}
}
var inputValueProvider = new ObjectValueProvider(
convertedValue,
this.parameterInfo.ParameterType);
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)
{
{ nameof(DurableActivityContext.InstanceId), activityContext.InstanceId },
};
var triggerData = new TriggerData(inputValueProvider, bindingData);
triggerData.ReturnValueProvider = new ActivityTriggerReturnValueBinder(
activityContext,
this.parameterInfo.ParameterType);
return(Task.FromResult <ITriggerData>(triggerData));
}
public EventHubTriggerAttributeBindingProvider(
INameResolver nameResolver,
IConverterManager converterManager,
IEventHubProvider eventHubConfig)
{
this._nameResolver = nameResolver;
this._converterManager = converterManager;
this._eventHubConfig = eventHubConfig;
}
public FakeQueueBindingProvider(FakeQueueClient client, IConverterManager converterManager)
{
_client = client;
_converterManager = converterManager;
}
