static void Main(string[] args)
{
NamespaceManager manager = NamespaceManager.Create(); // Automatycznie bierze informacje z App.config
//Wolę na początku - wygodniej "zaczynamy" zawsze od zera
manager.DeleteTopic("obliczenia"); //Kasuje temat i subskrypcje
manager.DeleteQueue("wynik");
//Tworzenie Topics - tematu
TopicDescription td = new TopicDescription("obliczenia");
//Nie przewidujemy dużego ruchu nie wymagamy partycjonowania
td.EnablePartitioning = false;
//Wymagamy wykrywania duplikatów - by klient 2 razy nie wysłał tego samego polecenia
td.RequiresDuplicateDetection = true;
//Nie pozwalamy na tematy tylko w pamięci; chcemy żeby klient był pewien że wysłał wiadomość = wiadomość zostanie przetworzona
td.EnableExpress = false;
manager.CreateTopic(td); //Tworzenie tematu
//Suma i średnia będzie wyliczana gdy opowiednia własciwość zostanie zdefiniowana
manager.CreateSubscription("obliczenia", "suma", new SqlFilter("suma=1"));
manager.CreateSubscription("obliczenia", "srednia", new SqlFilter("srednia=1"));
//Ale zawsze będą liczone elementy w komunikacie
manager.CreateSubscription("obliczenia", "liczba");
QueueDescription qd = new QueueDescription("wynik");
qd.RequiresSession = true;
manager.CreateQueue(qd);
}
public string GetQueuePath(QueueDescription queueDescription)
{
IEnumerable<string> segments = new[] {_settings.ServiceUri.AbsolutePath.Trim('/'), queueDescription.Path.Trim('/')}
.Where(x => x.Length > 0);
return string.Join("/", segments);
}
public ActionResult Newsletter(string email)
{
var nm = NamespaceManager.CreateFromConnectionString(ConnectionString);
QueueDescription qd = new QueueDescription(qname);
qd.MaxSizeInMegabytes = 2048;
qd.DefaultMessageTimeToLive = new TimeSpan(0, 5, 0);
if (!nm.QueueExists(qname))
{
nm.CreateQueue(qd);
}
//Send to the queue
QueueClient qc = QueueClient.CreateFromConnectionString(ConnectionString, qname);
// Create amessage with email property
var bm = new BrokeredMessage();
bm.Properties["email"] = email;
qc.Send(bm);
ViewBag.email = email;
return View();
}
public void LoadConfig()
{
Trace.TraceInformation("Initializing and configuring Azure service bus queue");
string connectionString =
CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
var namespaceManager =
NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(QueueName))
{
namespaceManager.CreateQueue(QueueName);
}
// Configure Queue Settings
QueueDescription qd = new QueueDescription(QueueName)
{
MaxSizeInMegabytes = 5120,
DefaultMessageTimeToLive = new TimeSpan(0, 1, 0)
};
WorkHistoryDataTable = new DataSetMobile.WorkHistoryDataTable();
WorkHistoryTableAdapter = new WorkHistoryTableAdapter();
Trace.TraceInformation("Creating queue client from service bus connection string");
MobleQueueClient =
QueueClient.CreateFromConnectionString(connectionString, QueueName);
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
MefLoader.Initialize();
// Create the queue if it does not exist already
string connectionString = CloudConfigurationManager.GetSetting("ServiceBus");
string queueName = ConfigurationsSelector.GetSetting("Customer.Queue");
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
QueueDescription queueDescription = new QueueDescription(queueName)
{
MaxSizeInMegabytes = 1024,
DefaultMessageTimeToLive = TimeSpan.FromMinutes(10),
EnablePartitioning = false, //I want to ensure the messages will processed in the right order
EnableDeadLetteringOnMessageExpiration = true,
LockDuration = TimeSpan.FromMinutes(5)
};
if (!namespaceManager.QueueExists(queueName))
namespaceManager.CreateQueue(queueDescription);
// Initialize the connection to Service Bus Queue
_client = QueueClient.CreateFromConnectionString(connectionString, queueName);
return base.OnStart();
}
private static void QueueMessage(string messageType, VirtualMachine virtualMachine)
{
if (VirtualMachine.IsValid(virtualMachine) == false)
{
throw new ArgumentException("Invalid virtual machine.", "virtualMachine");
}
var connectionString = CloudConfigurationManager.GetSetting("ServiceBus.ConnectionString");
var queueName = CloudConfigurationManager.GetSetting("QueueName");
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(queueName))
{
var queue = new QueueDescription(queueName)
{
DefaultMessageTimeToLive = new TimeSpan(7, 0, 0, 0)
};
namespaceManager.CreateQueue(queue);
}
var message = PrepareMessage(messageType, virtualMachine);
var client = QueueClient.CreateFromConnectionString(connectionString, queueName);
client.Send(message);
}
public Consumer()
{
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your Issuer Name: ");
string issuerName = Console.ReadLine();
Console.Write("Your Issuer Secret: ");
string issuerSecret = Console.ReadLine();
// Configure queue settings.
this.queueDescription = new QueueDescription(MyQueuePath);
// Setting Max Size and TTL for demonstration purpose
// but can be changed per user discretion to suite their system needs.
// Refer service bus documentation to understand the limitations.
// Setting Queue max size to 1GB where as default Max Size is 5GB.
this.queueDescription.MaxSizeInMegabytes = 1024;
// Setting message TTL to 5 days where as default TTL is 14 days.
this.queueDescription.DefaultMessageTimeToLive = TimeSpan.FromDays(5);
// Create management credentials.
this.credential = new TransportClientEndpointBehavior()
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret)
};
// Create the URI for the queue.
this.namespaceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, String.Empty);
Console.WriteLine("Service Bus Namespace Uri address '{0}'", this.namespaceUri.AbsoluteUri);
}
private async static Task QueueShouldExistAsync(NamespaceManager ns, QueueDescription queueDescription)
{
if (!await ns.QueueExistsAsync(queueDescription.Path))
{
throw new MessagingEntityNotFoundException("Queue: " + queueDescription.Path);
}
}
public QueueClient Create(Address address)
{
var queueName = address.Queue;
try
{
if (!NamespaceClient.QueueExists(queueName))
{
var description = new QueueDescription(queueName)
{
LockDuration = LockDuration,
MaxSizeInMegabytes = MaxSizeInMegabytes,
RequiresDuplicateDetection = RequiresDuplicateDetection,
RequiresSession = RequiresSession,
DefaultMessageTimeToLive = DefaultMessageTimeToLive,
EnableDeadLetteringOnMessageExpiration = EnableDeadLetteringOnMessageExpiration,
DuplicateDetectionHistoryTimeWindow = DuplicateDetectionHistoryTimeWindow,
MaxDeliveryCount = MaxDeliveryCount,
EnableBatchedOperations = EnableBatchedOperations
};
NamespaceClient.CreateQueue(description);
}
}
catch (MessagingEntityAlreadyExistsException)
{
// the queue already exists or another node beat us to it, which is ok
}
var client = Factory.CreateQueueClient(queueName, ReceiveMode.PeekLock);
client.PrefetchCount = 100; // todo make configurable
return client;
}
public bool Equals(QueueDescription other)
{
if (ReferenceEquals(null, other))
return false;
if (ReferenceEquals(this, other))
return true;
return Equals(other.Path, Path);
}
public void Connect(string connectionString, string queueName, QueueDescription queueDescription = null)
{
this.VerifyQueue(connectionString, queueName, queueDescription);
this.serviceBus.Connect(connectionString, queueName);
this.AddServiceBusSubscription();
}
static IEnumerable<string> GetQueryStringOptions(QueueDescription settings)
{
if (settings.EnableExpress)
yield return "express=true";
if (settings.AutoDeleteOnIdle > TimeSpan.Zero)
yield return $"autodelete={settings.AutoDeleteOnIdle.TotalSeconds}";
}
public async Task <QueueDefinition> CreateQueue(IWorkContext context, QueueDefinition queueDefinition)
{
context.Verify(nameof(context)).IsNotNull();
queueDefinition.Verify(nameof(queueDefinition)).IsNotNull();
QueueDescription createdDescription = await _managementClient.CreateQueueAsync(queueDefinition.ConvertTo(), context.CancellationToken);
return(createdDescription.ConvertTo());
}
public void CreateAndDeleteQueue_WhenUserHasManagePermission_Success()
{
string queueName = Guid.NewGuid().ToString();
var queue = new QueueDescription(queueName);
NamespaceManager nsManager = ServiceBusHelper.GetNamespaceManager();
nsManager.CreateQueue(queue);
nsManager.DeleteQueue(queueName);
}
static void CreateQueue(Uri baseAddress,string queueName,QueueDescription queueDescription,TokenProvider credentials)
{
if(QueueExists(baseAddress,queueName,credentials))
{
DeleteQueue(baseAddress,queueName,credentials);
}
NamespaceManager namespaceClient = new NamespaceManager(baseAddress,credentials);
namespaceClient.CreateQueue(queueDescription);
}
public void CreateQueue_WhenUserDoesNotHaveManagePermission_UnauthorizedAccessExceptionIsThrown()
{
string queueName = Guid.NewGuid().ToString();
var queue = new QueueDescription(queueName);
NamespaceManager nsManager = GetNamespaceManagerWithCustomCredentials(TestUsers.User1);
Assert.Throws<UnauthorizedAccessException>(() => nsManager.CreateQueue(queue));
}
static void CreateQueue(NamespaceManager namespaceManager, string path, bool requiresSessions,
int maxDeliveryCount)
{
var description = new QueueDescription(path);
description.RequiresSession = requiresSessions;
description.MaxDeliveryCount = maxDeliveryCount;
namespaceManager.CreateQueue(description);
}
public static Uri GetInputAddress(this ServiceBusHostSettings hostSettings, QueueDescription queueDescription)
{
var builder = new UriBuilder(hostSettings.ServiceUri);
builder.Path += queueDescription.Path;
builder.Query += string.Join("&", GetQueryStringOptions(queueDescription));
return builder.Uri;
}
private async static Task QueueCreateAsync(NamespaceManager ns, QueueDescription queueDescription)
{
if (!await ns.QueueExistsAsync(queueDescription.Path))
{
await ns.CreateQueueAsync(queueDescription);
ServiceBusEventSource.Log.CreatedQueue(ns.Address.ToString(), queueDescription.Path);
}
}
public async Task <QueueDefinition> GetQueue(IWorkContext context, string queueName)
{
context.Verify(nameof(context)).IsNotNull();
queueName.Verify(nameof(queueName)).IsNotEmpty();
QueueDescription queueDescription = await _managementClient.GetQueueAsync(queueName, context.CancellationToken);
return(queueDescription.ConvertTo());
}
CreateSendOnlyQueue(
string name)
{
var queueDescription = new QueueDescription(name) {
Status = EntityStatus.ReceiveDisabled
};
return await this.CreateQueueInternal(queueDescription);
}
public async static Task<QueueClient> EnsureQueueAsync(this MessagingFactory factory, QueueDescription queueDescription, ReceiveMode mode = ReceiveMode.PeekLock)
{
await new NamespaceManager(factory.Address, factory.GetSettings().TokenProvider)
.TryCreateEntity(
mgr => QueueCreateAsync(mgr, queueDescription),
mgr => QueueShouldExistAsync(mgr, queueDescription));
return factory.CreateQueueClient(queueDescription.Path, mode);
}
internal void EnsureQueueExists(string queuePath)
{
if (_knownQueues.Value.Contains(queuePath))
{
return;
}
lock (LockFor(queuePath))
{
if (_knownQueues.Value.Contains(queuePath))
{
return;
}
_logger.Debug("Creating queue '{0}'", queuePath);
var queueDescription = new QueueDescription(queuePath)
{
MaxDeliveryCount = _maxDeliveryAttempts,
DefaultMessageTimeToLive = TimeSpan.MaxValue,
EnableDeadLetteringOnMessageExpiration = true,
EnableBatchedOperations = true,
LockDuration = _defaultMessageLockDuration,
RequiresDuplicateDetection = false,
RequiresSession = false,
SupportOrdering = false,
AutoDeleteOnIdle = _autoDeleteOnIdle,
};
// We don't check for queue existence here because that introduces a race condition with any other bus participant that's
// launching at the same time. If it doesn't exist, we'll create it. If it does, we'll just continue on with life and
// update its configuration in a minute anyway. -andrewh 8/12/2013
try
{
_namespaceManager().CreateQueue(queueDescription);
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException exc)
{
if (!exc.Message.Contains("SubCode=40901"))
{
throw;
}
// SubCode=40901. Another conflicting operation is in progress. Let's see if it's created the queue for us.
if (!_namespaceManager().QueueExists(queuePath))
{
throw new BusException("Queue creation for '{0}' failed".FormatWith(queuePath), exc);
}
}
_knownQueues.Value.Add(queuePath);
}
}
private static async Task OverrideQueueLockDuration(string queuePath, string connectionString)
{
var managementClient = new ManagementClient(connectionString);
var queueDescription = new QueueDescription(queuePath)
{
LockDuration = TimeSpan.FromSeconds(30)
};
await managementClient.UpdateQueueAsync(queueDescription).ConfigureAwait(false);
}
public void UpdateQueue([FromBody] QueueDetails queueData)
{
NamespaceManager namespaceManager = CreateNamespaceManager();
QueueDescription description = namespaceManager.GetQueue(queueData.name);
queueData.ApplyChangesToDescription(description);
namespaceManager.UpdateQueue(description);
}
public async Task <QueueDefinition> Create(QueueDefinition queueDefinition, CancellationToken token)
{
queueDefinition.VerifyNotNull(nameof(queueDefinition));
QueueDescription createdDescription = await _managementClient.CreateQueueAsync(queueDefinition.ConvertTo(), token);
_logging.LogTrace($"{nameof(Create)}: QueueName={queueDefinition.QueueName}");
return(createdDescription.ConvertTo());
}
private async static Task QueueCreateAsync(NamespaceManager ns, QueueDescription queueDescription)
{
if (!await ns.QueueExistsAsync(queueDescription.Path).ConfigureAwait(false))
{
await ns.CreateQueueAsync(queueDescription)
.ConfigureAwait(false);
ServiceBusEventSource.Log.CreatedQueue(ns.Address.ToString(), queueDescription.Path);
}
}
private void buttonDeleteQueue_Click(object sender, RoutedEventArgs e)
{
if (MessageBox.Show("Are you sure you want to permanently delete this queue and all messages within it?", "Confirmation", MessageBoxButton.OKCancel, MessageBoxImage.Warning, MessageBoxResult.Cancel) == MessageBoxResult.OK)
{
MessageBox.Show("Deleted queues can take up to 60 seconds to be removed.", "Notice", MessageBoxButton.OK, MessageBoxImage.Information);
QueueDescription qd = (QueueDescription)this.gridQueues.SelectedItem;
this.queueAdmin.DeleteQueue(qd.Url);
}
}
private static QueueDescription CreateQueueDescription(bool sessionEnabled, string queueName)
{
var qd = new QueueDescription(queueName)
{
RequiresSession = sessionEnabled,
AutoDeleteOnIdle = TimeSpan.FromMinutes(5)
};
return(qd);
}
CreateSendOnlyQueue(
string name)
{
var queueDescription = new QueueDescription(name)
{
Status = EntityStatus.ReceiveDisabled
};
return(await this.CreateQueueInternal(queueDescription));
}
public void VerifyQueue(string connectionString, QueueDescription description)
{
var namespaceManager =
NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(description.Path))
{
namespaceManager.CreateQueue(description);
}
}
private static QueueClient CreateQueueClient(QueueDescription queueDescription)
{
Uri runtimeUri = ServiceBusEnvironment.CreateServiceUri("sb", Sender.serviceBusNamespace, string.Empty);
messagingFactory = MessagingFactory.Create(
runtimeUri,
TokenProvider.CreateSharedAccessSignatureTokenProvider(serviceBusKeyName, serviceBusKey));
return(messagingFactory.CreateQueueClient(queueDescription.Path));
}
public void PathToThrowsArgumentOutOfRangeException(string baseUrl, int lengthOfName)
{
var longName = string.Join(string.Empty, Enumerable.Repeat('a', lengthOfName));
var sub = new QueueDescription("Fake SubscriptionName");
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => sub.Name = $"{baseUrl}{longName}");
Assert.AreEqual($"Entity path '{longName}' exceeds the '260' character limit.{Environment.NewLine}Parameter name: Name", ex.Message);
Assert.AreEqual($"Name", ex.ParamName);
}
public void ForwardDeadLetteredMessagesToThrowsArgumentOutOfRangeException(string baseUrl, int lengthOfName)
{
var longName = string.Join(string.Empty, Enumerable.Repeat('a', lengthOfName));
var sub = new QueueDescription("Fake SubscriptionName");
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => sub.ForwardDeadLetteredMessagesTo = $"{baseUrl}{longName}");
Assert.StartsWith($"Entity path '{longName}' exceeds the '260' character limit.", ex.Message);
Assert.Equal($"ForwardDeadLetteredMessagesTo", ex.ParamName);
}
static void CreateQueue(Uri baseAddress, string queueName, QueueDescription queueDescription, TokenProvider credentials)
{
if (QueueExists(baseAddress, queueName, credentials))
{
DeleteQueue(baseAddress, queueName, credentials);
}
NamespaceManager namespaceClient = new NamespaceManager(baseAddress, credentials);
namespaceClient.CreateQueue(queueDescription);
}
public HandleQueueControl(MainForm mainForm, WriteToLogDelegate writeToLog, ServiceBusHelper serviceBusHelper, QueueDescription queueDescription, string path)
{
this.mainForm = mainForm;
this.writeToLog = writeToLog;
this.serviceBusHelper = serviceBusHelper;
this.path = path;
this.queueDescription = queueDescription;
InitializeComponent();
InitializeData();
}
public static async Task<QueueDescription> CreateQueueSafeAsync(this NamespaceManager namespaceManager, QueueDescription queueDescription)
{
var create = true;
try
{
queueDescription = await namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
create = false;
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
var created = false;
try
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Creating queue {0}", queueDescription.Path);
queueDescription = await namespaceManager.CreateQueueAsync(queueDescription).ConfigureAwait(false);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
throw;
}
if (!created)
queueDescription = await namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Queue: {0} ({1})", queueDescription.Path,
string.Join(", ", new[]
{
queueDescription.EnableExpress ? "express" : "",
queueDescription.RequiresDuplicateDetection ? "dupe detect" : "",
queueDescription.EnableDeadLetteringOnMessageExpiration ? "dead letter" : "",
queueDescription.RequiresSession ? "session" : ""
}.Where(x => !string.IsNullOrWhiteSpace(x))));
}
return queueDescription;
}
public async Task ServiceBus_Node_DoesNotExhaustConnections()
{
var connectionString = Environment.GetEnvironmentVariable("AzureWebJobsServiceBus");
NamespaceManager manager = NamespaceManager.CreateFromConnectionString(connectionString);
// Start with an empty queue
await manager.DeleteQueueAsync("node");
// Pre-create the queue as we can end up with 409s if a bunch of requests
// try to create the queue at once
await manager.CreateQueueAsync("node");
int i = 0, j = 0, lastConnectionCount = 0, lastConnectionLimit = 0;
using (var client = CreateClient())
{
// make this longer as we'll start seeing long timeouts from Service Bus upon failure.
client.Timeout = TimeSpan.FromMinutes(5);
// max connections in dynamic is currently 300
for (i = 0; i < 25; i++)
{
List <Task <HttpResponseMessage> > requestTasks = new List <Task <HttpResponseMessage> >();
for (j = 0; j < 25; j++)
{
requestTasks.Add(client.GetAsync($"api/ServiceBusNode?code={_fixture.FunctionDefaultKey}"));
}
await Task.WhenAll(requestTasks);
foreach (var requestTask in requestTasks)
{
HttpResponseMessage response = await requestTask;
JObject result = await response.Content.ReadAsAsync <JObject>();
if (response.IsSuccessStatusCode)
{
// store these off for error details
lastConnectionCount = (int)result["connections"];
lastConnectionLimit = (int)result["connectionLimit"];
// make sure we have the correct limit
Assert.Equal(300, lastConnectionLimit);
}
Assert.True(response.IsSuccessStatusCode, $"Error: {response.StatusCode}, Last successful response: Connections: {lastConnectionCount}, ConnectionLimit: {lastConnectionLimit}");
}
}
}
QueueDescription queueDescription = manager.GetQueue("node");
Assert.Equal(i * j, queueDescription.MessageCountDetails.ActiveMessageCount);
}
public AzureServiceBusQueue(string connectionString, string queueName = null, int retries = 2, TimeSpan?workItemTimeout = null, bool shouldRecreate = false, RetryPolicy retryPolicy = null, ISerializer serializer = null, IEnumerable <IQueueBehavior <T> > behaviors = null, ILoggerFactory loggerFactory = null) : base(serializer, behaviors, loggerFactory)
{
_queueName = queueName ?? typeof(T).Name;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
_retries = retries;
if (workItemTimeout.HasValue && workItemTimeout.Value < TimeSpan.FromMinutes(5))
{
_workItemTimeout = workItemTimeout.Value;
}
if (_namespaceManager.QueueExists(_queueName) && shouldRecreate)
{
_namespaceManager.DeleteQueue(_queueName);
}
if (!_namespaceManager.QueueExists(_queueName))
{
_queueDescription = new QueueDescription(_queueName)
{
MaxDeliveryCount = retries + 1,
LockDuration = _workItemTimeout
};
_namespaceManager.CreateQueue(_queueDescription);
}
else
{
_queueDescription = _namespaceManager.GetQueue(_queueName);
bool changes = false;
int newMaxDeliveryCount = retries + 1;
if (_queueDescription.MaxDeliveryCount != newMaxDeliveryCount)
{
_queueDescription.MaxDeliveryCount = newMaxDeliveryCount;
changes = true;
}
if (_queueDescription.LockDuration != _workItemTimeout)
{
_queueDescription.LockDuration = _workItemTimeout;
changes = true;
}
if (changes)
{
_namespaceManager.UpdateQueue(_queueDescription);
}
}
_queueClient = QueueClient.CreateFromConnectionString(connectionString, _queueDescription.Path);
if (retryPolicy != null)
{
_queueClient.RetryPolicy = retryPolicy;
}
}
private static void RegenerateKey(QueueDescription description, string ruleName, TextWriter log)
{
SharedAccessAuthorizationRule rule;
if (!description.Authorization.TryGetSharedAccessAuthorizationRule(ruleName, out rule))
throw new Exception($"Authorization rule {ruleName} was not found");
rule.SecondaryKey = rule.PrimaryKey;
rule.PrimaryKey = SharedAccessAuthorizationRule.GenerateRandomKey();
log.WriteLine($"Authorization rule: {ruleName}\nPrimary key: {rule.PrimaryKey}\nSecondary key: {rule.SecondaryKey}");
}
/// <summary>
/// Creates a new Queue using the managementClient with the name provided.
/// </summary>
private async Task CreateQueueAsync(string queueName)
{
// All the values have defaults and hence optional.
// The only required parameter is the path of the queue (in this case, queueName)
var queueDescription = new QueueDescription(queueName)
{
// The duration of a peek lock; that is, the amount of time that a message is locked from other receivers.
LockDuration = TimeSpan.FromSeconds(45),
// Size of the Queue. For non-partitioned entity, this would be the size of the queue.
// For partitioned entity, this would be the size of each partition.
MaxSizeInMB = 2048,
// This value indicates if the queue requires guard against duplicate messages.
// Find out more in DuplicateDetection sample
RequiresDuplicateDetection = false,
//Since RequiresDuplicateDetection is false, the following need not be specified and will be ignored.
//DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(2),
// This indicates whether the queue supports the concept of session.
// Find out more in "Session and Workflow Management Features" sample
RequiresSession = false,
// The default time to live value for the messages
// Find out more in "TimeToLive" sample.
DefaultMessageTimeToLive = TimeSpan.FromDays(7),
// Duration of idle interval after which the queue is automatically deleted.
AutoDeleteOnIdle = TimeSpan.MaxValue,
// Decides whether an expired message due to TTL should be dead-letterd
// Find out more in "TimeToLive" sample.
EnableDeadLetteringOnMessageExpiration = false,
// The maximum delivery count of a message before it is dead-lettered
// Find out more in "DeadletterQueue" sample
MaxDeliveryCount = 8,
// Creating only one partition.
// Find out more in PartitionedQueues sample.
EnablePartitioning = false
};
try
{
QueueDescription createdQueue = await managementClient.CreateQueueAsync(queueName).ConfigureAwait(false);
}
catch (ServiceBusException ex)
{
Console.WriteLine($"Encountered exception while creating Queue -\n{ex}");
throw;
}
}
private async Task CreateQueueIfNotExists()
{
bool queueExists = await _namespaceManager.QueueExistsAsync(_queueName);
if (queueExists == false)
{
var queueDescription = new QueueDescription(_queueName);
queueDescription.EnablePartitioning = false;
await _namespaceManager.CreateQueueAsync(queueDescription);
}
}
public void RenameQueue([FromBody] Rename names)
{
NamespaceManager namespaceManager = CreateNamespaceManager();
QueueDescription description = namespaceManager.GetQueue(names.oldName);
if (description.EnablePartitioning)
{
throw new Exception("Partitioned queues cannot be renamed.");
}
namespaceManager.RenameQueue(names.oldName, names.newName);
}
public static void PurgeQueue(Uri baseAddress, string queueName, TokenProvider credentials)
{
Debug.Assert(QueueExists(baseAddress, queueName, credentials));
NamespaceManager namespaceClient = new NamespaceManager(baseAddress, credentials);
QueueDescription description = namespaceClient.GetQueue(queueName);
DeleteQueue(baseAddress, queueName, credentials);
CreateQueue(baseAddress, queueName, description, credentials);
}
static void CreateQueue()
{
var ns = NamespaceManager.CreateFromConnectionString(connection);
if (!ns.QueueExists(queue))
{
var qd = new QueueDescription(queue);
qd.AutoDeleteOnIdle = new TimeSpan(1, 0, 0);
ns.CreateQueue(qd);
}
}
private static void CreateQueueIfDoesNotAlreadyExist(
this ServiceBusSettings settings,
QueueDescription queueDescription)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(settings.ConnectionString);
if (!namespaceManager.QueueExists(queueDescription.Path))
{
namespaceManager.CreateQueue(queueDescription);
}
}
public ActionResult SignUp(string userName)
{
if (string.IsNullOrEmpty(userName))
{
ViewBag.ErrorMessage = "You have to enter a name in the sign up box, stupid.";
return(View("Index"));
}
else
{
User user = new User(userName);
if (Session["balance"] != null && userName == (string)Session["UserName"])
{
user.Balance = (int)Session["balance"];
}
Session["UserName"] = userName;
var nm = NamespaceManager.CreateFromConnectionString(connectionString);
QueueDescription qd = new QueueDescription(qname);
//Ställ in Max size på queue på 2GB
qd.MaxSizeInMegabytes = 2048;
//Max Time To Live är 5 minuter
qd.DefaultMessageTimeToLive = new TimeSpan(0, 5, 0);
if (!nm.QueueExists(qname))
{
nm.CreateQueue(qd);
}
//Skicka till queue med hjälp av den connectionstring vi tidigare ställt in i configen
QueueClient qc = QueueClient.CreateFromConnectionString(connectionString, qname);
//Skapa msg med email properaty och skicka till QueueClient
var bm = new BrokeredMessage();
Session["balance"] = user.Balance;
bm.Properties["userName"] = user.UserName;
bm.Properties["balance"] = user.Balance;
bm.Properties["action"] = "create";
qc.Send(bm);
ViewBag.message = "Hello " + user.UserName + ".You have a balance of " + user.Balance + " USD";
var frogData = new FrogData();
var frogList = frogData.GetFrogList();
Session["frogList"] = frogList;
ViewBag.frogList = frogList;
return(View("Betting", frogList));
}
}
private static void CreateQueueIfDoesNotAlreadyExist(
this ServiceBusSettings settings,
QueueDescription queueDescription)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(settings.ConnectionString);
if (!namespaceManager.QueueExists(queueDescription.Path))
{
namespaceManager.CreateQueue(queueDescription);
}
}
AzureServiceBusEndpointAddress([NotNull] Data data,
AddressType addressType)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
_data = data;
_tp = TokenProvider.CreateSharedSecretTokenProvider(_data.UsernameIssuer,
_data.PasswordSharedSecret);
Uri sbUri = ServiceBusEnvironment.CreateServiceUri("sb", _data.Namespace, string.Empty);
var mfs = new MessagingFactorySettings
{
TokenProvider = _tp,
NetMessagingTransportSettings =
{
// todo: configuration setting
BatchFlushInterval = 50.Milliseconds()
},
OperationTimeout = 3.Seconds()
};
_mff = () => MessagingFactory.Create(sbUri, mfs);
_nm = new NamespaceManager(sbUri, _tp);
string suffix = "";
if (addressType == AddressType.Queue)
{
_queueDescription = new QueueDescriptionImpl(data.QueueOrTopicName);
}
else
{
_topicDescription = new TopicDescriptionImpl(data.QueueOrTopicName);
suffix = "?topic=true";
}
_rebuiltUri = new Uri(string.Format("azure-sb://{0}:{1}@{2}/{3}{4}",
data.UsernameIssuer,
Uri.EscapeDataString(data.PasswordSharedSecret),
data.Namespace,
data.QueueOrTopicName,
suffix));
_friendlyUri = new Uri(string.Format("azure-sb://{0}/{1}{2}",
data.Namespace,
data.QueueOrTopicName,
suffix));
}
internal void EnsureQueueExists(string queuePath)
{
if (_knownQueues.Value.Contains(queuePath))
{
return;
}
lock (LockFor(queuePath))
{
if (_knownQueues.Value.Contains(queuePath))
{
return;
}
_retry.Do(async() =>
{
var queueDescription = new QueueDescription(queuePath)
{
MaxDeliveryCount = _maxDeliveryAttempts,
DefaultMessageTimeToLive = _defaultMessageTimeToLive,
EnableDeadLetteringOnMessageExpiration = true,
EnableBatchedOperations = true,
RequiresDuplicateDetection = false,
RequiresSession = false,
//SupportOrdering = false,
AutoDeleteOnIdle = _autoDeleteOnIdle
};
// We don't check for queue existence here because that introduces a race condition with any other bus participant that's
// launching at the same time. If it doesn't exist, we'll create it. If it does, we'll just continue on with life and
// update its configuration in a minute anyway. -andrewh 8/12/2013
try
{
await _managementClient().CreateQueueAsync(queueDescription);
}
catch (MessagingEntityAlreadyExistsException)
{
await _managementClient().UpdateQueueAsync(queueDescription);
}
// catch (MessagingException exc)
// {
// if (!exc.Message.Contains("SubCode=40901")) throw;
//
// // SubCode=40901. Another conflicting operation is in progress. Let's see if it's created the queue for us.
// if (!_managementClient().QueueExists(queuePath))
// throw new BusException($"Queue creation for '{queuePath}' failed due to a conflicting operation and that queue does not already exist.", exc)
// .WithData("QueuePath", queuePath);
// }
_knownQueues.Value.Add(queuePath);
},
"Creating queue " + queuePath);
}
}
private static async Task <QueueDescription> CreateQueueIfNotExists(QueueDescription queueDescription)
{
try
{
return(await _mgmtClient.GetQueueAsync(queueDescription.Path));
}
catch (MessagingEntityNotFoundException)
{
return(await _mgmtClient.CreateQueueAsync(queueDescription));
}
}
static IEnumerable <string> GetQueryStringOptions(QueueDescription settings)
{
if (settings.EnableExpress)
{
yield return("express=true");
}
if (settings.AutoDeleteOnIdle > TimeSpan.Zero)
{
yield return($"autodelete={settings.AutoDeleteOnIdle.TotalSeconds}");
}
}
public static void CreateQueue(string entityName)
{
NamespaceManager nsManager = NamespaceManager.CreateFromConnectionString(_sbAuth);
QueueDescription queueDesc = new QueueDescription(entityName)
{
EnableDeadLetteringOnMessageExpiration = true,
DefaultMessageTimeToLive = new TimeSpan(0, 0, 0, 15)
};
nsManager.CreateQueue(queueDesc);
}
public ReceiveEndpointSettings(string queuePath)
{
QueueDescription = new QueueDescription(queuePath);
QueueDescription.EnableBatchedOperations = true;
QueueDescription.MaxDeliveryCount = 5;
QueueDescription.DefaultMessageTimeToLive = TimeSpan.FromDays(365);
QueueDescription.LockDuration = TimeSpan.FromMinutes(5);
QueueDescription.EnableDeadLetteringOnMessageExpiration = true;
MaxConcurrentCalls = Math.Max(Environment.ProcessorCount, 8);
PrefetchCount = Math.Max(MaxConcurrentCalls, 32);
}
public async Task CreateQueueAsync()
{
if (await QueueExists())
return;
QueueDescription queueDesc = new QueueDescription(_entityName)
{
EnableDeadLetteringOnMessageExpiration = true
};
await _nsMgr.CreateQueueAsync(queueDesc);
}
public MessageReceiverObservableExtensionsTests()
{
this.azureServiceBusTestUtilities = AzureServiceBusTestUtilities.Create();
string queueName = "MessageReceiverExtensionTests-" + Guid.NewGuid();
this.queueDescription = this.azureServiceBusTestUtilities.NamespaceManager.CreateQueue(queueName);
MessagingFactory messagingFactory = this.azureServiceBusTestUtilities.MessagingFactory;
this.messageSender = messagingFactory.CreateMessageSender(this.queueDescription.Path);
this.messageReceiver = messagingFactory.CreateMessageReceiver(this.queueDescription.Path);
}
public QueueClientObservableExtensionsTests()
{
this.azureServiceBusTestUtilities = AzureServiceBusTestUtilities.Create();
this.queueDescription = new QueueDescription("MessageReceiverExtensionTests-" + Guid.NewGuid())
{
RequiresSession = true,
};
this.queueDescription = this.azureServiceBusTestUtilities.NamespaceManager.CreateQueue(this.queueDescription);
this.queueClient = this.azureServiceBusTestUtilities.MessagingFactory.CreateQueueClient(this.queueDescription.Path);
}
public static SubscriptionDescription CreateSubscriptionDescription(string topicPath, string subscriptionName, QueueDescription queue, string queuePath)
{
return new SubscriptionDescription(topicPath, subscriptionName)
{
AutoDeleteOnIdle = queue.AutoDeleteOnIdle,
DefaultMessageTimeToLive = queue.DefaultMessageTimeToLive,
EnableBatchedOperations = queue.EnableBatchedOperations,
EnableDeadLetteringOnMessageExpiration = queue.EnableDeadLetteringOnMessageExpiration,
ForwardTo = queuePath,
LockDuration = queue.LockDuration,
MaxDeliveryCount = queue.MaxDeliveryCount,
UserMetadata = queue.UserMetadata
};
}
public void Initialize(string queueName)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(this._connectionString);
//check if queue name exists
if (!namespaceManager.QueueExists(queueName))
{
QueueDescription queue = new QueueDescription(queueName);
//queue.MaxSizeInMegabytes = 5120; //5GB
//expiry to 30 days
//queue.DefaultMessageTimeToLive = new System.TimeSpan(720, 0, 0);
namespaceManager.CreateQueue(queue);
}
}
/// <summary>
/// Creates a queue client, as well as the target queue if it does not already exist.
/// </summary>
public static QueueClient CreateQueueClient(
this ServiceBusSettings settings,
string queueName,
Action<QueueDescription> configure = null)
{
queueName = queueName.PrefixedIfConfigured(settings);
var queueDescription = new QueueDescription(queueName);
if (configure != null)
{
configure(queueDescription);
}
settings.CreateQueueIfDoesNotAlreadyExist(queueDescription);
return QueueClient.CreateFromConnectionString(settings.ConnectionString, queueName);
}
