public void Start(PushRuntimeSettings limitations) { maxConcurrency = limitations.MaxConcurrency; var prefetchCount = maxConcurrency * prefetchMultiplier; if (overriddenPrefetchCount.HasValue) { prefetchCount = overriddenPrefetchCount.Value; } var receiveMode = pushSettings.RequiredTransactionMode == TransportTransactionMode.None ? ReceiveMode.ReceiveAndDelete : ReceiveMode.PeekLock; if (tokenProvider == null) { receiver = new MessageReceiver(connectionStringBuilder.GetNamespaceConnectionString(), pushSettings.InputQueue, receiveMode, retryPolicy: retryPolicy, prefetchCount); } else { receiver = new MessageReceiver(connectionStringBuilder.Endpoint, pushSettings.InputQueue, tokenProvider, connectionStringBuilder.TransportType, receiveMode, retryPolicy: retryPolicy, prefetchCount); } semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency); messageProcessing = new CancellationTokenSource(); receiveLoopTask = Task.Run(() => ReceiveLoop()); }
public MessageReceiver( ServiceBusConnectionStringBuilder connectionStringBuilder, ReceiveMode receiveMode = ReceiveMode.PeekLock, RetryPolicy retryPolicy = null, int prefetchCount = DefaultPrefetchCount) : this(connectionStringBuilder?.GetNamespaceConnectionString(), connectionStringBuilder.EntityPath, receiveMode, retryPolicy, prefetchCount) { }
private static async Task ConfigureSubscriptionAsync(ServiceBusConnectionStringBuilder builder, string subscriptionName) { var subscriptionDescription = new SubscriptionDescription(builder.EntityPath, subscriptionName); var client = new ManagementClient(builder.GetNamespaceConnectionString()); if (!await client.SubscriptionExistsAsync(builder.EntityPath, subscriptionName).ConfigureAwait(false)) { await client.CreateSubscriptionAsync(subscriptionDescription).ConfigureAwait(false); } }
private static string GetConnectionString() { ServiceBusConnectionStringBuilder sb = new ServiceBusConnectionStringBuilder(); sb.Endpoint = BaseAddress; sb.SasKey = AccessKey; sb.EntityPath = "tranfers"; sb.SasKeyName = KeyName; var connectionString = sb.GetNamespaceConnectionString(); return(connectionString); }
public DefaultServiceBusPersisterConnection(ServiceBusConnectionStringBuilder serviceBusConnectionStringBuilder, ILogger <DefaultServiceBusPersisterConnection> logger) { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _serviceBusConnectionStringBuilder = serviceBusConnectionStringBuilder ?? throw new ArgumentNullException(nameof(serviceBusConnectionStringBuilder)); var test = _serviceBusConnectionStringBuilder.GetNamespaceConnectionString(); _topicClient = new TopicClient(_serviceBusConnectionStringBuilder, RetryPolicy.Default); }
private static MessageReceiver CreateReceiver(ServiceBusConnectionStringBuilder serviceBusConnectionStringBuilder, string entityName, string subscriptionName) { var entityPath = entityName; if (string.IsNullOrWhiteSpace(subscriptionName) == false) { entityPath = $"{entityPath}/subscriptions/{subscriptionName}"; } var connectionString = serviceBusConnectionStringBuilder.GetNamespaceConnectionString(); return(new MessageReceiver(connectionString, entityPath)); }
public static IServiceCollection AddCustomHealthChecks(this IServiceCollection services, IConfiguration configuration) { var hcBuilder = services.AddHealthChecks(); hcBuilder.AddCheck("liveness", () => HealthCheckResult.Healthy()); var serviceBusConnectionString = configuration["EventBus:ConnectionString"]; var serviceBusConnection = new ServiceBusConnectionStringBuilder(serviceBusConnectionString); hcBuilder.AddSqlServer(configuration["Database:ConnectionString"], name: "web-app-on-containers-db-sb-check", tags: new[] { "web-app-on-containers-db-sb" }); hcBuilder.AddAzureServiceBusTopic(serviceBusConnection.GetNamespaceConnectionString(), serviceBusConnection.EntityPath, "service-bus-check", tags: new[] { "service-bus" }); return(services); }
private static async Task QueueOrders(int requestedAmount) { var serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(ConnectionString); var queueClient = new QueueClient(serviceBusConnectionStringBuilder.GetNamespaceConnectionString(), serviceBusConnectionStringBuilder.EntityPath, ReceiveMode.PeekLock); for (int currentOrderAmount = 0; currentOrderAmount < requestedAmount; currentOrderAmount++) { var order = GenerateOrder(); var rawOrder = JsonConvert.SerializeObject(order); var orderMessage = new Message(Encoding.UTF8.GetBytes(rawOrder)); Console.WriteLine($"Queuing order {order.Id} - A {order.ArticleNumber} for {order.Customer.FirstName} {order.Customer.LastName}"); await queueClient.SendAsync(orderMessage); } }
public void Start(PushRuntimeSettings limitations) { maxConcurrency = limitations.MaxConcurrency; var prefetchCount = overriddenPrefetchCount; if (prefetchCount == 0) { prefetchCount = maxConcurrency * prefetchMultiplier; } var receiveMode = pushSettings.RequiredTransactionMode == TransportTransactionMode.None ? ReceiveMode.ReceiveAndDelete : ReceiveMode.PeekLock; if (tokenProvider == null) { receiver = new MessageReceiver(connectionStringBuilder.GetNamespaceConnectionString(), pushSettings.InputQueue, receiveMode, retryPolicy: default, prefetchCount);
private static async Task ConfigureQueueAsync(ServiceBusConnectionStringBuilder builder, bool canCreateQueue) { if (canCreateQueue) { var queueDescription = new QueueDescription(builder.EntityPath) { EnableBatchedOperations = true, EnablePartitioning = true }; var client = new ManagementClient(builder.GetNamespaceConnectionString()); if (!await client.QueueExistsAsync(builder.EntityPath).ConfigureAwait(false)) { await client.CreateQueueAsync(queueDescription).ConfigureAwait(false); } } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllers(); services.AddRazorPages(); services.AddSignalR(); services.AddOptions(); var orderQueueSection = Configuration.GetSection("OrderQueue"); services.Configure <OrderQueueSettings>(orderQueueSection); services.AddSwagger(); services.AddScoped <QueueClient>(serviceProvider => { var connectionString = Configuration.GetValue <string>("KEDA_SERVICEBUS_QUEUE_CONNECTIONSTRING"); var serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString); return(new QueueClient(serviceBusConnectionStringBuilder.GetNamespaceConnectionString(), serviceBusConnectionStringBuilder.EntityPath)); }); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var ordersQueue = Configuration.GetValue <string>("SERVICEBUS_QUEUE_ORDERS"); var queueClient = new QueueClient(_serviceBusConnectionStringBuilder.GetNamespaceConnectionString(), ordersQueue, ReceiveMode.PeekLock); Logger.LogInformation("Starting message pump"); queueClient.RegisterMessageHandler(HandleMessage, HandleReceivedException); Logger.LogInformation("Message pump started"); while (!stoppingToken.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(1)); } Logger.LogInformation("Closing message pump"); await queueClient.CloseAsync(); Logger.LogInformation("Message pump closed : {Time}", DateTimeOffset.UtcNow); }
public void ConfigureServices(IServiceCollection services) { services.AddControllers(); var openApiInformation = new OpenApiInfo { Title = "KEDA API", Version = "v1" }; services.AddScoped <QueueClient>(serviceProvider => { var configuration = serviceProvider.GetRequiredService <IConfiguration>(); var connectionString = configuration["KEDA_SERVICEBUS_QUEUE_CONNECTIONSTRING"]; var serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString); return(new QueueClient(serviceBusConnectionStringBuilder.GetNamespaceConnectionString(), serviceBusConnectionStringBuilder.EntityPath, ReceiveMode.PeekLock)); }); services.AddSwaggerGen(swaggerGenerationOptions => { swaggerGenerationOptions.SwaggerDoc("v1", openApiInformation); swaggerGenerationOptions.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, "Keda.Samples.Dotnet.API.Open-Api.xml")); }); }
public ShipmentRepository(ServiceBusConnectionStringBuilder connectionStringBuilder, IConfiguration configuration) { var shipmentsQueue = configuration.GetValue <string>("SERVICEBUS_QUEUE_SHIPMENTS"); _queueClient = new QueueClient(connectionStringBuilder.GetNamespaceConnectionString(), shipmentsQueue, ReceiveMode.PeekLock); }
static async Task MainAsync(string[] args) { // The connection string for the RootManageSharedAccessKey can be accessed from the Azure portal // by selecting the SB namespace and clicking on "Connection Information" Console.Write("Enter your connection string for the RootManageSharedAccessKey for your Service Bus namespace: "); nsConnectionString = Console.ReadLine(); var cxn = new ServiceBusConnectionStringBuilder(nsConnectionString); /////////////////////////////////////////////////////////////////////////////////////// // Create a topic with a SAS Listen rule and an associated subscription /////////////////////////////////////////////////////////////////////////////////////// ManagementClient nm = new ManagementClient(cxn); contosoTListenRule = new SharedAccessAuthorizationRule("contosoTListenKey", new[] { AccessRights.Listen }); TopicDescription td = new TopicDescription(topicPath); td.AuthorizationRules.Add(contosoTListenRule); if ((await nm.TopicExistsAsync(topicPath))) { await nm.DeleteTopicAsync(topicPath); } await nm.CreateTopicAsync(td); await nm.CreateSubscriptionAsync(topicPath, subscriptionName); /////////////////////////////////////////////////////////////////////////////////////// // Send a message to the topic // Note that this uses the connection string for RootManageSharedAccessKey // configured on the namespace root /////////////////////////////////////////////////////////////////////////////////////// TopicClient tc = new TopicClient(cxn.GetNamespaceConnectionString(), topicPath, RetryPolicy.Default); Message sentMessage = CreateHelloMessage(); await tc.SendAsync(sentMessage); Console.WriteLine("Sent Hello message to topic: ID={0}, Body={1}.", sentMessage.MessageId, Encoding.UTF8.GetString(sentMessage.Body)); /////////////////////////////////////////////////////////////////////////////////////// // Generate a SAS token scoped to a subscription using the SAS rule with // a Listen right configured on the Topic & TTL of 1 day /////////////////////////////////////////////////////////////////////////////////////// ServiceBusConnectionStringBuilder csBuilder = new ServiceBusConnectionStringBuilder(nsConnectionString); string subscriptionUri = new Uri(new Uri(csBuilder.Endpoint), topicPath + "/subscriptions/" + subscriptionName).ToString(); // This is how you acquire a token in an STS to pass it out to a client. var tp = TokenProvider.CreateSharedAccessSignatureTokenProvider(contosoTListenRule.KeyName, contosoTListenRule.PrimaryKey); var subscriptionToken = await tp.GetTokenAsync(subscriptionUri, TimeSpan.FromMinutes(180)); Console.WriteLine($"Acquired token: {subscriptionToken.TokenValue}"); /////////////////////////////////////////////////////////////////////////////////////// // Use the SAS token scoped to a subscription to receive the messages /////////////////////////////////////////////////////////////////////////////////////// var are = new AutoResetEvent(false); SubscriptionClient sc = new SubscriptionClient(csBuilder.Endpoint, topicPath, subscriptionName, TokenProvider.CreateSharedAccessSignatureTokenProvider(subscriptionToken.TokenValue)); sc.RegisterMessageHandler(async(m, c) => { Console.WriteLine("Received message from subscription: ID = {0}, Body = {1}.", m.MessageId, Encoding.UTF8.GetString(m.Body)); await sc.CompleteAsync(m.SystemProperties.LockToken); are.Set(); }, new MessageHandlerOptions(async(e) => { Console.WriteLine($"Exception: {e.Exception.ToString()}"); }) { AutoComplete = false }); are.WaitOne(); await sc.CloseAsync(); /////////////////////////////////////////////////////////////////////////////////////// // Clean-up /////////////////////////////////////////////////////////////////////////////////////// await nm.DeleteTopicAsync(topicPath); }
/// <summary> /// Creates a new AMQP MessageSender. /// </summary> /// <param name="connectionStringBuilder">The <see cref="ServiceBusConnectionStringBuilder"/> having entity level connection details.</param> /// <param name="retryPolicy">The <see cref="RetryPolicy"/> that will be used when communicating with Service Bus. Defaults to <see cref="RetryPolicy.Default"/></param> /// <remarks>Creates a new connection to the entity, which is opened during the first operation.</remarks> public MessageSender( ServiceBusConnectionStringBuilder connectionStringBuilder, RetryPolicy retryPolicy = null) : this(connectionStringBuilder?.GetNamespaceConnectionString(), connectionStringBuilder?.EntityPath, retryPolicy) { }
public static IHealthChecksBuilder AddCustomAzureServiceBusTopic(this IHealthChecksBuilder builder, IConfiguration configuration) { var connectionString = new ServiceBusConnectionStringBuilder(configuration.GetAzureServiceBusConnectionString()); return(builder.AddAzureServiceBusTopic(connectionString.GetNamespaceConnectionString(), connectionString.EntityPath)); }