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();
}
