public Task <IBinding> TryCreateAsync(BindingProviderContext context) { ParameterInfo parameter = context.Parameter; ServiceBusAttribute serviceBusAttribute = parameter.GetCustomAttribute <ServiceBusAttribute>(inherit: false); if (serviceBusAttribute == null) { return(Task.FromResult <IBinding>(null)); } string queueOrTopicName = Resolve(serviceBusAttribute.QueueOrTopicName); IBindableServiceBusPath path = BindableServiceBusPath.Create(queueOrTopicName); path.ValidateContractCompatibility(context.BindingDataContract); IArgumentBinding <ServiceBusEntity> argumentBinding = _innerProvider.TryCreate(parameter); if (argumentBinding == null) { throw new InvalidOperationException("Can't bind ServiceBus to type '" + parameter.ParameterType + "'."); } string connectionString = _accountProvider.ConnectionString; ServiceBusAccount account = ServiceBusAccount.CreateFromConnectionString(connectionString); IBinding binding = new ServiceBusBinding(parameter.Name, argumentBinding, account, path); return(Task.FromResult(binding)); }
public override async Task BindAsync(BindingContext context) { string boundQueueName = QueueOrTopicName; if (context.BindingData != null) { boundQueueName = _queueOrTopicNameBindingTemplate.Bind(context.BindingData); } boundQueueName = Resolve(boundQueueName); var attribute = new ServiceBusAttribute(boundQueueName); Attribute[] additionalAttributes = null; if (!string.IsNullOrEmpty(Metadata.Connection)) { additionalAttributes = new Attribute[] { new ServiceBusAccountAttribute(Metadata.Connection) }; } RuntimeBindingContext runtimeContext = new RuntimeBindingContext(attribute, additionalAttributes); await BindAsyncCollectorAsync <string>(context.Value, context.Binder, runtimeContext); }
public Task <IBinding> TryCreateAsync(BindingProviderContext context) { if (context == null) { throw new ArgumentNullException("context"); } ParameterInfo parameter = context.Parameter; ServiceBusAttribute attribute = parameter.GetCustomAttribute <ServiceBusAttribute>(inherit: false); if (attribute == null) { return(Task.FromResult <IBinding>(null)); } string queueOrTopicName = Resolve(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)); } ServiceBusAccount account = ServiceBusAccount.CreateFromConnectionString(_config.ConnectionString); IBinding binding = new ServiceBusBinding(parameter.Name, argumentBinding, account, path, attribute.Access); return(Task.FromResult(binding)); }
public void Constructor_AccessSpecified_SetsExpectedValues() { ServiceBusAttribute attribute = new ServiceBusAttribute("testqueue", AccessRights.Listen); Assert.Equal("testqueue", attribute.QueueOrTopicName); Assert.Equal(AccessRights.Listen, attribute.Access); }
public StringToServiceBusEntityConverter(ServiceBusAttribute attribute, IBindableServiceBusPath defaultPath, MessagingProvider messagingProvider, ServiceBusClientFactory clientFactory) { _attribute = attribute; _defaultPath = defaultPath; _entityType = _attribute.EntityType; _messagingProvider = messagingProvider; _clientFactory = clientFactory; }
private static async Task <HttpResponseMessage> Run(string type, HttpRequestMessage req, TraceWriter log, IBinder binder) { try { log.Info($"{type} WebHook Received"); var queryParams = req.GetQueryNameValuePairs().ToList(); var tenant = queryParams.FirstOrDefault(x => string.Equals(x.Key, "tenant", StringComparison.OrdinalIgnoreCase)).Value; if (string.IsNullOrWhiteSpace(tenant)) { log.Error($"{type} - Missing tenant parameter"); return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Please provide tenant parameter")); } var validTenants = Environment.GetEnvironmentVariable("ValidTenants")?.Split(';'); if (validTenants == null || !validTenants.Any(x => string.Equals(x, tenant, StringComparison.InvariantCultureIgnoreCase))) { log.Error($"{type} - Tenant {tenant} is not allowed"); return(req.CreateErrorResponse(HttpStatusCode.Forbidden, "Please provide valid tenant parameter")); } var subType = queryParams.FirstOrDefault(x => string.Equals(x.Key, "subType", StringComparison.OrdinalIgnoreCase)).Value; if (string.IsNullOrWhiteSpace(subType)) { log.Error($"{type} - Missing subType parameter"); return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Please provide subType parameter")); } log.Info($"{type} WebHook (tenant: {tenant} | subType: {subType})"); var jsonData = await req.Content.ReadAsStringAsync(); var hookInformation = new HookInformation { Type = type, SubType = subType, JsonData = jsonData, RequestHeaders = req.Headers.ToList() }; var serviceBusQueueAttribute = new ServiceBusAttribute($"hooks_{tenant}", AccessRights.Manage) { Connection = "AzureServiceBus" }; var queueMessageJson = JsonConvert.SerializeObject(hookInformation); var outputMessages = await binder.BindAsync <IAsyncCollector <string> >(serviceBusQueueAttribute); await outputMessages.AddAsync(queueMessageJson); return(req.CreateResponse(HttpStatusCode.OK)); } catch (Exception e) { log.Error($"Error Processing {type} Hook", e); return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
public void ServiceBusShouldHaveStringEnumForAccessRights() { var attribute = new ServiceBusAttribute("queue1", AccessRights.Manage); var jObject = attribute.ToJObject(); jObject.Should().HaveElement("accessRights"); jObject["accessRights"].Should().Be("manage"); }
public void ServiceBusShouldHaveCorrectQueueName() { var attribute = new ServiceBusAttribute("queue1") { EntityType = EntityType.Queue }; var jObject = attribute.ToJObject(); jObject.Should().HaveElement("queueName"); jObject["queueName"].Should().Be("queue1"); }
public ServiceBusBinding( string parameterName, IArgumentBinding <ServiceBusEntity> argumentBinding, IBindableServiceBusPath path, ServiceBusAttribute attribute, MessagingProvider messagingProvider, ServiceBusClientFactory clientFactory) { _parameterName = parameterName; _argumentBinding = argumentBinding; _path = path; _messagingProvider = messagingProvider; _clientFactory = clientFactory; _attribute = attribute; _converter = new OutputConverter <string>(new StringToServiceBusEntityConverter(_attribute, _path, _messagingProvider, _clientFactory)); }
public static void ServiceBusBinderTest( string message, int numMessages, Binder binder) { var attribute = new ServiceBusAttribute(_firstQueueScope.QueueName) { EntityType = ServiceBusEntityType.Queue }; var collector = binder.Bind <ICollector <string> >(attribute); for (int i = 0; i < numMessages; i++) { collector.Add(message + i); } }
public override Collection <Attribute> GetAttributes() { Collection <Attribute> attributes = new Collection <Attribute>(); string queueName = Context.GetMetadataValue <string>("queueName"); string topicName = Context.GetMetadataValue <string>("topicName"); string subscriptionName = Context.GetMetadataValue <string>("subscriptionName"); var accessRights = Context.GetMetadataEnumValue <Microsoft.ServiceBus.Messaging.AccessRights>("accessRights"); Attribute attribute = null; if (Context.IsTrigger) { if (!string.IsNullOrEmpty(topicName) && !string.IsNullOrEmpty(subscriptionName)) { attribute = new ServiceBusTriggerAttribute(topicName, subscriptionName, accessRights); } else if (!string.IsNullOrEmpty(queueName)) { attribute = new ServiceBusTriggerAttribute(queueName, accessRights); } } else { attribute = new ServiceBusAttribute(queueName ?? topicName, accessRights) { EntityType = string.IsNullOrEmpty(topicName) ? EntityType.Queue : EntityType.Topic }; } if (attribute == null) { throw new InvalidOperationException("Invalid ServiceBus trigger configuration."); } attributes.Add(attribute); var connectionProvider = (IConnectionProvider)attribute; string connection = Context.GetMetadataValue <string>("connection"); if (!string.IsNullOrEmpty(connection)) { connectionProvider.Connection = connection; } return(attributes); }
public async Task <ISendTransport> GetSendTransport(Uri address) { var queueOrTopicName = address.AbsolutePath.Trim('/'); var serviceBusQueue = new ServiceBusAttribute(queueOrTopicName, EntityType.Queue); IAsyncCollector <Message> collector = await _binder.BindAsync <IAsyncCollector <Message> >(serviceBusQueue, _cancellationToken).ConfigureAwait(false); LogContext.Debug?.Log("Creating Send Transport: {Queue}", queueOrTopicName); var sendEndpointContext = new CollectorMessageSendEndpointContext(queueOrTopicName, collector, _cancellationToken); var source = new CollectorSendEndpointContextSupervisor(sendEndpointContext); var transportContext = new HostServiceBusSendTransportContext(address, source, LogContext.Current.CreateLogContext(LogCategoryName.Transport.Send)); return(new ServiceBusSendTransport(transportContext)); }
public static async Task ServiceBusBinderTest( string message, int numMessages, Binder binder) { var attribute = new ServiceBusAttribute(BinderQueueName) { EntityType = EntityType.Queue }; var collector = await binder.BindAsync <IAsyncCollector <string> >(attribute); for (int i = 0; i < numMessages; i++) { await collector.AddAsync(message + i); } await collector.FlushAsync(); }
public async Task <ISendTransport> GetSendTransport(Uri address) { var queueOrTopicName = address.AbsolutePath.Trim('/'); var serviceBusQueue = new ServiceBusAttribute(queueOrTopicName, EntityType.Queue); IAsyncCollector <Message> collector = await _binder.BindAsync <IAsyncCollector <Message> >(serviceBusQueue, _cancellationToken).ConfigureAwait(false); if (_log.IsDebugEnabled) { _log.DebugFormat("Creating Send Transport: {0}", queueOrTopicName); } var sendEndpointContext = new CollectorMessageSendEndpointContext(queueOrTopicName, _log, collector, _cancellationToken); var source = new CollectorSendEndpointContextSource(sendEndpointContext); return(new ServiceBusSendTransport(source, address)); }
public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)]HttpRequestMessage req, //[ServiceBus("emails", AccessRights.Manage, Connection = "ServiceBusConnection")] IAsyncCollector<string> collector, TraceWriter log, IBinder binder) { log.Info("C# HTTP trigger function processed a request."); var qs = req.GetQueryNameValuePairs(); var valValue = qs.FirstOrDefault(x => x.Key.Equals(validationKey, StringComparison.CurrentCultureIgnoreCase)); if (!string.IsNullOrEmpty(valValue.Value)) return req.CreateResponse(HttpStatusCode.OK, valValue.Value); else { var serviceBusQueueAttribute = new ServiceBusAttribute("emails", AccessRights.Manage) { Connection = "ServiceBusConnection" }; var outputMessages = await binder.BindAsync<IAsyncCollector<string>>(serviceBusQueueAttribute); var body = await req.Content.ReadAsStringAsync(); await outputMessages.AddAsync(body); return req.CreateResponse(HttpStatusCode.Accepted); } }
async Task <ISendTransport> GetSendTransport(Uri address) { var queueOrTopicName = address.AbsolutePath.Trim('/'); var serviceBusTopic = new ServiceBusAttribute(queueOrTopicName, AccessRights.Manage); serviceBusTopic.EntityType = EntityType.Topic; IAsyncCollector <BrokeredMessage> collector = await _binder.BindAsync <IAsyncCollector <BrokeredMessage> >(serviceBusTopic, _cancellationToken).ConfigureAwait(false); if (_log.IsDebugEnabled) { _log.DebugFormat("Creating Publish Transport: {0}", queueOrTopicName); } var client = new CollectorSendEndpointContext(queueOrTopicName, _log, collector, _cancellationToken); var source = new CollectorSendEndpointContextSource(client); var transport = new ServiceBusSendTransport(source, address); return(transport); }
public override async Task BindAsync(BindingContext context) { string boundQueueName = QueueOrTopicName; if (context.BindingData != null) { boundQueueName = _queueOrTopicNameBindingTemplate.Bind(context.BindingData); } boundQueueName = Resolve(boundQueueName); var attribute = new ServiceBusAttribute(boundQueueName); Attribute[] additionalAttributes = null; if (!string.IsNullOrEmpty(Metadata.Connection)) { additionalAttributes = new Attribute[] { new ServiceBusAccountAttribute(Metadata.Connection) }; } RuntimeBindingContext runtimeContext = new RuntimeBindingContext(attribute, additionalAttributes); await BindAsyncCollectorAsync<string>(context.Value, context.Binder, runtimeContext); }
public static async Task <ActivityResponse> QueryOutputToServiceBusActivity( [ActivityTrigger] DurableActivityContext context, Binder outputBinder, ILogger log) { ActivityResponse ret = new ActivityResponse() { FunctionName = "QueryOutputToServiceBusActivity" }; #region Logging if (null != log) { log.LogDebug($"Output in {ret.FunctionName} "); } #endregion // Read the results QueryOutputRecord <object> results = context.GetInput <QueryOutputRecord <object> >(); if (null != results) { var queueAttribute = new ServiceBusAttribute(results.Target); var payloadAsJSON = JsonConvert.SerializeObject(results.Results); using (var writer = outputBinder.Bind <TextWriter>(queueAttribute)) { await writer.WriteAsync(payloadAsJSON); } } else { ret.Message = $"Unable to get query output record to send to Service Bus"; } return(ret); }
public ServiceBusBinding(string parameterName, IArgumentBinding <ServiceBusEntity> argumentBinding, ServiceBusAccount account, IBindableServiceBusPath path, ServiceBusAttribute attr, MessagingProvider messagingProvider) { _parameterName = parameterName; _argumentBinding = argumentBinding; _account = account; _path = path; _entityType = attr.EntityType; _messagingProvider = messagingProvider; _converter = new OutputConverter <string>(new StringToServiceBusEntityConverter(account, _path, _entityType, _messagingProvider)); }
public void Constructor_Success() { ServiceBusAttribute attribute = new ServiceBusAttribute("testqueue"); Assert.AreEqual("testqueue", attribute.QueueOrTopicName); }
public ServiceBusBinding(string parameterName, IArgumentBinding <ServiceBusEntity> argumentBinding, ServiceBusAccount account, IBindableServiceBusPath path, ServiceBusAttribute attr) { _parameterName = parameterName; _argumentBinding = argumentBinding; _account = account; _namespaceName = ServiceBusClient.GetNamespaceName(account); _path = path; _accessRights = attr.Access; _entityType = attr.EntityType; _converter = new OutputConverter <string>( new StringToServiceBusEntityConverter(account, _path, _accessRights, _entityType)); }