public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { try { var connectionKey = $"{_connectionString}_{_topicName}"; if (!TopicClient.TryGetValue(connectionKey, out var topicClient)) { TokenProvider identityTokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); topicClient = new TopicClient(_connectionString, _topicName, identityTokenProvider, TransportType.Amqp, RetryPolicy.NoRetry); TopicClient.TryAdd(connectionKey, topicClient); } var message = new Message(Encoding.UTF8.GetBytes(TestMessage)); var scheduledMessageId = await topicClient.ScheduleMessageAsync(message, new DateTimeOffset(DateTime.UtcNow).AddHours(2)); await topicClient.CancelScheduledMessageAsync(scheduledMessageId); return(HealthCheckResult.Healthy()); } catch (Exception ex) { return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex)); } }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, TraceWriter log) { // var azureServiceTokenProvider = new AzureServiceTokenProvider(); //azureServiceTokenProvider. //string accessToken = await azureServiceTokenProvider.GetAccessTokenAsync("https://management.azure.com/"); //// OR //var kv = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback)); try { var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); var queueClient = new QueueClient("sb://asb-msitest-asos3.servicebus.windows.net", "myqueue", tokenProvider, TransportType.Amqp); var message = new Message(Encoding.UTF8.GetBytes("My message")); await queueClient.SendAsync(message); await queueClient.CloseAsync(); return((IActionResult) new OkObjectResult("Message sent")); } catch (Exception ex) { log.Error(ex.ToString(), ex); return((IActionResult) new BadRequestObjectResult(ex.ToString())); } }
protected void btnSend_Click(object sender, EventArgs e) { // create a parameter object for the messaging factory that configures // the MSI token provider for Service Bus and use of the AMQP protocol: MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience), TransportType = TransportType.Amqp }; // TODO - Remove after backend is patched with the AuthComponent open fix // https://github.com/Azure/azure-service-bus/issues/136 messagingFactorySettings.AmqpTransportSettings.EnableLinkRedirect = false; // create the messaging factory using the namespace endpoint name supplied by the user MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}/", messagingFactorySettings); // create a queue client using the queue name supplied by the user QueueClient queueClient = messagingFactory.CreateQueueClient(txtQueueName.Text); // send a message using the input text queueClient.Send(new BrokeredMessage(Encoding.UTF8.GetBytes(txtData.Text))); queueClient.Close(); messagingFactory.Close(); }
protected void btnReceive_Click(object sender, EventArgs e) { // create a parameter object for the messaging factory that configures // the MSI token provider for Service Bus and use of the AMQP protocol: MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience), TransportType = TransportType.Amqp }; // TODO - Remove after backend is patched with the AuthComponent open fix // https://github.com/Azure/azure-service-bus/issues/136 messagingFactorySettings.AmqpTransportSettings.EnableLinkRedirect = false; // create the messaging factory using the namespace endpoint name supplied by the user MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}/", messagingFactorySettings); // create a queue client using the queue name supplied by the user QueueClient queueClient = messagingFactory.CreateQueueClient(txtQueueName.Text, ReceiveMode.ReceiveAndDelete); // request a readily available message (with a very short wait) BrokeredMessage msg = queueClient.Receive(TimeSpan.FromSeconds(1)); if (msg != null) { // if we got a message, show its contents. txtReceivedData.Text += $"Seq#:{msg.SequenceNumber} data:{Encoding.UTF8.GetString(msg.GetBody<byte[]>())}{Environment.NewLine}"; } queueClient.Close(); messagingFactory.Close(); }
public string Get() { try { // create a parameter object for the messaging factory that configures // the MSI token provider for Service Bus and use of the AMQP protocol: MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience), TransportType = TransportType.Amqp }; // create the messaging factory using the namespace endpoint name supplied by the user MessagingFactory messagingFactory = MessagingFactory.Create($"sb://gordsbus.servicebus.windows.net/", messagingFactorySettings); // create a queue client using the queue name supplied by the user QueueClient queueClient = messagingFactory.CreateQueueClient("fabrictraffic"); queueClient.Send(new BrokeredMessage(Encoding.UTF8.GetBytes("Api hit"))); queueClient.Close(); messagingFactory.Close(); return("All good"); } catch (Exception ex) { return(ex.ToString()); } }
public ActionResult <QueueDescription> Get() { var token = TokenProvider.CreateManagedServiceIdentityTokenProvider(); var client = new ManagementClient("sb://issue-6462-2083f381-sbn.servicebus.windows.net/", token); var desc = client.GetQueueAsync("QueueName").Result; return(desc); }
static void ManagedServiceIdentityScenario() { MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.EventHubsAudience), TransportType = TransportType.Amqp }; SendReceive(messagingFactorySettings); }
private async Task <string> SendSecretToServiceBus() { var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); string sbName = "nosecrets01"; string queueName = "myqueue"; QueueClient client = new QueueClient($"sb://{sbName}.servicebus.windows.net/", queueName, tokenProvider); await client.SendAsync(new Message(Encoding.UTF8.GetBytes("Don't do this at home"))); await client.CloseAsync(); return("Message send to Service Bus. Check with ServiceBusExplorer"); }
public static EndpointConfiguration UseAzureServiceBusTransport(this EndpointConfiguration config, string connectionString, Action <RoutingSettings> routing = null) { #if NETSTANDARD2_0 var transport = config.UseTransport <AzureServiceBusTransport>(); var ruleNameShortener = new RuleNameShortener(); var tokenProvider = TokenProvider.CreateManagedIdentityTokenProvider(); transport.CustomTokenProvider(tokenProvider); transport.ConnectionString(connectionString); transport.RuleNameShortener(ruleNameShortener.Shorten); transport.Transactions(TransportTransactionMode.ReceiveOnly); routing?.Invoke(transport.Routing()); #elif NET462 var transport = config.UseTransport <AzureServiceBusTransport>(); transport.BrokeredMessageBodyType(SupportedBrokeredMessageBodyTypes.Stream); var managers = transport.NamespaceManagers(); managers.NamespaceManagerSettingsFactory( factory: s => { return(new NamespaceManagerSettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience) }); }); transport.ConnectionString(connectionString); transport.Transactions(TransportTransactionMode.ReceiveOnly); transport.UseForwardingTopology(); var messageReceivers = transport.MessageReceivers(); messageReceivers.AutoRenewTimeout(TimeSpan.FromMinutes(10)); var queues = transport.Queues(); queues.ForwardDeadLetteredMessagesTo(q => q != "error" && q != "audit" && q != "deadletters", "deadletters"); queues.LockDuration(TimeSpan.FromMinutes(1)); var subscriptions = transport.Subscriptions(); subscriptions.ForwardDeadLetteredMessagesTo("deadletters"); var sanitization = transport.Sanitization(); sanitization.UseStrategy <ValidateAndHashIfNeeded>(); routing?.Invoke(transport.Routing()); #endif return(config); }
public async Task <ActionResult> Send(ServiceBusMessageData messageInfo) { if (string.IsNullOrEmpty(messageInfo.MessageToSend)) { return(RedirectToAction("Index")); } var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); QueueClient sendClient = new QueueClient($"sb://{Config.Namespace}.servicebus.windows.net/", Config.Queue, tokenProvider); await sendClient.SendAsync(new Message(Encoding.UTF8.GetBytes(messageInfo.MessageToSend))); await sendClient.CloseAsync(); return(RedirectToAction("Index")); }
public async Task <bool> IsQueueHealthy(string queueName) { var connectionString = new ServiceBusConnectionStringBuilder(_configuration.NServiceBusConnectionString); var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); var client = new ManagementClient(connectionString, tokenProvider); if (!await client.QueueExistsAsync(queueName)) { return(false); } var queue = await client.GetQueueRuntimeInfoAsync(queueName); return(queue.MessageCount == 0); }
private static MessagingFactory CreateMessagingFactoryWithMsiTokenProvider() { // create a parameter object for the messaging factory that configures // the MSI token provider for Service Bus and use of the AMQP protocol: MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience), TransportType = TransportType.Amqp }; // create the messaging factory using the namespace endpoint name supplied by web.config MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{ServiceBusNamespace}.servicebus.windows.net/", messagingFactorySettings); return(messagingFactory); }
protected void btnSend_Click(object sender, EventArgs e) { MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.EventHubsAudience), TransportType = TransportType.Amqp }; MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}.servicebus.windows.net/", messagingFactorySettings); EventHubClient ehClient = messagingFactory.CreateEventHubClient(txtEventHub.Text); ehClient.Send(new EventData(Encoding.UTF8.GetBytes(txtData.Text))); ehClient.Close(); messagingFactory.Close(); }
public async Task <IList <sbMessageModel> > PeekMessages(string queueName) { var sbConnectionString = _config.GetValue <string>("ServiceBusRepoSettings:ServiceBusConnectionString"); var batchSize = _config.GetValue <int>("ServiceBusRepoSettings:PeekMessageBatchSize"); var notifyBatchSize = _config.GetValue <int>("ServiceBusRepoSettings:NotifyUIBatchSize"); var sbConnectionStringBuilder = new ServiceBusConnectionStringBuilder(sbConnectionString); var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); var messageReceiver = new MessageReceiver(sbConnectionStringBuilder.Endpoint, queueName, tokenProvider); #if DEBUG _logger.LogDebug($"ServiceBusConnectionString: {sbConnectionString}"); _logger.LogDebug($"PeekMessageBatchSize: {batchSize}"); #endif int totalMessages = 0; IList <Message> peekedMessages; var formattedMessages = new List <sbMessageModel>(); peekedMessages = await messageReceiver.PeekAsync(batchSize); _logger.LogDebug($"Peeked Message Count: {peekedMessages.Count}"); while (peekedMessages.Count > 0) { foreach (var msg in peekedMessages) { var messageModel = FormatMsgToLog(msg); totalMessages++; if (totalMessages % notifyBatchSize == 0) { _logger.LogDebug($" {queueName} - processed: {totalMessages}"); } formattedMessages.Add(messageModel); } peekedMessages = await messageReceiver.PeekAsync(batchSize); } await messageReceiver.CloseAsync(); return(formattedMessages); }
public static IServiceCollection AddNServiceBus(this IServiceCollection services, IConfiguration configuration, bool isDevelopment) { return(services .AddSingleton(p => { var nservicebusConfiguration = configuration.GetSection(NotificationConfigurationKeys.NServiceBusConfiguration).Get <NServiceBusConfiguration>(); var container = p.GetService <IContainer>(); var endpointName = "SFA.DAS.Notifications.MessageHandlers"; var endpointConfiguration = new EndpointConfiguration(endpointName) .UseErrorQueue($"{endpointName}-errors") .UseInstallers() .UseLicense(nservicebusConfiguration.NServiceBusLicense) .UseMessageConventions() .UseNewtonsoftJsonSerializer() .UseNLogFactory() .UseOutbox() .UseSqlServerPersistence(() => container.GetInstance <DbConnection>()) .UseStructureMapBuilder(container) .UseUnitOfWork(); if (isDevelopment) { endpointConfiguration.UseLearningTransport(); } else { var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>(); var ruleNameShortener = new RuleNameShortener(); var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); transport.CustomTokenProvider(tokenProvider); transport.ConnectionString(nservicebusConfiguration.ServiceBusConnectionString); transport.RuleNameShortener(ruleNameShortener.Shorten); } var endpoint = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult(); return endpoint; }) .AddHostedService <NServiceBusHostedService>()); }
public async Task <IEnumerable <string> > GetErrorQueuesAsync() { var sbConnectionString = _config.GetValue <string>("ServiceBusRepoSettings:ServiceBusConnectionString"); var tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); var sbConnectionStringBuilder = new ServiceBusConnectionStringBuilder(sbConnectionString); var managementClient = new ManagementClient(sbConnectionStringBuilder, tokenProvider); var queues = await managementClient.GetQueuesAsync().ConfigureAwait(false); var regexString = _config.GetValue <string>("ServiceBusRepoSettings:QueueSelectionRegex"); var queueSelectionRegex = new Regex(regexString); var errorQueues = queues.Where(q => queueSelectionRegex.IsMatch(q.Path)).Select(x => x.Path); #if DEBUG _logger.LogDebug("Error Queues:"); foreach (var queue in errorQueues) { _logger.LogDebug(queue); } #endif return(errorQueues); }
public static void Initialize(ServiceBusConfiguration config) { if (_receiveClient != null) { return; } TokenProvider tokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(); _receiveClient = new QueueClient($"sb://{config.Namespace}.servicebus.windows.net/", config.Queue, tokenProvider, receiveMode: ReceiveMode.ReceiveAndDelete); _receiveClient.RegisterMessageHandler( (message, cancellationToken) => { _receivedMessages.Add($"MessageId:{message.MessageId}, Seq#:{message.SystemProperties.SequenceNumber}, data:{Encoding.UTF8.GetString(message.Body)}"); return(Task.CompletedTask); }, (exceptionEvent) => { _receivedMessages.Add($"Exception: \"{exceptionEvent.Exception.Message}\" {exceptionEvent.ExceptionReceivedContext.EntityPath}"); return(Task.CompletedTask); }); }
protected void btnReceive_Click(object sender, EventArgs e) { MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.EventHubsAudience), TransportType = TransportType.Amqp }; messagingFactorySettings.AmqpTransportSettings.EnableLinkRedirect = false; MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}.servicebus.windows.net/", messagingFactorySettings); EventHubClient ehClient = messagingFactory.CreateEventHubClient(txtEventHub.Text); EventHubConsumerGroup consumerGroup = ehClient.GetDefaultConsumerGroup(); int partitions = int.Parse(txtPartitions.Text); string[] Offsets = new string[partitions]; if (!string.IsNullOrEmpty(hiddenStartingOffset.Value)) { Offsets = hiddenStartingOffset.Value.Split(','); } System.Threading.Tasks.Parallel.ForEach(Enumerable.Range(0, int.Parse(txtPartitions.Text)), partitionId => { EventHubReceiver receiver = consumerGroup.CreateReceiver($"{partitionId}", Offsets[partitionId] == null ? "-1" : Offsets[partitionId]); EventData data = receiver.Receive(TimeSpan.FromSeconds(1)); if (data != null) { Offsets[partitionId] = data.Offset; txtReceivedData.Text += $"PartitionId: {partitionId} Seq#:{data.SequenceNumber} data:{Encoding.UTF8.GetString(data.GetBytes())}{Environment.NewLine}"; } receiver.Close(); }); hiddenStartingOffset.Value = string.Join(",", Offsets); ehClient.Close(); messagingFactory.Close(); }
protected void btnSend_Click(object sender, EventArgs e) { // create a parameter object for the messaging factory that configures // the MSI token provider for Service Bus and use of the AMQP protocol: MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience), TransportType = TransportType.Amqp }; // create the messaging factory using the namespace endpoint name supplied by the user MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}/", messagingFactorySettings); // create a queue client using the queue name supplied by the user QueueClient queueClient = messagingFactory.CreateQueueClient(txtQueueName.Text); // send a message using the input text queueClient.Send(new BrokeredMessage(Encoding.UTF8.GetBytes(txtData.Text))); queueClient.Close(); messagingFactory.Close(); }
public async Task UseAzureServiceBus_GivenStaticOptions_ThenValid() { var options = new ServiceBusOptions { ConnectionName = "connection-name-test", HostAddress = new Uri("sb://namespace.servicebus.windows.net/scope"), TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(), OperationTimeout = TimeSpan.FromMilliseconds(101), RetryMinBackoff = TimeSpan.FromMilliseconds(102), RetryMaxBackoff = TimeSpan.FromMilliseconds(103), RetryLimit = 9, TransportType = TransportType.AmqpWebSockets, }; var mockBusHandle = new Mock <BusHandle>(MockBehavior.Strict); var mockBusControl = new Mock <IBusControl>(MockBehavior.Strict); var mockAzureServiceBusBusFactory = new Mock <IBusFactory <IServiceBusBusFactoryConfigurator> >(MockBehavior.Strict); var mockAzureServiceBusBusFactoryConfigurator = new Mock <IServiceBusBusFactoryConfigurator>(MockBehavior.Strict); var mockAzureServiceBusHost = new Mock <IServiceBusHost>(MockBehavior.Strict); mockBusControl .Setup(_ => _.StartAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(mockBusHandle.Object) .Verifiable(); mockBusControl .Setup(_ => _.StopAsync(It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask) .Verifiable(); mockAzureServiceBusBusFactory .Setup(_ => _.Create(It.IsAny <Action <IServiceBusBusFactoryConfigurator> >())) .Callback((Action <IServiceBusBusFactoryConfigurator> configure) => configure(mockAzureServiceBusBusFactoryConfigurator.Object)) .Returns(mockBusControl.Object) .Verifiable(); mockAzureServiceBusBusFactoryConfigurator .Setup(_ => _.Host(It.IsAny <ServiceBusHostSettings>())) .Callback((ServiceBusHostSettings settings) => { Assert.Equal(options.HostAddress, settings.ServiceUri); Assert.Same(options.TokenProvider, settings.TokenProvider); Assert.Equal(options.OperationTimeout, settings.OperationTimeout); Assert.Equal(options.RetryMinBackoff, settings.RetryMinBackoff); Assert.Equal(options.RetryMaxBackoff, settings.RetryMaxBackoff); Assert.Equal(options.RetryLimit, settings.RetryLimit); Assert.Equal(options.TransportType, settings.TransportType); }) .Returns(mockAzureServiceBusHost.Object) .Verifiable(); var services = new ServiceCollection(); services.AddSingleton(mockAzureServiceBusBusFactory.Object); services.AddLogging(builder => { builder.SetMinimumLevel(LogLevel.Trace); builder.AddXUnit(_output); }); services.AddMassTransit(builder => { builder.UseAzureServiceBus(options); }); using (var serviceProvider = services.BuildServiceProvider()) { var busManager = serviceProvider.GetRequiredService <IBusManager>(); await busManager.StartAsync(CancellationToken.None).ConfigureAwait(false); var bus = busManager.GetBus(options.ConnectionName); Assert.NotNull(bus); await busManager.StopAsync(CancellationToken.None).ConfigureAwait(false); } mockAzureServiceBusHost.Verify(); mockAzureServiceBusBusFactoryConfigurator.Verify(); mockAzureServiceBusBusFactory.Verify(); mockBusControl.Verify(); mockBusHandle.Verify(); }