private static async Task CreateQueue() { try { if (string.IsNullOrEmpty(namespaceName)) { throw new Exception("Namespace name is empty!"); } var token = await GetToken(); var creds = new TokenCredentials(token); var sbClient = new ServiceBusManagementClient(creds) { SubscriptionId = appOptions.SubscriptionId, }; var queueParams = new SBQueue { EnablePartitioning = true }; Console.WriteLine("Creating queue..."); await sbClient.Queues.CreateOrUpdateAsync(resourceGroupName, namespaceName, QueueName, queueParams); Console.WriteLine("Created queue successfully."); } catch (Exception e) { Console.WriteLine("Could not create a queue..."); Console.WriteLine(e.Message); throw e; } }
private static async Task CriarQueueSeNaoExistir() { try { if (string.IsNullOrEmpty(namespaceName)) { throw new Exception("Namespace nao existe!"); } var token = await GetToken(); var creds = new TokenCredentials(token); var sbClient = new ServiceBusManagementClient(creds) { SubscriptionId = appOptions.SubscriptionId, }; var queueParams = new SBQueue { EnablePartitioning = true }; await sbClient.Queues.CreateOrUpdateAsync(resourceGroupName, namespaceName, queueName, queueParams); } catch (Exception e) { throw new Exception("Nao foi possivel criar fila a queue..."); } }
/// <summary> /// Creates a Service Bus scope associated with a queue instance, intended to be used in the context /// of a single test and disposed when the test has completed. /// </summary> /// /// <param name="enablePartitioning">When <c>true</c>, partitioning will be enabled on the queue that is created.</param> /// <param name="enableSession">When <c>true</c>, a session will be enabled on the queue that is created.</param> /// <param name="forceQueueCreation">When <c>true</c>, forces creation of a new queue even if an environmental override was specified to use an existing one.</param> /// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param> /// /// <returns>The requested Service Bus <see cref="QueueScope" />.</returns> /// /// <remarks> /// If an environmental override was set to use an existing Service Bus queue resource and the <paramref name="forceQueueCreation" /> flag /// was not set, the existing queue will be assumed with no validation. In this case the <paramref name="enablePartitioning" /> and /// <paramref name="enableSession" /> parameters are also ignored. /// </remarks> /// public static async Task <QueueScope> CreateWithQueue(bool enablePartitioning, bool enableSession, bool forceQueueCreation = false, TimeSpan?lockDuration = default, string overrideNamespace = default, [CallerMemberName] string caller = "") { // Create a new queue specific to the scope being created. caller = (caller.Length < 16) ? caller : caller.Substring(0, 15); var azureSubscription = ServiceBusTestEnvironment.Instance.SubscriptionId; var resourceGroup = ServiceBusTestEnvironment.Instance.ResourceGroup; var serviceBusNamespace = overrideNamespace ?? ServiceBusTestEnvironment.Instance.ServiceBusNamespace; var token = await AcquireManagementTokenAsync().ConfigureAwait(false); string CreateName() => $"{ Guid.NewGuid().ToString("D").Substring(0, 13) }-{ caller }"; using (var client = new ServiceBusManagementClient(ResourceManagerUri, new TokenCredentials(token)) { SubscriptionId = azureSubscription }) { var queueParameters = new SBQueue(enablePartitioning: enablePartitioning, requiresSession: enableSession, maxSizeInMegabytes: 1024, lockDuration: lockDuration); var queue = await CreateRetryPolicy <SBQueue>().ExecuteAsync(() => client.Queues.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, CreateName(), queueParameters)).ConfigureAwait(false); return(new QueueScope(serviceBusNamespace, queue.Name, true)); } }
public QueueAttributes(SBQueue quResource) { if (quResource != null) { Name = quResource.Name; LockDuration = XmlConvert.ToString((TimeSpan)quResource.LockDuration); AccessedAt = quResource.AccessedAt; AutoDeleteOnIdle = XmlConvert.ToString((TimeSpan)quResource.AutoDeleteOnIdle); CreatedAt = quResource.CreatedAt; DefaultMessageTimeToLive = XmlConvert.ToString((TimeSpan)quResource.DefaultMessageTimeToLive); DuplicateDetectionHistoryTimeWindow = XmlConvert.ToString((TimeSpan)quResource.DuplicateDetectionHistoryTimeWindow); DeadLetteringOnMessageExpiration = quResource.DeadLetteringOnMessageExpiration; EnableExpress = quResource.EnableExpress; EnablePartitioning = quResource.EnablePartitioning; MaxDeliveryCount = quResource.MaxDeliveryCount; MaxSizeInMegabytes = quResource.MaxSizeInMegabytes; MessageCount = quResource.MessageCount; CountDetails = quResource.CountDetails; RequiresDuplicateDetection = quResource.RequiresDuplicateDetection; RequiresSession = quResource.RequiresSession; SizeInBytes = quResource.SizeInBytes; Status = quResource.Status; UpdatedAt = quResource.UpdatedAt; #pragma warning disable 612, 618 IsAnonymousAccessible = false; SupportOrdering = false; EnableBatchedOperations = false; EntityAvailabilityStatus = "Available"; #pragma warning restore 612, 618 } }
public QueueAttributes(SBQueue quResource) { if (quResource != null) { Name = quResource.Name; LockDuration = XmlConvert.ToString((TimeSpan)quResource.LockDuration); AccessedAt = quResource.AccessedAt; AutoDeleteOnIdle = XmlConvert.ToString((TimeSpan)quResource.AutoDeleteOnIdle); CreatedAt = quResource.CreatedAt; DefaultMessageTimeToLive = XmlConvert.ToString((TimeSpan)quResource.DefaultMessageTimeToLive); DuplicateDetectionHistoryTimeWindow = XmlConvert.ToString((TimeSpan)quResource.DuplicateDetectionHistoryTimeWindow); DeadLetteringOnMessageExpiration = quResource.DeadLetteringOnMessageExpiration; EnableExpress = quResource.EnableExpress; EnablePartitioning = quResource.EnablePartitioning; MaxDeliveryCount = quResource.MaxDeliveryCount; MaxSizeInMegabytes = quResource.MaxSizeInMegabytes; MessageCount = quResource.MessageCount; CountDetails = quResource.CountDetails; RequiresDuplicateDetection = quResource.RequiresDuplicateDetection; RequiresSession = quResource.RequiresSession; SizeInBytes = quResource.SizeInBytes; Status = quResource.Status; UpdatedAt = quResource.UpdatedAt; } }
/// <summary> /// Creates a Service Bus scope associated with a queue instance, intended to be used in the context /// of a single test and disposed when the test has completed. /// </summary> /// /// <param name="enablePartitioning">When <c>true</c>, partitioning will be enabled on the queue that is created.</param> /// <param name="enableSession">When <c>true</c>, a session will be enabled on the queue that is created.</param> /// <param name="forceQueueCreation">When <c>true</c>, forces creation of a new queue even if an environmental override was specified to use an existing one.</param> /// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param> /// /// <returns>The requested Service Bus <see cref="QueueScope" />.</returns> /// /// <remarks> /// If an environmental override was set to use an existing Service Bus queue resource and the <paramref name="forceQueueCreation" /> flag /// was not set, the existing queue will be assumed with no validation. In this case the <paramref name="enablePartitioning" /> and /// <paramref name="enableSession" /> parameters are also ignored. /// </remarks> /// public static async Task <QueueScope> CreateWithQueue(bool enablePartitioning, bool enableSession, bool forceQueueCreation = false, [CallerMemberName] string caller = "") { // If there was an override and the force flag is not set for creation, then build a scope // for the specified queue. if ((!string.IsNullOrEmpty(TestEnvironment.OverrideQueueName)) && (!forceQueueCreation)) { return(new QueueScope(TestEnvironment.ServiceBusNamespace, TestEnvironment.OverrideQueueName, false)); } // Create a new queue specific to the scope being created. caller = (caller.Length < 16) ? caller : caller.Substring(0, 15); var azureSubscription = TestEnvironment.ServiceBusAzureSubscription; var resourceGroup = TestEnvironment.ServiceBusResourceGroup; var serviceBusNamespace = TestEnvironment.ServiceBusNamespace; var token = await AquireManagementTokenAsync().ConfigureAwait(false); string CreateName() => $"{ Guid.NewGuid().ToString("D").Substring(0, 13) }-{ caller }"; using (var client = new ServiceBusManagementClient(new TokenCredentials(token)) { SubscriptionId = azureSubscription }) { var queueParameters = new SBQueue(enablePartitioning: enablePartitioning, requiresSession: enableSession, maxSizeInMegabytes: 1024); var queue = await CreateRetryPolicy <SBQueue>().ExecuteAsync(() => client.Queues.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, CreateName(), queueParameters)).ConfigureAwait(false); return(new QueueScope(serviceBusNamespace, queue.Name, true)); } }
public PSQueueAttributes CreateUpdateQueue(string resourceGroupName, string namespaceName, string queueName, PSQueueAttributes queue) { SBQueue parameters = new SBQueue(); if (queue.LockDuration != null) { parameters.LockDuration = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.LockDuration); } if (queue.AutoDeleteOnIdle != null) { parameters.AutoDeleteOnIdle = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.AutoDeleteOnIdle); } if (queue.DefaultMessageTimeToLive != null) { parameters.DefaultMessageTimeToLive = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.DefaultMessageTimeToLive); } if (queue.DuplicateDetectionHistoryTimeWindow != null) { parameters.DuplicateDetectionHistoryTimeWindow = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.DuplicateDetectionHistoryTimeWindow); } if (queue.DeadLetteringOnMessageExpiration.HasValue) { parameters.DeadLetteringOnMessageExpiration = queue.DeadLetteringOnMessageExpiration; } if (queue.EnableExpress.HasValue) { parameters.EnableExpress = queue.EnableExpress; } if (queue.EnablePartitioning.HasValue) { parameters.EnablePartitioning = queue.EnablePartitioning; } if (queue.MaxDeliveryCount.HasValue) { parameters.MaxDeliveryCount = queue.MaxDeliveryCount; } if (queue.MaxSizeInMegabytes.HasValue) { parameters.MaxSizeInMegabytes = queue.MaxSizeInMegabytes; } if (queue.RequiresDuplicateDetection.HasValue) { parameters.RequiresDuplicateDetection = queue.RequiresDuplicateDetection; } if (queue.RequiresSession.HasValue) { parameters.RequiresSession = queue.RequiresSession; } if (queue.Status.HasValue) { parameters.Status = queue.Status; } SBQueue response = Client.Queues.CreateOrUpdate(resourceGroupName, namespaceName, queueName, parameters); return(new PSQueueAttributes(response)); }
public PSQueueAttributes UpdateQueue(string resourceGroupName, string namespaceName, string queueName, string location, bool enableExpress, bool isAnonymousAccessible) { SBQueue parameters = new SBQueue() { EnableExpress = enableExpress }; var response = Client.Queues.CreateOrUpdate(resourceGroupName, namespaceName, queueName, parameters); return(new PSQueueAttributes(response)); }
internal async Task CreateQueueAsync(string name) { var pars = new SBQueue() { AutoDeleteOnIdle = TimeSpan.FromMinutes(30) }; await _client.Queues.CreateOrUpdateAsync( _identifier.ResourceGroupName, _identifier.Name, name, pars); }
private static async Task CreateQueue() { try { if (string.IsNullOrEmpty(namespaceName)) { throw new Exception("Namespace name is empty!"); } var token = await GetToken(); var creds = new TokenCredentials(token); var sbClient = new ServiceBusManagementClient(creds) { SubscriptionId = appOptions.SubscriptionId, }; var queueParams = new SBQueue { EnablePartitioning = false, DeadLetteringOnMessageExpiration = true, MaxSizeInMegabytes = 1024 }; Console.WriteLine("Creating queue..."); foreach (var fila in appOptions.Queues) { try { await sbClient.Queues.CreateOrUpdateAsync(resourceGroupName, namespaceName, fila, queueParams); //var queueExists = await sbClient.Queues.GetAsync(resourceGroupName, namespaceName, QueueName); Console.WriteLine("Created queue successfully."); } catch (Exception e) { Console.WriteLine("Could not create a queue..."); } } } catch (Exception e) { Console.WriteLine("Could not create a queue..."); Console.WriteLine(e.Message); throw e; } }
public async Task CreateQueue(string queueName) { try { using (var sbClient = await GetServiceManagementClient()) { var queueParams = new SBQueue { EnablePartitioning = true, RequiresSession = true }; await sbClient.Queues.CreateOrUpdateAsync(appOptions.ResourceGroupName, appOptions.NamespaceName, queueName, queueParams); } } catch (Exception e) { throw e; } }
private async Task EnsureQueue() { var context = new AuthenticationContext($"https://login.microsoftonline.com/{_tenantId}"); var token = await context.AcquireTokenAsync("https://management.azure.com/", new ClientCredential(_clientId, _clientSecret)); var creds = new TokenCredentials(token.AccessToken); var sbClient = new ServiceBusManagementClient(creds) { SubscriptionId = _subscriptionId }; var queueParams = new SBQueue() { LockDuration = _lockDurationInSeconds, MaxDeliveryCount = _maxDeliveryCount, EnableExpress = _enableExpress, EnableBatchedOperations = _enableBatchOperations }; await sbClient.Queues.CreateOrUpdateAsync(_resourceGroup, _namespaceName, _queueName, queueParams); }
/// <summary> /// Creates or updates a Service Bus queue. This operation is idempotent. /// <see href="https://msdn.microsoft.com/en-us/library/azure/mt639395.aspx" /> /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// Name of the Resource group within the Azure subscription. /// </param> /// <param name='namespaceName'> /// The namespace name /// </param> /// <param name='queueName'> /// The queue name. /// </param> /// <param name='parameters'> /// Parameters supplied to create or update a queue resource. /// </param> public static SBQueue CreateOrUpdate(this IQueuesOperations operations, string resourceGroupName, string namespaceName, string queueName, SBQueue parameters) { return(operations.CreateOrUpdateAsync(resourceGroupName, namespaceName, queueName, parameters).GetAwaiter().GetResult()); }
public PSQueueAttributes GetQueue(string resourceGroupName, string namespaceName, string queueName) { SBQueue response = Client.Queues.Get(resourceGroupName, namespaceName, queueName); return(new PSQueueAttributes(response)); }
public void QueuesCreateGetUpdateDelete() { using (MockContext context = MockContext.Start(this.GetType().FullName)) { InitializeClients(context); var location = this.ResourceManagementClient.GetLocationFromProvider(); var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location); if (string.IsNullOrWhiteSpace(resourceGroup)) { resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix); this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup); } // Create Namespace var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix); var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName, new SBNamespace() { Location = location, Sku = new SBSku { Name = SkuName.Standard, Tier = SkuTier.Standard } }); Assert.NotNull(createNamespaceResponse); Assert.Equal(createNamespaceResponse.Name, namespaceName); TestUtilities.Wait(TimeSpan.FromSeconds(5)); // Create Queue var queueName = TestUtilities.GenerateName(ServiceBusManagementHelper.QueuesPrefix); var createQueueResponse = this.ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName, new SBQueue() { EnableExpress = true, EnableBatchedOperations = true }); Assert.NotNull(createQueueResponse); Assert.Equal(createQueueResponse.Name, queueName); Assert.True(createQueueResponse.EnableExpress); // Get the created Queue var getQueueResponse = ServiceBusManagementClient.Queues.Get(resourceGroup, namespaceName, queueName); Assert.NotNull(getQueueResponse); Assert.Equal(EntityStatus.Active, getQueueResponse.Status); Assert.Equal(getQueueResponse.Name, queueName); // Get all Queues var getQueueListAllResponse = ServiceBusManagementClient.Queues.ListByNamespace(resourceGroup, namespaceName); Assert.NotNull(getQueueListAllResponse); Assert.True(getQueueListAllResponse.Count() >= 1); Assert.True(getQueueListAllResponse.All(ns => ns.Id.Contains(resourceGroup))); // Create Queue1 var queueName1 = TestUtilities.GenerateName(ServiceBusManagementHelper.QueuesPrefix); var createQueueResponse1 = this.ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName1, new SBQueue() { EnableExpress = true }); // Update Queue. var updateQueuesParameter = new SBQueue() { EnableExpress = true, MaxDeliveryCount = 5, MaxSizeInMegabytes = 1024, ForwardTo = queueName1, ForwardDeadLetteredMessagesTo = queueName1 }; var updateQueueResponse = ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName, updateQueuesParameter); Assert.NotNull(updateQueueResponse); Assert.True(updateQueueResponse.EnableExpress); Assert.Equal(updateQueueResponse.ForwardTo, queueName1); Assert.Equal(updateQueueResponse.ForwardDeadLetteredMessagesTo, queueName1); // Delete Created Queue ServiceBusManagementClient.Queues.Delete(resourceGroup, namespaceName, queueName); //Delete Namespace Async ServiceBusManagementClient.Namespaces.DeleteWithHttpMessagesAsync(resourceGroup, namespaceName, null, new CancellationToken()).ConfigureAwait(false); } }
private SBQueue CreateQueueDescription() { var qd = new SBQueue(_options.Name) { LockDuration = _options.WorkItemTimeout, MaxDeliveryCount = _options.Retries + 1 }; if (_options.AutoDeleteOnIdle.HasValue) { qd.AutoDeleteOnIdle = _options.AutoDeleteOnIdle.Value; } if (_options.DefaultMessageTimeToLive.HasValue) { qd.DefaultMessageTimeToLive = _options.DefaultMessageTimeToLive.Value; } if (_options.DuplicateDetectionHistoryTimeWindow.HasValue) { qd.DuplicateDetectionHistoryTimeWindow = _options.DuplicateDetectionHistoryTimeWindow.Value; } // todo : https://github.com/Azure/azure-service-bus/issues/88 //if (_options.EnableBatchedOperations.HasValue) // qd.EnableBatchedOperations = _options.EnableBatchedOperations.Value; if (_options.EnableDeadLetteringOnMessageExpiration.HasValue) { qd.DeadLetteringOnMessageExpiration = _options.EnableDeadLetteringOnMessageExpiration.Value; } if (_options.EnableExpress.HasValue) { qd.EnableExpress = _options.EnableExpress.Value; } if (_options.EnablePartitioning.HasValue) { qd.EnablePartitioning = _options.EnablePartitioning.Value; } //if (!String.IsNullOrEmpty(_options.ForwardDeadLetteredMessagesTo)) // qd.ForwardDeadLetteredMessagesTo = _options.ForwardDeadLetteredMessagesTo; //if (!String.IsNullOrEmpty(_options.ForwardTo)) // qd.ForwardTo = _options.ForwardTo; //if (_options.IsAnonymousAccessible.HasValue) //qd.IsAnonymousAccessible = _options.IsAnonymousAccessible.Value; if (_options.MaxSizeInMegabytes.HasValue) { qd.MaxSizeInMegabytes = Convert.ToInt32(_options.MaxSizeInMegabytes.Value); } if (_options.RequiresDuplicateDetection.HasValue) { qd.RequiresDuplicateDetection = _options.RequiresDuplicateDetection.Value; } if (_options.RequiresSession.HasValue) { qd.RequiresSession = _options.RequiresSession.Value; } if (_options.Status.HasValue) { qd.Status = _options.Status.Value; } //if (_options.SupportOrdering.HasValue) // qd.SupportOrdering = _options.SupportOrdering.Value; //if (!String.IsNullOrEmpty(_options.UserMetadata)) // qd.UserMetadata = _options.UserMetadata; return(qd); }
/// <summary> /// Creates or updates a Service Bus queue. This operation is idempotent. /// <see href="https://msdn.microsoft.com/en-us/library/azure/mt639395.aspx" /> /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// Name of the Resource group within the Azure subscription. /// </param> /// <param name='namespaceName'> /// The namespace name /// </param> /// <param name='queueName'> /// The queue name. /// </param> /// <param name='parameters'> /// Parameters supplied to create or update a queue resource. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <SBQueue> CreateOrUpdateAsync(this IQueuesOperations operations, string resourceGroupName, string namespaceName, string queueName, SBQueue parameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, namespaceName, queueName, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public async Task <IActionResult> Post([FromBody] Order order) { bool listenForResponse = Boolean.TryParse(Request.Headers["ImplementAsyncRequestResponseMessaging"], out listenForResponse); var topicClient = new TopicClient(_appSettings.ServiceBusConnectionString, _appSettings.OrderTopicName); try { if (order == null) { return(BadRequest()); } var message = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(order))); message.MessageId = Guid.NewGuid().ToString(); if (listenForResponse) { var responseSessionID = order.Id.ToString(); var tenantId = _appSettings.TenantId; var clientId = _appSettings.ClientId; var clientSecret = _appSettings.ClientSecret; var context = new AuthenticationContext($"https://login.microsoftonline.com/{tenantId}"); var result = await context.AcquireTokenAsync( "https://management.core.windows.net/", new ClientCredential(clientId, clientSecret)); var creds = new TokenCredentials(result.AccessToken); var sbClient = new ServiceBusManagementClient(creds) { SubscriptionId = _appSettings.SubscriptionId }; var queueParams = new SBQueue() { DeadLetteringOnMessageExpiration = true, RequiresSession = true, DefaultMessageTimeToLive = TimeSpan.FromMilliseconds(20000) }; await sbClient.Queues.CreateOrUpdateAsync(_appSettings.ResourceGroupName, _appSettings.ServiceBusNamespace, responseSessionID, queueParams); var sessionClient = new SessionClient(_appSettings.ServiceBusConnectionString, responseSessionID); var session = await sessionClient.AcceptMessageSessionAsync(responseSessionID); await topicClient.SendAsync(message); var responseMessage = await session.ReceiveAsync(); if (responseMessage != null) { var orderResponse = JsonConvert.DeserializeObject <OrderResponse>(Encoding.UTF8.GetString(responseMessage.Body)); await session.CompleteAsync(responseMessage.SystemProperties.LockToken); await sbClient.Queues.DeleteAsync(_appSettings.ResourceGroupName, _appSettings.ServiceBusNamespace, responseSessionID); await sessionClient.CloseAsync(); return(new JsonResult(orderResponse)); } } await topicClient.SendAsync(message); return(Ok()); } catch (Exception ex) { return(StatusCode(500)); } finally { await topicClient.CloseAsync(); } }