public void Refresh()
{
GridView1.DataBind();
// queueClient = QueueClient.Create("bus2");
NamespaceManager nsmgr = Microsoft.ServiceBus.NamespaceManager.CreateFromConnectionString(System.Configuration.ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]);
var queue1details = nsmgr.GetQueue("bus1").MessageCountDetails;
Label1.Text = queue1details.ActiveMessageCount.ToString();
Label7.Text = queue1details.DeadLetterMessageCount.ToString();
var queue2details = nsmgr.GetQueue("bus2").MessageCountDetails;
Label2.Text = queue2details.ActiveMessageCount.ToString();
Label8.Text = queue2details.DeadLetterMessageCount.ToString();
var connectionString = ConfigurationManager.ConnectionStrings["App1DBConnectionString"].ToString();
SqlConnection sqlConnection1 = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand();
cmd.Connection = sqlConnection1;
sqlConnection1.Open();
cmd.CommandText = "Select Count('Id') From [dbo].[TEST] where [DTProcessStarted] is not null and [DTProcessEnded] is null";
int tt = (int)cmd.ExecuteScalar();
Label3.Text = tt.ToString();
sqlConnection1.Close();
}
public override async Task <long> ReadMessageCountAsync()
{
CheckOpened(null);
var queueDescription = _namespaceManager.GetQueue(_queueName);
return(queueDescription.MessageCount);
}
// This method rolls the primary key on a auth rule.
public static void RollSharedAccessKeysOnEntity(string serviceNamespace, string qPath, string keyName, string key)
{
// Create an instance of NamespaceManager for the operation.
Uri managementUri = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespace, string.Empty);
TokenProvider sasTP = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key);
NamespaceManager nsm = new NamespaceManager(managementUri, sasTP);
// Get the queue description.
QueueDescription qd = nsm.GetQueue(qPath);
IEnumerator <AuthorizationRule> rulesEnumerator = qd.Authorization.GetEnumerator();
while (rulesEnumerator.MoveNext())
{
SharedAccessAuthorizationRule typedRule = rulesEnumerator.Current as SharedAccessAuthorizationRule;
if (typedRule != null) // Confirm that this is a 'SharedAccessAuthorizationRule'
{
// Roll the keys.
// Note that this will also roll the keys on the 'contosoQManageRule' which is being used to
// authenticate this request, but since it won't take effect until we call NamespaceManager.UpdateQueue()
// that will still work.
typedRule.SecondaryKey = typedRule.PrimaryKey;
typedRule.PrimaryKey = SharedAccessAuthorizationRule.GenerateRandomKey();
}
}
// Apply the updated rules
nsm.UpdateQueue(qd);
}
public ServiceBusQueue(string connectionString, string queueName = null, int retries = 2, int workItemTimeoutMilliseconds = 60 * 1000, bool shouldRecreate = false, RetryPolicy retryPolicy = null)
{
_queueName = queueName ?? typeof(T).Name;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (_namespaceManager.QueueExists(_queueName) && shouldRecreate)
{
_namespaceManager.DeleteQueue(_queueName);
}
if (!_namespaceManager.QueueExists(_queueName))
{
_queueDescription = new QueueDescription(_queueName)
{
MaxDeliveryCount = retries + 1,
LockDuration = TimeSpan.FromMilliseconds(workItemTimeoutMilliseconds)
};
_namespaceManager.CreateQueue(_queueDescription);
}
else
{
_queueDescription = _namespaceManager.GetQueue(_queueName);
_queueDescription.MaxDeliveryCount = retries + 1;
_queueDescription.LockDuration = TimeSpan.FromMilliseconds(workItemTimeoutMilliseconds);
}
_queueClient = QueueClient.CreateFromConnectionString(connectionString, _queueDescription.Path);
if (retryPolicy != null)
{
_queueClient.RetryPolicy = retryPolicy;
}
}
// This method removes the auth rules with KeyName "contosoQSendKey" and "contosoQListenKey"
// from the queue.
public static void RemoveSASRulesFromEntity(string serviceNamespace, string qPath, string keyName, string key)
{
// Create an instance of NamespaceManager for the operation.
Uri managementUri = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespace, string.Empty);
TokenProvider sasTP = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key);
NamespaceManager nsm = new NamespaceManager(managementUri, sasTP);
// Get the queue description.
QueueDescription qd = nsm.GetQueue(qPath);
List <AuthorizationRule> rulesToRemove = new List <AuthorizationRule>();
rulesToRemove = qd.Authorization.GetRules(rule =>
{
SharedAccessAuthorizationRule typedRule = rule as SharedAccessAuthorizationRule;
if (typedRule != null &&
(String.Equals(typedRule.KeyName, "contosoQSendKey", StringComparison.Ordinal) ||
String.Equals(typedRule.KeyName, "contosoQListenKey", StringComparison.Ordinal)))
{
return(true);
}
return(false);
});
rulesToRemove.ForEach(delegate(AuthorizationRule rule)
{
qd.Authorization.Remove(rule);
});
nsm.UpdateQueue(qd);
}
public static long GetOrchestratorQueueMessageCount()
{
NamespaceManager nsManager = NamespaceManager.CreateFromConnectionString(ServiceBusConnectionString);
QueueDescription queueDesc = nsManager.GetQueue(TaskHubName + "/orchestrator");
return(queueDesc.MessageCount);
}
public bool HasChanged()
{
try {
NamespaceManager mgr = null;
if (!_nsManagers.ContainsKey(_connectionStr))
{
mgr = NamespaceManager.CreateFromConnectionString(_connectionStr);
_nsManagers.Add(_connectionStr, mgr);
}
else
{
mgr = _nsManagers[_connectionStr];
}
Info = mgr.GetQueue(Queue.Name);
if (_checkSum != Info.MessageCount + Info.SizeInBytes)
{
_log.Debug(" === " + Queue.Name + " - " + Info.UpdatedAt + " =======================");
_log.Debug("++ Has Changed, MessageCount: " + Info.MessageCount + ", SizeInBytes: " + Info.SizeInBytes);
}
else
{
_log.Debug("=== {0} = {1}:{2}b =======================".With(Queue.Name, Info.MessageCount, Info.SizeInBytes));
}
return(_checkSum != Info.MessageCount + Info.SizeInBytes);
} finally {
if (Info != null)
{
_checkSum = Info.MessageCount + Info.SizeInBytes;
}
}
}
static string GetHeartbeatStatus()
{
dynamic HeartbeatMessage = new ExpandoObject();
HeartbeatMessage.topic = "Process Heartbeat";
HeartbeatMessage.name = "Ops Alarm";
HeartbeatMessage.machine = Environment.MachineName;
HeartbeatMessage.processId = _ProcessId;
if (_isRunning)
{
HeartbeatMessage.status = "Running";
}
else
{
HeartbeatMessage.status = "Stop";
}
if (_sbNameSpaceMgr != null)
{
HeartbeatMessage.queueLength = _sbNameSpaceMgr.GetQueue(_sbAlarmOpsQueue).MessageCount;
}
else
{
HeartbeatMessage.queueLength = -1; //Unknow
}
HeartbeatMessage.cpu = Math.Round(_cpuCounter.NextValue(), 2) + " %";
HeartbeatMessage.ramAvail = _ramCounter.NextValue() + " MB";
HeartbeatMessage.timestampSource = DateTime.UtcNow;
var jsonString = JsonConvert.SerializeObject(HeartbeatMessage);
return(jsonString);
}
public void GetQueue(string queuePath)
{
QueueDescription queueDescription = m_NamespaceManager.GetQueue(queuePath);
Console.WriteLine("Queue Path: {0}",
queueDescription.Path);
Console.WriteLine("Queue MessageCount: {0}",
queueDescription.MessageCount);
Console.WriteLine("Queue SizeInBytes: {0}",
queueDescription.SizeInBytes);
Console.WriteLine("Queue RequiresSession: {0}",
queueDescription.RequiresSession);
Console.WriteLine("Queue RequiresDuplicateDetection: {0}",
queueDescription.RequiresDuplicateDetection);
Console.WriteLine("Queue DuplicateDetectionHistoryTimeWindow: {0}",
queueDescription.DuplicateDetectionHistoryTimeWindow);
Console.WriteLine("Queue LockDuration: {0}",
queueDescription.LockDuration);
Console.WriteLine("Queue DefaultMessageTimeToLive: {0}",
queueDescription.DefaultMessageTimeToLive);
Console.WriteLine("Queue EnableDeadLetteringOnMessageExpiration: {0}",
queueDescription.EnableDeadLetteringOnMessageExpiration);
Console.WriteLine("Queue EnableBatchedOperations: {0}",
queueDescription.EnableBatchedOperations);
Console.WriteLine("Queue MaxSizeInMegabytes: {0}",
queueDescription.MaxSizeInMegabytes);
Console.WriteLine("Queue MaxDeliveryCount: {0}",
queueDescription.MaxDeliveryCount);
Console.WriteLine("Queue IsReadOnly: {0}",
queueDescription.IsReadOnly);
}
private static void CheckQueue()
{
NamespaceManager namespaceManager = NamespaceManager.Create();
var queue = namespaceManager.GetQueue(QueueName);
Console.WriteLine(string.Format("Queue {0} has a message count of {1} and a dead letter count of {2}.", QueueName, queue.MessageCountDetails.ActiveMessageCount, queue.MessageCountDetails.DeadLetterMessageCount));
}
public SBMessageCounter(string ns, string queue, string keyName, string key)
{
var sb = ServiceBusEnvironment.CreateServiceUri("sb", ns, String.Empty);
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key);
NamespaceManager sbus = new NamespaceManager(sb, tokenProvider);
var q = sbus.GetQueue(queue);
MessageCount = q.MessageCount;
}
private static void ReceiveMessagesByIMessageSessionHandler()
{
Console.WriteLine("\nReceiving message from Queue...");
queueClient.RegisterSessionHandler(typeof(MyMessageSessionHandler), new SessionHandlerOptions {
AutoComplete = false
});
NamespaceManager namespaceManager = NamespaceManager.Create();
var queue = namespaceManager.GetQueue(QueueName);
while (queue.MessageCount > 0)
{
Thread.CurrentThread.Join(100);
queue = namespaceManager.GetQueue(QueueName);
}
queueClient.Close();
}
public void UpdateQueue([FromBody] QueueDetails queueData)
{
NamespaceManager namespaceManager = CreateNamespaceManager();
QueueDescription description = namespaceManager.GetQueue(queueData.name);
queueData.ApplyChangesToDescription(description);
namespaceManager.UpdateQueue(description);
}
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;
}
}
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);
}
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 bool QueueExists(Uri baseAddress, string queueName, TokenProvider credentials, bool requiresSession = false)
{
try
{
NamespaceManager namespaceClient = new NamespaceManager(baseAddress, credentials);
QueueDescription queue = namespaceClient.GetQueue(queueName);
return(true);
}
catch (MessagingEntityNotFoundException)
{}
return(false);
}
long GetQueueCount(string entityName)
{
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
QueueDescription queueDescription = namespaceManager.GetQueue(entityName);
if (queueDescription == null)
{
throw TraceHelper.TraceException(TraceEventType.Error,
new ArgumentException("Queue " + entityName + " does not exist"));
}
return(queueDescription.MessageCount);
}
public void RequeueAll(string queuePath)
{
var client = _messagingFactory.CreateQueueClient(queuePath.MakeDeadLetterPath());
var queue = _namespaceManager.GetQueue(queuePath);
var count = queue.MessageCountDetails.DeadLetterMessageCount;
var sender = client.MessagingFactory.CreateMessageSender(queuePath);
for (var i = 0; i < count; i++)
{
var msg = client.Receive(new TimeSpan(0, 0, 5));
if (msg == null)
{
break;
}
var clone = Clone(msg);
clone.RemoveProperties(GetPropertiesToRemove());
if (clone.Properties.ContainsKey("RequeuedFrom"))
{
clone.Properties["RequeuedFrom"] = clone.Properties["RequeuedFrom"] += "," + msg.MessageId;
}
else
{
clone.Properties.Add("RequeuedFrom", msg.MessageId);
}
sender.Send(clone);
msg.Complete();
}
}
/// <summary>
/// Creates shared access signature authorization for the service bus entity. This authorization works on
/// public Microsoft Azure environments and Windows Azure Pack on prim as well.
/// </summary>
/// <param name="namespaceName">The service bus namespace name</param>
/// <param name="entityName">The fully qualified service bus entity name</param>
/// <param name="entityType">The service bus entity type (e.g. Queue)</param>
/// <param name="ruleName">The SAS authorization rule name</param>
/// <param name="primaryKey">The SAS primary key. It'll be generated if empty</param>
/// <param name="secondaryKey">The SAS secondary key</param>
/// <param name="permissions">Set of permissions given to the rule</param>
/// <returns>The created Shared Access Signature authorization rule</returns>
public virtual ExtendedAuthorizationRule CreateSharedAccessAuthorization(
string namespaceName,
string entityName,
ServiceBusEntityType entityType,
string ruleName,
string primaryKey,
string secondaryKey,
params AccessRights[] permissions)
{
// Create the SAS authorization rule
SharedAccessAuthorizationRule rule = new SharedAccessAuthorizationRule(
ruleName,
string.IsNullOrEmpty(primaryKey) ? SharedAccessAuthorizationRule.GenerateRandomKey() : primaryKey,
secondaryKey,
permissions);
// Create namespace manager
NamespaceManager namespaceManager = CreateNamespaceManager(namespaceName);
// Add the SAS rule and update the entity
switch (entityType)
{
case ServiceBusEntityType.Queue:
QueueDescription queue = namespaceManager.GetQueue(entityName);
queue.Authorization.Add(rule);
namespaceManager.UpdateQueue(queue);
break;
case ServiceBusEntityType.Topic:
TopicDescription topic = namespaceManager.GetTopic(entityName);
topic.Authorization.Add(rule);
namespaceManager.UpdateTopic(topic);
break;
case ServiceBusEntityType.Relay:
RelayDescription relay = namespaceManager.GetRelayAsync(entityName).Result;
relay.Authorization.Add(rule);
namespaceManager.UpdateRelayAsync(relay).Wait();
break;
case ServiceBusEntityType.NotificationHub:
NotificationHubDescription notificationHub = namespaceManager.GetNotificationHub(entityName);
notificationHub.Authorization.Add(rule);
namespaceManager.UpdateNotificationHub(notificationHub);
break;
default:
throw new Exception(string.Format(Resources.ServiceBusEntityTypeNotFound, entityType.ToString()));
}
return(CreateExtendedAuthorizationRule(rule, namespaceName, entityName, entityType));
}
/// <summary>
/// Removed shared access signature authorization for the service bus entity.
/// </summary>
/// <param name="namespaceName">The service bus namespace name</param>
/// <param name="entityName">The fully qualified service bus entity name</param>
/// <param name="entityType">The service bus entity type (e.g. Queue)</param>
/// <param name="ruleName">The SAS authorization rule name</param>
public virtual void RemoveAuthorizationRule(
string namespaceName,
string entityName,
ServiceBusEntityType entityType,
string ruleName)
{
bool removed = false;
SharedAccessAuthorizationRule rule = (SharedAccessAuthorizationRule)GetAuthorizationRule(
namespaceName,
entityName,
entityType,
ruleName).Rule;
// Create namespace manager
NamespaceManager namespaceManager = CreateNamespaceManager(namespaceName);
// Add the SAS rule and update the entity
switch (entityType)
{
case ServiceBusEntityType.Queue:
QueueDescription queue = namespaceManager.GetQueue(entityName);
removed = queue.Authorization.Remove(rule);
Debug.Assert(removed);
namespaceManager.UpdateQueue(queue);
break;
case ServiceBusEntityType.Topic:
TopicDescription topic = namespaceManager.GetTopic(entityName);
removed = topic.Authorization.Remove(rule);
Debug.Assert(removed);
namespaceManager.UpdateTopic(topic);
break;
case ServiceBusEntityType.Relay:
RelayDescription relay = namespaceManager.GetRelayAsync(entityName).Result;
removed = relay.Authorization.Remove(rule);
Debug.Assert(removed);
namespaceManager.UpdateRelayAsync(relay).Wait();
break;
case ServiceBusEntityType.NotificationHub:
NotificationHubDescription notificationHub = namespaceManager.GetNotificationHub(entityName);
removed = notificationHub.Authorization.Remove(rule);
Debug.Assert(removed);
namespaceManager.UpdateNotificationHub(notificationHub);
break;
default:
throw new Exception(string.Format(Resources.ServiceBusEntityTypeNotFound, entityType.ToString()));
}
}
public void ListQueue(string queuePath)
{
QueueDescription queueDescriptions = m_NamespaceManager.GetQueue(queuePath);
Console.WriteLine("\tQueue Path: {0}", queueDescriptions.Path);
Console.WriteLine("\tQueue MessageCount: {0}", queueDescriptions.MessageCount);
Console.WriteLine("\tQueue SizeInBytes: {0}", queueDescriptions.SizeInBytes);
Console.WriteLine("\tQueue RequiresSession: {0}", queueDescriptions.RequiresSession);
Console.WriteLine("\tQueue RequiresDuplicateDetection: {0}", queueDescriptions.RequiresDuplicateDetection);
Console.WriteLine("\tQueue MaxDeliveryCount: {0}", queueDescriptions.MaxDeliveryCount);
Console.WriteLine("\tQueue DefaultMessageTimeToLive: {0}", queueDescriptions.DefaultMessageTimeToLive);
Console.WriteLine("\tQueue EnableDeadLetteringOnMessageExpiration: {0}", queueDescriptions.EnableDeadLetteringOnMessageExpiration);
Console.WriteLine("Done!");
}
public static QueueDescription CreateServiceBusQueue(string queueName)
{
QueueDescription queueDesc;
NamespaceManager namespaceClient = GetNamespaceManager();
if (namespaceClient.QueueExists(queueName))
{
queueDesc = namespaceClient.GetQueue(queueName);
}
else
{
queueDesc = namespaceClient.CreateQueue(queueName);
}
return(queueDesc);
}
public long Count()
{
NamespaceManager NM = NamespaceManager.CreateFromConnectionString(_ConStr);
try
{
Microsoft.ServiceBus.Messaging.QueueDescription Queue = NM.GetQueue(_ReceivingQueue);
return(Queue.MessageCount);
}
catch (Exception ex)
{
Debugger.Log(1, "Niffler.Data.SQLServer", ex.ToString());
return(-1);
}
}
public override CheckResult PerformCheck()
{
Logger.Debug("Checking Dead Letter Queue length");
var queueDescription = namespaceManager.GetQueue(stagingQueue);
var messageCountDetails = queueDescription.MessageCountDetails;
if (messageCountDetails.DeadLetterMessageCount > 0)
{
var result = $"{messageCountDetails.DeadLetterMessageCount} messages in the Dead Letter Queue '{stagingQueue}'. This could indicate a problem with ServiceControl's retries. Please submit a support ticket to Particular using [email protected] if you would like help from our engineers to ensure no message loss while resolving these dead letter messages.";
Logger.Warn(result);
return(CheckResult.Failed(result));
}
Logger.Debug("No messages in Dead Letter Queue");
return(CheckResult.Pass);
}
protected void Button11_Click(object sender, EventArgs e)
{
NamespaceManager nsmgr = Microsoft.ServiceBus.NamespaceManager.CreateFromConnectionString(System.Configuration.ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]);
var queueDeadletterPath = QueueClient.FormatDeadLetterPath("Bus2");
QueueClient deadletterQueueClient = QueueClient.Create(queueDeadletterPath);
while (nsmgr.GetQueue("bus2").MessageCountDetails.DeadLetterMessageCount > 0)
{
var message = deadletterQueueClient.Receive();
if (message != null)
{
SendMessage("bus2", message.Clone());
message.Complete();
}
}
Refresh();
}
public ServiceBusQueue(string connectionString, string queueName = null, int retries = 2, TimeSpan?workItemTimeout = null, bool shouldRecreate = false, RetryPolicy retryPolicy = null, ISerializer serializer = null)
{
_queueName = queueName ?? typeof(T).Name;
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
_retries = retries;
if (workItemTimeout.HasValue && workItemTimeout.Value < TimeSpan.FromMinutes(5))
{
_workItemTimeout = workItemTimeout.Value;
}
QueueId = Guid.NewGuid().ToString("N");
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);
_queueDescription.MaxDeliveryCount = retries + 1;
_queueDescription.LockDuration = _workItemTimeout;
}
_serializer = serializer ?? new JsonNetSerializer();
_queueClient = QueueClient.CreateFromConnectionString(connectionString, _queueDescription.Path);
if (retryPolicy != null)
{
_queueClient.RetryPolicy = retryPolicy;
}
}
private static void Receive(Uri serviceUri, TokenProvider credentials)
{
NamespaceManager namespaceClient = new NamespaceManager(serviceUri, credentials);
QueueDescription queueDescription = namespaceClient.GetQueue(QueueName);
MessagingFactory factory = MessagingFactory.Create(serviceUri, credentials);
QueueClient myQueueClient = factory.CreateQueueClient(QueueName, ReceiveMode.PeekLock);
BrokeredMessage message;
long messageCount = queueDescription.MessageCount;
for (long count = 0; count < messageCount; count++)
{
message = myQueueClient.Receive(TimeSpan.FromSeconds(5));
if (message != null)
{
Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>()));
message.Complete();
}
}
}
public bool HasChanged(uint currentMsgCount)
{
long msgCount = 0;
try {
NamespaceManager mgr = null;
if (!_nsManagers.ContainsKey(_connectionStr))
{
mgr = NamespaceManager.CreateFromConnectionString(_connectionStr);
_nsManagers.Add(_connectionStr, mgr);
}
else
{
mgr = _nsManagers[_connectionStr];
}
// Update info
Info = mgr.GetQueue(Queue.Name);
msgCount = GetMessageCount();
if (currentMsgCount != msgCount || (_checkSum != msgCount + Info.SizeInBytes))
{
_log.Debug(" === " + Queue.Name + " - " + Info.UpdatedAt + " =======================");
_log.Debug("++ Has Changed, MessageCount: " + Info.MessageCount + ", SizeInBytes: " + Info.SizeInBytes);
return(true);
}
else
{
_log.Debug("=== {0} = {1}:{2}b =======================".With(Queue.Name, Info.MessageCount, Info.SizeInBytes));
return(false);
}
} finally {
if (Info != null)
{
_checkSum = msgCount + Info.SizeInBytes;
}
}
}
static void Main(string[] args)
{
GetUserCredentials();
TokenProvider credentials = null;
Uri serviceUri = null;
CreateTokenProviderAndServiceUri(out credentials, out serviceUri);
MessagingFactory factory = null;
try
{
NamespaceManager namespaceClient = new NamespaceManager(serviceUri, credentials);
if (namespaceClient == null)
{
Console.WriteLine("\nUnexpected Error: NamespaceManager is NULL");
return;
}
QueueDescription queueDescription = namespaceClient.GetQueue(Receiver.QueueName);
if (queueDescription == null)
{
Console.WriteLine("\nUnexpected Error: QueueDescription is NULL");
return;
}
QueueClient myQueueClient = CreateQueueClient(serviceUri, credentials, out factory);
Console.WriteLine("\nReceiving messages from Queue '{0}'...", Receiver.QueueName);
// Numero actual de mensagens na queue
long messageCount = queueDescription.MessageCount;
ReceiveNMessagesFromQueue(myQueueClient, messageCount);
Console.WriteLine("\nEnd of scenario, press ENTER to exit.");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception {0}", e.ToString());
throw;
}
finally
{
if (factory != null) factory.Close();
}
}
public async System.Threading.Tasks.Task <bool> deleteQueueMessagesAsync(string queue)
{
//NamespaceManager nm = NamespaceManager.CreateFromConnectionString(connectionString);
var mf = MessagingFactory.CreateFromConnectionString(connectionString);
var receiver = await mf.CreateMessageReceiverAsync(queue, ReceiveMode.ReceiveAndDelete);
NamespaceManager nm = NamespaceManager.CreateFromConnectionString(connectionString);
int numMessages = (int)nm.GetQueue(queue).MessageCount;
while (true)
{
var messages = await receiver.ReceiveBatchAsync(numMessages);
if (!messages.Any())
{
break;
}
}
;
return(true);
}
static bool QueueExists(Uri baseAddress,string queueName,TokenProvider credentials,bool requiresSession = false)
{
try
{
NamespaceManager namespaceClient = new NamespaceManager(baseAddress,credentials);
QueueDescription queue = namespaceClient.GetQueue(queueName);
return true;
}
catch(MessagingEntityNotFoundException)
{}
return false;
}
