/// <summary>
/// Create the <see cref="ITriggerBinding"/> (being the <see cref="ResilientEventHubBinding"/>).
/// </summary>
/// <param name="context">The <see cref="TriggerBindingProviderContext"/>.</param>
/// <returns></returns>
public Task <ITriggerBinding?> TryCreateAsync(TriggerBindingProviderContext context)
{
// Get the required attribuite.
var att = context.Parameter.GetCustomAttribute <ResilientEventHubTriggerAttribute>(false);
if (att == null)
{
return(Task.FromResult <ITriggerBinding?>(null));
}
// Resolve the attribute parameters.
var resolvedEventHubName = _nameResolver.ResolveWholeString(att.EventHubName);
var resolvedConsumerGroup = _nameResolver.ResolveWholeString(att.ConsumerGroup ?? PartitionReceiver.DefaultConsumerGroupName);
if (!string.IsNullOrWhiteSpace(att.Connection))
{
var connectionString = _config.GetConnectionStringOrSetting(_nameResolver.ResolveWholeString(att.Connection));
_options.Value.AddEventHub(resolvedEventHubName, connectionString);
}
// Capture the name of the function being executed.
_options.Value.FunctionName = context.Parameter.Member.GetCustomAttribute <FunctionNameAttribute>().Name;
_options.Value.FunctionType = context.Parameter.Member.DeclaringType.FullName + "." + context.Parameter.Member.Name;
// Create the event hub processor.
var host = _options.Value.GetEventProcessorHost(_config, resolvedEventHubName, resolvedConsumerGroup);
// Create and return the binding.
return(Task.FromResult <ITriggerBinding?>(new ResilientEventHubBinding(host, context.Parameter, _options.Value, _config, _logger)));
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ParameterInfo parameter = context.Parameter;
var attribute = TypeUtility.GetResolvedAttribute <ServiceBusAttribute>(parameter);
if (attribute == null)
{
return(Task.FromResult <IBinding>(null));
}
string queueOrTopicName = _nameResolver.ResolveWholeString(attribute.QueueOrTopicName);
IBindableServiceBusPath path = BindableServiceBusPath.Create(queueOrTopicName);
ValidateContractCompatibility(path, context.BindingDataContract);
IArgumentBinding <ServiceBusEntity> argumentBinding = _innerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ServiceBus to type '{0}'.", parameter.ParameterType));
}
attribute.Connection = _nameResolver.ResolveWholeString(attribute.Connection);
IBinding binding = new ServiceBusBinding(parameter.Name, argumentBinding, path, attribute, _messagingProvider, _clientFactory);
return(Task.FromResult <IBinding>(binding));
}
internal SignalRTriggerAttribute GetParameterResolvedAttribute(SignalRTriggerAttribute attribute, ParameterInfo parameterInfo)
{
//TODO: AutoResolve more properties in attribute
var hubName = attribute.HubName;
var category = attribute.Category;
var @event = attribute.Event;
var parameterNames = attribute.ParameterNames ?? Array.Empty <string>();
var connectionStringSetting = attribute.ConnectionStringSetting;
// We have two models for C#, one is function based model which also work in multiple language
// Another one is class based model, which is highly close to SignalR itself but must keep some conventions.
var method = (MethodInfo)parameterInfo.Member;
var declaredType = method.DeclaringType;
string[] parameterNamesFromAttribute;
if (declaredType != null && IsServerlessHub(declaredType))
{
// Class based model
if (!string.IsNullOrEmpty(hubName) ||
!string.IsNullOrEmpty(category) ||
!string.IsNullOrEmpty(@event) ||
parameterNames.Length != 0)
{
throw new ArgumentException($"{nameof(SignalRTriggerAttribute)} must use parameterless constructor in class based model.");
}
parameterNamesFromAttribute = method.GetParameters().Where(IsLegalClassBasedParameter).Select(p => p.Name).ToArray();
hubName = declaredType.Name;
category = GetCategoryFromMethodName(method.Name);
@event = GetEventFromMethodName(method.Name, category);
connectionStringSetting = declaredType.GetCustomAttribute <SignalRConnectionAttribute>()?.Connection ?? attribute.ConnectionStringSetting;
}
else
{
parameterNamesFromAttribute = method.GetParameters().
Where(p => p.GetCustomAttribute <SignalRParameterAttribute>(false) != null).
Select(p => p.Name).ToArray();
if (parameterNamesFromAttribute.Length != 0 && parameterNames.Length != 0)
{
throw new InvalidOperationException(
$"{nameof(SignalRTriggerAttribute)}.{nameof(SignalRTriggerAttribute.ParameterNames)} and {nameof(SignalRParameterAttribute)} can not be set in the same Function.");
}
// If we aren't using the class-based model, make sure we resolve binding expressions for attribute properties here.
hubName = _nameResolver.ResolveWholeString(hubName);
category = _nameResolver.ResolveWholeString(category);
@event = _nameResolver.ResolveWholeString(@event);
}
parameterNames = parameterNamesFromAttribute.Length != 0
? parameterNamesFromAttribute
: parameterNames;
return(new SignalRTriggerAttribute(hubName, category, @event, parameterNames)
{
ConnectionStringSetting = connectionStringSetting
});
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ParameterInfo parameter = context.Parameter;
EventHubTriggerAttribute attribute = parameter.GetCustomAttribute <EventHubTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
string resolvedEventHubName = _nameResolver.ResolveWholeString(attribute.EventHubName);
string consumerGroup = attribute.ConsumerGroup ?? EventHubConsumerClient.DefaultConsumerGroupName;
string resolvedConsumerGroup = _nameResolver.ResolveWholeString(consumerGroup);
if (!string.IsNullOrWhiteSpace(attribute.Connection))
{
var connection = _nameResolver.ResolveWholeString(attribute.Connection);
var connectionString = _config.GetConnectionStringOrSetting(connection);
_options.Value.AddReceiver(resolvedEventHubName, connectionString);
}
var eventHostListener = _options.Value.GetEventProcessorHost(resolvedEventHubName, resolvedConsumerGroup);
var checkpointStoreConnectionString = _options.Value.GetCheckpointStoreConnectionString(_config, resolvedEventHubName);
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
var checkpointStore = new BlobsCheckpointStore(
new BlobContainerClient(checkpointStoreConnectionString, _options.Value.LeaseContainerName),
_options.Value.EventProcessorOptions.RetryOptions.ToRetryPolicy(),
factoryContext.Descriptor.Id,
_logger);
IListener listener = new EventHubListener(
factoryContext.Descriptor.Id,
factoryContext.Executor,
eventHostListener,
singleDispatch,
() => _options.Value.GetEventHubConsumerClient(resolvedEventHubName, consumerGroup),
checkpointStore,
_options.Value,
_logger);
return(Task.FromResult(listener));
};
#pragma warning disable 618
ITriggerBinding binding = BindingFactory.GetTriggerBinding(new EventHubTriggerBindingStrategy(), parameter, _converterManager, createListener);
#pragma warning restore 618
return(Task.FromResult(binding));
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
EventHubTriggerAttribute attribute = parameter.GetCustomAttribute <EventHubTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
string resolvedEventHubName = _nameResolver.ResolveWholeString(attribute.EventHubName);
string consumerGroup = attribute.ConsumerGroup ?? PartitionReceiver.DefaultConsumerGroupName;
string resolvedConsumerGroup = _nameResolver.ResolveWholeString(consumerGroup);
string connectionString = null;
if (!string.IsNullOrWhiteSpace(attribute.Connection))
{
attribute.Connection = _nameResolver.ResolveWholeString(attribute.Connection);
connectionString = _config.GetConnectionStringOrSetting(attribute.Connection);
_options.Value.AddReceiver(resolvedEventHubName, connectionString);
}
var eventHostListener = _options.Value.GetEventProcessorHost(_config, resolvedEventHubName, resolvedConsumerGroup);
string storageConnectionString = _config.GetWebJobsConnectionString(ConnectionStringNames.Storage);
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new EventHubListener(
factoryContext.Descriptor.Id,
resolvedEventHubName,
resolvedConsumerGroup,
connectionString,
storageConnectionString,
factoryContext.Executor,
eventHostListener,
singleDispatch,
_options.Value,
_logger);
return(Task.FromResult(listener));
};
ITriggerBinding binding = BindingFactory.GetTriggerBinding(new EventHubTriggerBindingStrategy(), parameter, _converterManager, createListener);
return(Task.FromResult <ITriggerBinding>(binding));
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ParameterInfo parameter = context.Parameter;
var attribute = TypeUtility.GetResolvedAttribute <ServiceBusTriggerAttribute>(parameter);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
attribute.Connection = _nameResolver.ResolveWholeString(attribute.Connection);
string entityPath;
ServiceBusEntityType serviceBusEntityType;
if (attribute.QueueName != null)
{
var queueName = _nameResolver.ResolveWholeString(attribute.QueueName);
entityPath = queueName;
serviceBusEntityType = ServiceBusEntityType.Queue;
}
else
{
var topicName = _nameResolver.ResolveWholeString(attribute.TopicName);
var subscriptionName = _nameResolver.ResolveWholeString(attribute.SubscriptionName);
entityPath = EntityNameFormatter.FormatSubscriptionPath(topicName, subscriptionName);
serviceBusEntityType = ServiceBusEntityType.Topic;
}
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
var autoCompleteMessagesOptionEvaluatedValue = GetAutoCompleteMessagesOptionToUse(attribute, factoryContext.Descriptor.ShortName);
IListener listener = new ServiceBusListener(factoryContext.Descriptor.Id, serviceBusEntityType, entityPath, attribute.IsSessionsEnabled, autoCompleteMessagesOptionEvaluatedValue, factoryContext.Executor, _options, attribute.Connection, _messagingProvider, _loggerFactory, singleDispatch, _clientFactory, _concurrencyManager);
return(Task.FromResult(listener));
};
#pragma warning disable 618
ITriggerBinding binding = BindingFactory.GetTriggerBinding(new ServiceBusTriggerBindingStrategy(), parameter, _converterManager, createListener);
#pragma warning restore 618
return(Task.FromResult <ITriggerBinding>(binding));
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ParameterInfo parameter = context.Parameter;
FtpAttribute attribute = parameter.GetCustomAttribute <FtpAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <IBinding>(null));
}
string path = attribute.Path;
if (_nameResolver != null)
{
path = _nameResolver.ResolveWholeString(path);
}
BindingTemplate bindingTemplate = BindingTemplate.FromString(path);
bindingTemplate.ValidateContractCompatibility(context.BindingDataContract);
IEnumerable <Type> types = StreamValueBinder.GetSupportedTypes(FileAccess.Read);
if (!ValueBinder.MatchParameterType(context.Parameter, types))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind FtpAttribute to type '{0}'.", parameter.ParameterType));
}
return(Task.FromResult <IBinding>(new FtpBinding(_config, parameter, bindingTemplate)));
}
public override Collection <Attribute> GetAttributes()
{
Collection <Attribute> attributes = new Collection <Attribute>();
string schedule = Context.GetMetadataValue <string>("schedule");
bool runOnStartup = Context.GetMetadataValue <bool>("runOnStartup");
bool useMonitor = Context.GetMetadataValue <bool>("useMonitor", true);
if (_environment.IsWindowsConsumption())
{
// pre-resolve app setting specifiers
schedule = _nameResolver.ResolveWholeString(schedule);
var options = new CrontabSchedule.ParseOptions()
{
IncludingSeconds = true
};
if (CrontabSchedule.TryParse(schedule, options) == null)
{
throw new ArgumentException(string.Format("'{0}' is not a valid CRON expression.", schedule));
}
}
attributes.Add(new TimerTriggerAttribute(schedule)
{
RunOnStartup = runOnStartup,
UseMonitor = useMonitor
});
return(attributes);
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
EventHubAttribute attribute = parameter.GetCustomAttribute <EventHubAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <IBinding>(null));
}
string name = attribute.EventHubName;
var resolvedName = _nameResolver.ResolveWholeString(name);
Func <string, EventHubClient> invokeStringBinder = (invokeString) => _eventHubConfig.GetEventHubClient(invokeString);
IBinding binding = BindingFactory.BindCollector <EventData, EventHubClient>(
parameter,
_converterManager,
(client, valueBindingContext) => new EventHubAsyncCollector(client),
resolvedName,
invokeStringBinder);
return(Task.FromResult(binding));
}
internal static bool IsDisabledBySetting(string settingName, MethodInfo method, INameResolver nameResolver)
{
if (nameResolver != null)
{
settingName = nameResolver.ResolveWholeString(settingName);
}
BindingTemplate bindingTemplate = BindingTemplate.FromString(settingName);
Dictionary <string, string> bindingData = new Dictionary <string, string>();
bindingData.Add("MethodName", string.Format(CultureInfo.InvariantCulture, "{0}.{1}", method.DeclaringType.Name, method.Name));
bindingData.Add("MethodShortName", method.Name);
settingName = bindingTemplate.Bind(bindingData);
// check the target setting and return false (disabled) if the value exists
// and is "falsey"
string value = ConfigurationUtility.GetSettingFromConfigOrEnvironment(settingName);
if (!string.IsNullOrEmpty(value) &&
(string.Compare(value, "1", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(value, "true", StringComparison.OrdinalIgnoreCase) == 0))
{
return(true);
}
return(false);
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
EventHubTriggerAttribute attribute = parameter.GetCustomAttribute <EventHubTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
string eventHubName = attribute.EventHubName;
string resolvedName = _nameResolver.ResolveWholeString(eventHubName);
var eventHostListener = _eventHubConfig.GetEventProcessorHost(resolvedName);
var options = _eventHubConfig.GetOptions();
var hooks = new EventHubTriggerBindingStrategy();
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new EventHubListener(factoryContext.Executor, eventHostListener, options, singleDispatch);
return(Task.FromResult(listener));
};
ITriggerBinding binding = BindingFactory.GetTriggerBinding <EventData, EventHubTriggerInput>(hooks, parameter, _converterManager, createListener);
return(Task.FromResult <ITriggerBinding>(binding));
}
internal static TimerSchedule Create(TimerTriggerAttribute attribute, INameResolver nameResolver)
{
TimerSchedule schedule = null;
if (!string.IsNullOrEmpty(attribute.ScheduleExpression))
{
string resolvedExpression = nameResolver.ResolveWholeString(attribute.ScheduleExpression);
CronSchedule cronSchedule = null;
if (CronSchedule.TryCreate(resolvedExpression, out cronSchedule))
{
schedule = cronSchedule;
DateTime[] nextOccurrences = cronSchedule.InnerSchedule.GetNextOccurrences(DateTime.Now, DateTime.Now + TimeSpan.FromMinutes(1)).ToArray();
if (nextOccurrences.Length > 1)
{
// if there is more than one occurrence due in the next minute,
// assume that this is a sub-minute constant schedule and disable
// persistence
attribute.UseMonitor = false;
}
else if (!attribute.UseMonitor.HasValue)
{
// if the user hasn't specified a value
// set to true
attribute.UseMonitor = true;
}
}
else
{
TimeSpan periodTimespan = TimeSpan.Parse(resolvedExpression);
schedule = new ConstantSchedule(periodTimespan);
if (periodTimespan.TotalMinutes < 1)
{
// for very frequent constant schedules, we want to disable persistence
attribute.UseMonitor = false;
}
else if (!attribute.UseMonitor.HasValue)
{
// if the user hasn't specified a value
// set to true
attribute.UseMonitor = true;
}
}
}
else
{
schedule = (TimerSchedule)Activator.CreateInstance(attribute.ScheduleType);
if (!attribute.UseMonitor.HasValue)
{
// if the user hasn't specified a value
// set to true
attribute.UseMonitor = true;
}
}
return(schedule);
}
private string NameResolveWholeStringRecursive(string name)
{
if (_nameResolver == null || String.IsNullOrWhiteSpace(name))
{
return(name);
}
string resolvedName = _nameResolver.ResolveWholeString(name);
while (false == String.IsNullOrWhiteSpace(resolvedName) && false == resolvedName.Equals(name, StringComparison.Ordinal))
{
name = resolvedName;
resolvedName = _nameResolver.ResolveWholeString(name);
}
return(resolvedName);
}
public string Resolve(string channelOrKey)
{
if (_nameResolver == null)
{
return(channelOrKey);
}
return(_nameResolver.ResolveWholeString(channelOrKey));
}
// AutoResolve
internal static BindingDataResolver GetTemplateResolver(string originalValue, AutoResolveAttribute attr, INameResolver nameResolver, PropertyInfo propInfo, BindingDataContract contract)
{
string resolvedValue = nameResolver.ResolveWholeString(originalValue);
var template = BindingTemplate.FromString(resolvedValue);
IResolutionPolicy policy = GetPolicy(attr.ResolutionPolicyType, propInfo);
template.ValidateContractCompatibility(contract);
return((newAttr, bindingData) => TemplateBind(policy, propInfo, newAttr, template, bindingData));
}
private static string Resolve(string value, INameResolver resolver)
{
if (resolver == null)
{
return(value);
}
return(resolver.ResolveWholeString(value));
}
private static string Resolve(string name, INameResolver nameResolver)
{
if (nameResolver == null)
{
return(name);
}
return(nameResolver.ResolveWholeString(name));
}
private string Resolve(string queueName)
{
if (_nameResolver == null)
{
return(queueName);
}
return(_nameResolver.ResolveWholeString(queueName));
}
private string Resolve(string blobName)
{
if (_nameResolver == null)
{
return(blobName);
}
return(_nameResolver.ResolveWholeString(blobName));
}
private static string NormalizeQueueName(QueueAttribute attribute, INameResolver nameResolver)
{
string queueName = attribute.QueueName;
if (nameResolver != null)
{
queueName = nameResolver.ResolveWholeString(queueName);
}
queueName = queueName.ToLowerInvariant(); // must be lowercase. coerce here to be nice.
return(queueName);
}
private static void ValidateContract(string value, INameResolver nameResolver, IReadOnlyDictionary <string, Type> contract)
{
if (!string.IsNullOrEmpty(value))
{
if (nameResolver != null)
{
value = nameResolver.ResolveWholeString(value);
}
BindingTemplate bindingTemplate = BindingTemplate.FromString(value, ignoreCase: true);
bindingTemplate.ValidateContractCompatibility(contract);
}
}
internal static string ResolveSecureSetting(this IConfiguration config, INameResolver nameResolver, string currentValue)
{
if (string.IsNullOrWhiteSpace(currentValue))
{
return(currentValue);
}
var resolved = nameResolver.ResolveWholeString(currentValue);
var resolvedFromConfig = config.GetConnectionStringOrSetting(resolved);
return(!string.IsNullOrEmpty(resolvedFromConfig) ? resolvedFromConfig : resolved);
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
EventHubTriggerAttribute attribute = parameter.GetCustomAttribute <EventHubTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
string resolvedEventHubName = _nameResolver.ResolveWholeString(attribute.EventHubName);
string consumerGroup = attribute.ConsumerGroup ?? EventHubConsumerGroup.DefaultGroupName;
string resolvedConsumerGroup = _nameResolver.ResolveWholeString(consumerGroup);
if (!string.IsNullOrWhiteSpace(attribute.Connection))
{
_eventHubConfig.AddReceiver(resolvedEventHubName, _nameResolver.Resolve(attribute.Connection));
}
var eventHostListener = _eventHubConfig.GetEventProcessorHost(resolvedEventHubName, resolvedConsumerGroup);
var options = _eventHubConfig.GetOptions();
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new EventHubListener(factoryContext.Executor, eventHostListener, options, singleDispatch);
return(Task.FromResult(listener));
};
ITriggerBinding binding = BindingFactory.GetTriggerBinding(new EventHubTriggerBindingStrategy(), parameter, _converterManager, createListener);
return(Task.FromResult <ITriggerBinding>(binding));
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
var attribute = context.Parameter.GetCustomAttribute <DiscordMessageTriggerAttribute>();
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
var binding = new DiscordMessageTriggerBinding(context.Parameter.Name, resolver.ResolveWholeString(attribute.Token));
return(Task.FromResult <ITriggerBinding>(binding));
}
public override Collection <Attribute> GetAttributes()
{
Collection <Attribute> attributes = new Collection <Attribute>();
string eventHubName = Context.GetMetadataValue <string>("path");
if (!string.IsNullOrEmpty(eventHubName))
{
eventHubName = _nameResolver.ResolveWholeString(eventHubName);
}
string connectionString = Context.GetMetadataValue <string>("connection");
if (!string.IsNullOrEmpty(connectionString))
{
connectionString = _nameResolver.Resolve(connectionString);
}
if (Context.IsTrigger)
{
var attribute = new EventHubTriggerAttribute(eventHubName);
string consumerGroup = Context.GetMetadataValue <string>("consumerGroup");
if (consumerGroup != null)
{
consumerGroup = _nameResolver.ResolveWholeString(consumerGroup);
attribute.ConsumerGroup = consumerGroup;
}
attributes.Add(attribute);
_eventHubConfiguration.AddReceiver(eventHubName, connectionString);
}
else
{
attributes.Add(new EventHubAttribute(eventHubName));
_eventHubConfiguration.AddSender(eventHubName, connectionString);
}
return(attributes);
}
public override Collection <Attribute> GetAttributes()
{
Collection <Attribute> attributes = new Collection <Attribute>();
string eventHubName = Context.GetMetadataValue <string>("path");
if (!string.IsNullOrEmpty(eventHubName))
{
eventHubName = _nameResolver.ResolveWholeString(eventHubName);
}
string connectionString = Context.GetMetadataValue <string>("connection");
if (!string.IsNullOrEmpty(connectionString))
{
connectionString = _nameResolver.Resolve(connectionString);
}
if (Context.IsTrigger)
{
attributes.Add(new EventHubTriggerAttribute(eventHubName));
string eventProcessorHostName = Guid.NewGuid().ToString();
string storageConnectionString = _storageConnectionString;
string consumerGroup = Context.GetMetadataValue <string>("consumerGroup");
if (consumerGroup == null)
{
consumerGroup = Microsoft.ServiceBus.Messaging.EventHubConsumerGroup.DefaultGroupName;
}
var eventProcessorHost = new Microsoft.ServiceBus.Messaging.EventProcessorHost(
eventProcessorHostName,
eventHubName,
consumerGroup,
connectionString,
storageConnectionString);
_eventHubConfiguration.AddEventProcessorHost(eventHubName, eventProcessorHost);
}
else
{
attributes.Add(new EventHubAttribute(eventHubName));
var client = Microsoft.ServiceBus.Messaging.EventHubClient.CreateFromConnectionString(connectionString, eventHubName);
_eventHubConfiguration.AddEventHubClient(eventHubName, client);
}
return(attributes);
}
internal static bool IsDisabledBySetting(string settingName, MethodInfo method, INameResolver nameResolver)
{
if (nameResolver != null)
{
settingName = nameResolver.ResolveWholeString(settingName);
}
BindingTemplate bindingTemplate = BindingTemplate.FromString(settingName);
Dictionary <string, object> bindingData = new Dictionary <string, object>();
bindingData.Add("MethodName", string.Format(CultureInfo.InvariantCulture, "{0}.{1}", method.DeclaringType.Name, method.Name));
bindingData.Add("MethodShortName", method.Name);
settingName = bindingTemplate.Bind(bindingData);
return(ConfigurationUtility.IsSettingEnabled(settingName));
}
// AutoResolve
internal static BindingDataResolver GetTemplateResolver(string originalValue, AutoResolveAttribute attr, INameResolver nameResolver, PropertyInfo propInfo, BindingDataContract contract, Validator validator)
{
string resolvedValue = nameResolver.ResolveWholeString(originalValue);
var template = BindingTemplate.FromString(resolvedValue);
if (!template.HasParameters)
{
// No { } tokens, bind eagerly up front.
validator(resolvedValue);
}
IResolutionPolicy policy = GetPolicy(attr.ResolutionPolicyType, propInfo);
template.ValidateContractCompatibility(contract);
return((newAttr, bindingData) => TemplateBind(policy, propInfo, newAttr, template, bindingData, validator));
}
private ParameterDescriptor ToBlobDescr(BlobAttribute attr, ParameterInfo parameter, INameResolver nameResolver)
{
// Resolve the connection string to get an account name.
var client = GetClient(attr);
var accountName = client.AccountName;
var resolved = nameResolver.ResolveWholeString(attr.BlobPath);
string containerName = resolved;
string blobName = null;
int split = resolved.IndexOf('/');
if (split > 0)
{
containerName = resolved.Substring(0, split);
blobName = resolved.Substring(split + 1);
}
FileAccess access = FileAccess.ReadWrite;
if (attr.Access.HasValue)
{
access = attr.Access.Value;
}
else
{
var type = parameter.ParameterType;
if (type.IsByRef || type == typeof(TextWriter))
{
access = FileAccess.Write;
}
if (type == typeof(TextReader) || type == typeof(string) || type == typeof(byte[]))
{
access = FileAccess.Read;
}
}
return(new BlobParameterDescriptor
{
Name = parameter.Name,
AccountName = accountName,
ContainerName = containerName,
BlobName = blobName,
Access = access
});
}
internal static TimerSchedule Create(TimerTriggerAttribute attribute, INameResolver nameResolver)
{
TimerSchedule schedule = null;
if (!string.IsNullOrEmpty(attribute.ScheduleExpression))
{
string resolvedExpression = nameResolver.ResolveWholeString(attribute.ScheduleExpression);
CronSchedule cronSchedule = null;
TimeSpan periodTimespan;
if (CronSchedule.TryCreate(resolvedExpression, out cronSchedule))
{
schedule = cronSchedule;
DateTime[] nextOccurrences = cronSchedule.InnerSchedule.GetNextOccurrences(DateTime.Now, DateTime.Now + TimeSpan.FromMinutes(1)).ToArray();
if (nextOccurrences.Length > 1)
{
// if there is more than one occurrence due in the next minute,
// assume that this is a sub-minute constant schedule and disable
// persistence
attribute.UseMonitor = false;
}
}
else if (TimeSpan.TryParse(resolvedExpression, out periodTimespan))
{
schedule = new ConstantSchedule(periodTimespan);
if (periodTimespan.TotalMinutes < 1)
{
// for very frequent constant schedules, we want to disable persistence
attribute.UseMonitor = false;
}
}
else
{
throw new ArgumentException("The schedule expression was not recognized as a valid cron expression or timespan string.");
}
}
else
{
schedule = (TimerSchedule)Activator.CreateInstance(attribute.ScheduleType);
}
return(schedule);
}
internal static bool IsDisabledBySetting(string settingName, MethodInfo method, INameResolver nameResolver)
{
if (nameResolver != null)
{
settingName = nameResolver.ResolveWholeString(settingName);
}
BindingTemplate bindingTemplate = BindingTemplate.FromString(settingName);
Dictionary<string, string> bindingData = new Dictionary<string, string>();
bindingData.Add("MethodName", string.Format(CultureInfo.InvariantCulture, "{0}.{1}", method.DeclaringType.Name, method.Name));
bindingData.Add("MethodShortName", method.Name);
settingName = bindingTemplate.Bind(bindingData);
// check the target setting and return false (disabled) if the value exists
// and is "falsey"
string value = ConfigurationUtility.GetSettingFromConfigOrEnvironment(settingName);
if (!string.IsNullOrEmpty(value) &&
(string.Compare(value, "1", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(value, "true", StringComparison.OrdinalIgnoreCase) == 0))
{
return true;
}
return false;
}