public AzureServiceBusSubscriptionService(string connectionString, ILogger logger)
{
if (String.IsNullOrEmpty(connectionString)) throw new ArgumentNullException(nameof(connectionString));
if (logger == null) throw new ArgumentNullException(nameof(logger));
_connectionString = connectionString;
_logger = logger;
var namespaceManager = NamespaceManager.CreateFromConnectionString(_connectionString);
_clients = new Dictionary<string, SubscriptionClient>();
foreach (var topic in TOPICS)
{
var subscriptionName = getSubscriptionName(topic);
if (!namespaceManager.SubscriptionExists(topic, subscriptionName))
{
var description = new SubscriptionDescription(topic, subscriptionName);
description.DefaultMessageTimeToLive = TOPIC_MESSAGE_TTL;
namespaceManager.CreateSubscription(description);
}
_clients.Add(topic, SubscriptionClient.CreateFromConnectionString(
_connectionString,
topic,
subscriptionName,
ReceiveMode.ReceiveAndDelete));
}
_messageOptions = new OnMessageOptions()
{
AutoComplete = false,
AutoRenewTimeout = TimeSpan.FromMinutes(1)
};
}
private async static Task SubscriptionShouldExistAsync(NamespaceManager ns, SubscriptionDescription subscriptionDescription)
{
if (!await ns.SubscriptionExistsAsync(subscriptionDescription.TopicPath, subscriptionDescription.Name))
{
throw new MessagingEntityNotFoundException("Subscription: " + subscriptionDescription.TopicPath + "/" + subscriptionDescription.Name);
}
}
private SubscriptionClient CreateAndGetSubscriptionInternal(string subscriptionName, ISpecification filterSpecification)
{
var filter = new SqlFilter(filterSpecification.Result());
EnsureSubscriptionNameIsValid(subscriptionName);
log.Info($"Checking subscription for path {subscriptionName} exists");
if (!this.namespaceManager.SubscriptionExists(this.topic, subscriptionName))
{
log.Info("Creating subscription as it does not currently exist");
var subscriptionDescription = new SubscriptionDescription(this.topic, subscriptionName)
{
LockDuration = TimeSpan.FromMinutes(5)
};
this.namespaceManager.CreateSubscription(subscriptionDescription, filter);
log.Info("Subscription created");
}
log.Info("Creating subscription client");
var client = SubscriptionClient.CreateFromConnectionString(
connectionString, this.topic, subscriptionName);
log.Info("Subscription client created");
return client;
}
public async static Task<SubscriptionClient> EnsureSubscriptionAsync(this MessagingFactory factory, SubscriptionDescription subscriptionDescription, ReceiveMode mode = ReceiveMode.PeekLock)
{
await new NamespaceManager(factory.Address, factory.GetSettings().TokenProvider)
.TryCreateEntity(
mgr => SubscriptionCreateAsync(mgr, subscriptionDescription),
mgr => SubscriptionShouldExistAsync(mgr, subscriptionDescription));
return factory.CreateSubscriptionClient(subscriptionDescription.TopicPath, subscriptionDescription.Name, mode);
}
public static void CreateSubscription(this ServiceBusSettings settings, SubscriptionDescription description)
{
CreateTopic(settings, description.TopicPath);
new NamespaceManager(
ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath),
TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey))
.CreateSubscription(description);
}
private async static Task SubscriptionCreateAsync(NamespaceManager ns, SubscriptionDescription subscriptionDescription)
{
if (!await ns.SubscriptionExistsAsync(subscriptionDescription.TopicPath, subscriptionDescription.Name))
{
await ns.CreateSubscriptionAsync(subscriptionDescription);
ServiceBusEventSource.Log.CreatedSubscription(ns.Address.ToString(), subscriptionDescription.TopicPath, subscriptionDescription.Name);
}
}
/// <summary>
/// Creates a subscription client, as well as the target subscription if it does not already exist.
/// </summary>
public static SubscriptionClient CreateSubscriptionClient(
this ServiceBusSettings settings,
string topicPath,
string subscriptionName,
Action<SubscriptionDescription> configure = null)
{
topicPath = topicPath.PrefixedIfConfigured(settings);
var subscriptionDescription = new SubscriptionDescription(topicPath, subscriptionName);
if (configure != null)
{
configure(subscriptionDescription);
}
settings.CreateSubscriptionIfDoesNotAlreadyExist(subscriptionDescription);
return SubscriptionClient.CreateFromConnectionString(settings.ConnectionString, subscriptionDescription.TopicPath, subscriptionDescription.Name);
}
public void SubscriptionCreation()
{
string topicName = "SubscriptionCreation";
string SubscriptionName = "TestSubscriptionCreation".ToLower();
var ns = NamespaceManager.CreateFromConnectionString(TestServiceBus.serviceBusConnectionString);
try
{
ns.CreateTopic(topicName);
SubscriptionDescription initialDesc = ns.CreateSubscription(topicName, SubscriptionName);
}
finally
{
ns.DeleteSubscription(topicName, SubscriptionName);
ns.DeleteTopic(topicName);
}
}
public void Initialize(string topicName, string subscriptionName, string filterExpression, string connectionString)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.TopicExists(topicName))
{
var topicDesc = new TopicDescription(topicName);
topicDesc.DefaultMessageTimeToLive = TimeSpan.FromMinutes(10);
topicDesc.EnableBatchedOperations = false;
topicDesc.EnableExpress = false;
topicDesc.SupportOrdering = true;
var topic = namespaceManager.CreateTopic(topicDesc);
}
if (!namespaceManager.SubscriptionExists(topicName, subscriptionName))
{
var subDesc = new SubscriptionDescription(topicName, subscriptionName);
subDesc.EnableBatchedOperations = false;
namespaceManager.CreateSubscription(subDesc, new SqlFilter(filterExpression /*"StoreName = 'Store1'"*/));
}
var client = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName);
client.PrefetchCount = 0;
client.MessagingFactory.PrefetchCount = 0;
//client.MessagingFactory.RetryPolicy = RetryExponential.Default;
_topicClient = TopicClient.CreateFromConnectionString(connectionString, topicName);
client.OnMessage(receivedMessage =>
{
try
{
MessageReceived(receivedMessage);
Trace.WriteLine("Processing Service Bus message: " + receivedMessage.SequenceNumber.ToString());
}
catch (Exception exc)
{
receivedMessage.Abandon();
Trace.TraceError(exc.ToString());
}
}, new OnMessageOptions {
AutoComplete = false, MaxConcurrentCalls = 10000
});
}
bool MembersAreNotEqual(SubscriptionDescription existingDescription, SubscriptionDescription newDescription)
{
if (existingDescription.RequiresSession != newDescription.RequiresSession)
{
logger.Warn("RequiresSession cannot be update on the existing queue!");
}
return(existingDescription.AutoDeleteOnIdle != newDescription.AutoDeleteOnIdle ||
existingDescription.LockDuration != newDescription.LockDuration ||
existingDescription.DefaultMessageTimeToLive != newDescription.DefaultMessageTimeToLive ||
existingDescription.EnableDeadLetteringOnMessageExpiration != newDescription.EnableDeadLetteringOnMessageExpiration ||
existingDescription.EnableDeadLetteringOnFilterEvaluationExceptions != newDescription.EnableDeadLetteringOnFilterEvaluationExceptions ||
existingDescription.MaxDeliveryCount != newDescription.MaxDeliveryCount ||
existingDescription.EnableBatchedOperations != newDescription.EnableBatchedOperations ||
existingDescription.ForwardTo != newDescription.ForwardTo ||
existingDescription.ForwardDeadLetteredMessagesTo != newDescription.ForwardDeadLetteredMessagesTo);
}
public void Create(string script, bool force = false)
{
Script s = ParseScript(script);
OnMessage($"Creating {s.Topics.Count} topics ... " + Environment.NewLine + Environment.NewLine);
foreach (Topic topic in s.Topics ?? Enumerable.Empty <Topic>())
{
if (_namespaceService.TopicExists(topic.Path))
{
if (force)
{
OnMessage($"Topic '{topic.Path}' already exists. Deleting ... ");
_namespaceService.DeleteTopic(topic.Path);
OnMessage("done" + Environment.NewLine);
}
else
{
OnMessage($"Topic '{topic.Path}' already exists. Skipping ... " + Environment.NewLine);
continue;
}
}
TopicDescription topicDescription = Mappers.TopicMapper.Map(topic);
OnMessage($"Creating topic '{topic.Path}' ... ");
_namespaceService.CreateTopic(topicDescription);
OnMessage("done" + Environment.NewLine);
foreach (Subscription subscription in topic.Subscriptions ?? Enumerable.Empty <Subscription>())
{
SubscriptionDescription subscriptionDescription = Mappers.SubscriberMapper.Map(subscription, topic.Path);
OnMessage($"Creating subscription '{subscription.Name}' for topic '{topic.Path}' ... ");
if (subscription.SqlFilter == null)
{
_namespaceService.CreateSubscription(subscriptionDescription);
}
else
{
_namespaceService.CreateSubscription(subscriptionDescription, new SqlFilter(subscription.SqlFilter));
}
OnMessage("done" + Environment.NewLine);
}
}
}
public void TestForwardTo()
{
string name = "testSubscription";
string topicName = "TestForwardTo";
string queueName = "Testforwardtoqueue".ToLower();
NamespaceManager ns = NamespaceManager.CreateFromConnectionString(serviceBusConnectionString);
try
{
DeleteSafeQueue(ns, queueName);
DeleteSafeTopic(ns, topicName);
TopicDescription tdescription = ns.CreateTopic(topicName);
Assert.IsTrue(null != tdescription);
var queueDescription = ns.CreateQueue(queueName);
Assert.IsTrue(null != queueDescription);
string endpointAddress = String.Empty;
int endpointIndex = serviceBusConnectionString.IndexOf("Endpoint=sb") + "Endpoint=".Length;
int nextColon = serviceBusConnectionString.IndexOf(';', endpointIndex);
if (nextColon < 0)
{
nextColon = serviceBusConnectionString.Length - 1;
}
endpointAddress = serviceBusConnectionString.Substring(endpointIndex, nextColon - endpointIndex);
string forwardToAddress = endpointAddress + queueName;
var description = new SubscriptionDescription(topicName, name)
{
ForwardTo = forwardToAddress
};
SubscriptionDescription sdescription = ns.CreateSubscription(description);
Assert.IsTrue(null != sdescription);
Assert.IsTrue(forwardToAddress.Equals(sdescription.ForwardTo));
IEnumerable <SubscriptionDescription> suscriptions = ns.GetSubscriptions(topicName);
Assert.IsTrue(suscriptions.First().Name.Equals(name));
}
finally
{
DeleteSafeQueue(ns, queueName);
DeleteSafeTopic(ns, topicName);
}
}
SubscriptionClient CreateSubscriptionClient(string topicName, string subscriptionName)
{
TopicDescription topicDescription = new TopicDescription(topicName);
if (!_namespaceManager.TopicExists(topicName))
{
_namespaceManager.CreateTopic(topicDescription);
}
if (!_namespaceManager.SubscriptionExists(topicDescription.Path, subscriptionName))
{
var subscriptionDescription =
new SubscriptionDescription(topicDescription.Path, subscriptionName);
_namespaceManager.CreateSubscription(subscriptionDescription);
}
return(_messageFactory.CreateSubscriptionClient(topicDescription.Path, subscriptionName));
}
public static async Task <SubscriptionDescription> CreateSubscriptionIfNotExists(string topicName,
string subName, RuleDescription ruleDescription = null)
{
try
{
return(await Topic.MgmtClient.GetSubscriptionAsync(topicName, subName));
}
catch (MessagingEntityNotFoundException)
{
var subDesc = new SubscriptionDescription(topicName, subName)
{
// The maximum delivery count of a message before it is dead-lettered
// default value = 10
// Min value = 1
// Max value = int.Max
MaxDeliveryCount = 5,
// default value = 60 seconds.
// Max value = 5 minutes.
LockDuration = TimeSpan.FromSeconds(45),
// whether the queue supports the concept of session.
RequiresSession = false,
// >> Message >>
// ExpiresAtUtc = EnqueuedTimeUtc + TimeToLive
DefaultMessageTimeToLive = TimeSpan.FromDays(7), // Expiration
// Duration of idle interval after which the queue is automatically deleted.
// Default / Max value = TimeSpan.MaxValue >> 29K years
// Min value = 5 minute
AutoDeleteOnIdle = TimeSpan.MaxValue,
// Decides whether an expired message due to TTL should be dead-letterd
EnableDeadLetteringOnMessageExpiration = true,
EnableBatchedOperations = false
};
await Topic.MgmtClient.CreateSubscriptionAsync(subDesc, ruleDescription);
//await AddRule(topicName, subName, ruleDescription);
return(subDesc);
}
}
protected override void ClearItem(string path)
{
string[] pathChunks = Context.ChunkPath(this.PSDriveInfo, path);
string name = pathChunks[pathChunks.Length - 1];
string parentPath = path.Substring(0, path.LastIndexOf('\\'));
pathChunks = Context.ChunkPath(this.PSDriveInfo, parentPath);
switch (pathChunks.Length)
{
case 1:
if (string.Compare(pathChunks[0], "Queues", true) == 0)
{
this.ServiceBusNamespaceClient.DeleteQueue(name);
}
else if (string.Compare(pathChunks[0], "Topics", true) == 0)
{
this.ServiceBusNamespaceClient.DeleteTopic(name);
}
break;
case 2:
if (string.Compare(pathChunks[0], "Topics", true) == 0)
{
TopicDescription topic = (TopicDescription)this.GetItemAt(parentPath);
this.ServiceBusNamespaceClient.DeleteSubscription(topic.Path, name);
}
break;
case 3:
if (string.Compare(pathChunks[0], "Topics", true) == 0)
{
MessagingFactory factory = Context.GetMessagingFactory(this.SessionState);
SubscriptionDescription subscription = (SubscriptionDescription)this.GetItemAt(parentPath);
SubscriptionClient client = factory.CreateSubscriptionClient(subscription.TopicPath, subscription.Name);
client.RemoveRule(name);
}
break;
}
Context.Cache.Remove(this.GetPathTillElement(path, pathChunks.Length));
}
public SubscriptionClient Create(Type eventType, string topicPath, string subscriptionname)
{
if (NamespaceClient.TopicExists(topicPath))
{
try
{
if (!NamespaceClient.SubscriptionExists(topicPath, subscriptionname))
{
var description = new SubscriptionDescription(topicPath, subscriptionname)
{
LockDuration = LockDuration,
RequiresSession = RequiresSession,
DefaultMessageTimeToLive = DefaultMessageTimeToLive,
EnableDeadLetteringOnMessageExpiration = EnableDeadLetteringOnMessageExpiration,
MaxDeliveryCount = MaxDeliveryCount,
EnableBatchedOperations = EnableBatchedOperations,
EnableDeadLetteringOnFilterEvaluationExceptions =
EnableDeadLetteringOnFilterEvaluationExceptions
};
if (eventType != null)
{
var filter =
string.Format(
"[{0}] LIKE '{1}%' OR [{0}] LIKE '%{1}%' OR [{0}] LIKE '%{1}' OR [{0}] = '{1}'",
Headers.EnclosedMessageTypes, eventType.AssemblyQualifiedName);
var typefilter = new SqlFilter(filter);
NamespaceClient.CreateSubscription(description, typefilter);
}
else
{
NamespaceClient.CreateSubscription(description);
}
}
}
catch (MessagingEntityAlreadyExistsException)
{
// the queue already exists or another node beat us to it, which is ok
}
return(Factory.CreateSubscriptionClient(topicPath, subscriptionname, ReceiveMode.PeekLock));
}
return(null);
}
static void Main(string[] args)
{
Console.WriteLine("Enter Name - ");
var username = Console.ReadLine();
var manager = NamespaceManager.CreateFromConnectionString(ConnectionString);
if (!manager.TopicExists(TopicPath))
{
manager.CreateTopic(TopicPath);
}
var description = new SubscriptionDescription(TopicPath, username);
{
description.AutoDeleteOnIdle = TimeSpan.FromMinutes(5);
}
manager.CreateSubscription(description);
var factory = MessagingFactory.CreateFromConnectionString(ConnectionString);
var topicClient = factory.CreateTopicClient(TopicPath);
var subscriptionClient = factory.CreateSubscriptionClient(TopicPath, username);
subscriptionClient.OnMessage(msg => ProcessMessage(msg));
var hellomessage = new BrokeredMessage("Has entered the Room...");
hellomessage.Label = username;
topicClient.Send(hellomessage);
while (true)
{
string text = Console.ReadLine();
if (text.Equals("exit"))
{
break;
}
var chatMessage = new BrokeredMessage(text);
chatMessage.Label = username;
topicClient.Send(chatMessage);
}
var goodbyeMessage = new BrokeredMessage("Has left the building.....");
goodbyeMessage.Label = username;
topicClient.Send(goodbyeMessage);
factory.Close();
}
static async Task Main(string[] args)
{
ManagementClient m_ManagementClient = new ManagementClient("your connection string goes here");
string topicPath = "demotopic";
string subscriptionName = "orderSubscription";
// create the filter
var filter = new CorrelationFilter();
filter.Properties["State"] = "USA";
var rule = new RuleDescription("Demo", filter);
var subscriptionDescription = new SubscriptionDescription(topicPath, subscriptionName);
await m_ManagementClient.CreateSubscriptionAsync(subscriptionDescription, rule);
Console.WriteLine("Hello World!");
}
public async Task DeleteTopicSubscription(SubscriptionDescription description)
{
try
{
await DeleteSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);
LogContext.Debug?.Log("Subscription Deleted: {Subscription} ({Topic} -> {ForwardTo})", description.SubscriptionName, description.TopicPath,
description.ForwardTo);
}
catch (MessagingEntityNotFoundException)
{
}
catch (Exception ex)
{
LogContext.Error?.Log(ex, "Subscription Delete Faulted: {Subscription} ({Topic} -> {ForwardTo})", description.SubscriptionName,
description.TopicPath, description.ForwardTo);
}
}
public void AddSubscription()
{
try
{
var subscription = new SubscriptionDescription(Instance.Path, SubscriptionName);
subscription = _manager.AddSubscription(subscription);
_manager.UpdateTopic(Instance);
Subscriptions.Add(subscription);
NotifyOfPropertyChange(() => Instance);
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Add subscription failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public Task EnsureSubscribed(SubscriptionDescription subscription, CancellationToken cancellationToken)
{
// TODO Unit test
if (this.subscription != null)
{
throw new InvalidOperationException("Subscription already registered.");
}
if (subscription.EndpointName != endpointName)
{
throw new ArgumentOutOfRangeException(
nameof(subscription),
"Endpoint name in subscription description does not match endpoint name of bus connection.");
}
this.subscription = subscription;
return(Task.CompletedTask);
}
public static Subscription Map(SubscriptionDescription source)
{
return(new Subscription
{
AutoDeleteOnIdle = source.AutoDeleteOnIdle,
DefaultMessageTimeToLive = source.DefaultMessageTimeToLive,
EnableBatchedOperations = source.EnableBatchedOperations,
EnableDeadLetteringOnFilterEvaluationExceptions = source.EnableDeadLetteringOnFilterEvaluationExceptions,
EnableDeadLetteringOnMessageExpiration = source.EnableDeadLetteringOnMessageExpiration,
ForwardDeadLetteredMessagesTo = source.ForwardDeadLetteredMessagesTo,
ForwardTo = source.ForwardTo,
LockDuration = source.LockDuration,
MaxDeliveryCount = source.MaxDeliveryCount,
Name = source.Name,
RequiresSession = source.RequiresSession,
UserMetadata = source.UserMetadata
});
}
private static void CreateSubscriptionFilter(CreateSubscriptionOptions options)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(options.ConnectionString);
var subscription = new SubscriptionDescription(options.TopicName, options.SubscriptionName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(7),
LockDuration = TimeSpan.FromMinutes(1),
MaxDeliveryCount = 10,
EnableDeadLetteringOnFilterEvaluationExceptions = true
};
var filter = new SqlFilter($"user.SupplierID = '{options.SupplierID}'");
namespaceManager.CreateSubscription(subscription, filter);
Console.WriteLine($"Created subscription {options.SubscriptionName} on topic {options.TopicName}.");
}
/// <summary>
/// Checks if a event hub by the provided <paramref name="hubName"/> exists and
/// Checks if a consumer group by the provided <paramref name="consumerGroupNames"/> exists.
/// </summary>
protected virtual void CheckHubExists(NamespaceManager namespaceManager, string hubName, string consumerGroupNames)
{
// Configure Queue Settings
var eventHubDescription = new EventHubDescription(hubName)
{
MessageRetentionInDays = long.MaxValue,
};
// Create the topic if it does not exist already
namespaceManager.CreateEventHubIfNotExists(eventHubDescription);
var subscriptionDescription = new SubscriptionDescription(eventHubDescription.Path, consumerGroupNames);
if (!namespaceManager.SubscriptionExists(eventHubDescription.Path, consumerGroupNames))
{
namespaceManager.CreateSubscription(subscriptionDescription);
}
}
private void ensureSubscriptionExists(Filter filter)
{
lock (createLock)
{
var nsMgr = NamespaceManager.CreateFromConnectionString(connectionString);
if (nsMgr.SubscriptionExists(topicPath, subscriptionName))
return;
var definition = new SubscriptionDescription(topicPath, subscriptionName)
{
LockDuration = TimeSpan.FromMinutes(5),
EnableDeadLetteringOnFilterEvaluationExceptions = true,
EnableDeadLetteringOnMessageExpiration = true
};
nsMgr.CreateSubscription(definition, filter);
}
}
public async Task <object> CreatetopicMatchAllSubscription(string topicname)
{
var client = new ManagementClient(sbconnection);
bool topicExists = await client.TopicExistsAsync(topicname).ConfigureAwait(false);
if (topicExists)
{
SubscriptionDescription subName = new SubscriptionDescription(topicname, "AllMessages");
subName.Status = 0;
var result01 = await client.CreateSubscriptionAsync(subName).ConfigureAwait(false);
return(result01);
}
else
{
return("Unable to create MatchAll Subscription!!");
}
}
public IAsyncResult BeginCreateSubscription(ITopicClient topic, string name, string sqlFilter, AsyncCallback callback)
{
Requires.NotNull(topic, "topic");
Requires.NotNullOrEmpty(name, "name");
TopicClient client = (TopicClient)topic;
SqlFilter filter = new SqlFilter(sqlFilter);
SubscriptionDescription description = new SubscriptionDescription();
// TODO: Filters aren't actually working at the moment
//description.DefaultRuleDescription = new RuleDescription(filter);
description.DefaultRuleDescription = new RuleDescription();
Func <SubscriptionClient> creator = () => CreateSubscription(client, name);
return(SubscriptionClient.BeginCreateSubscription(client.Path, name, description, client.TokenProvider, callback, creator));
}
public async Task DeleteTopicSubscription(SubscriptionDescription description)
{
try
{
if (await RootNamespaceManager.SubscriptionExistsAsync(description.TopicPath, description.Name).ConfigureAwait(false))
{
await RootNamespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
}
}
catch (MessagingEntityNotFoundException)
{
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Subscription Deleted: {0} ({1} -> {2})", description.Name, description.TopicPath, description.ForwardTo);
}
}
static async Task CreateSubscription(string serviceBusConnectionString, string topicName, string subscriptionName)
{
var client = new ManagementClient(serviceBusConnectionString);
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName)
{
DefaultMessageTimeToLive = new TimeSpan(0, 0, 20),
AutoDeleteOnIdle = new TimeSpan(0, 5, 0), //subscription will be deleted after 5 min if idle.
LockDuration = new TimeSpan(0, 0, 20),
MaxDeliveryCount = 10
};
var subExist = await client.SubscriptionExistsAsync(topicName, subscriptionName);
if (!subExist)
{
await client.CreateSubscriptionAsync(subscriptionDescription);
}
}
public void UnknownElementsInAtomXmlHanldedRight()
{
string subscriptionDescriptionXml = $@"<entry xmlns=""{ManagementClientConstants.AtomNamespace}"">" +
$@"<title xmlns=""{ManagementClientConstants.AtomNamespace}"">testqueue1</title>" +
$@"<content xmlns=""{ManagementClientConstants.AtomNamespace}"">" +
$@"<SubscriptionDescription xmlns=""{ManagementClientConstants.ServiceBusNamespace}"">" +
$"<LockDuration>{XmlConvert.ToString(TimeSpan.FromMinutes(1))}</LockDuration>" +
$"<RequiresSession>true</RequiresSession>" +
$"<DefaultMessageTimeToLive>{XmlConvert.ToString(TimeSpan.FromMinutes(60))}</DefaultMessageTimeToLive>" +
$"<DeadLetteringOnMessageExpiration>false</DeadLetteringOnMessageExpiration>" +
$"<DeadLetteringOnFilterEvaluationExceptions>false</DeadLetteringOnFilterEvaluationExceptions>" +
$"<MaxDeliveryCount>10</MaxDeliveryCount>" +
$"<EnableBatchedOperations>true</EnableBatchedOperations>" +
$"<Status>Active</Status>" +
$"<ForwardTo>fq1</ForwardTo>" +
$"<UserMetadata></UserMetadata>" +
$"<AutoDeleteOnIdle>{XmlConvert.ToString(TimeSpan.FromMinutes(60))}</AutoDeleteOnIdle>" +
$"<IsClientAffine>prop1</IsClientAffine>" +
$"<ClientAffineProperties><ClientId>xyz</ClientId><IsDurable>false</IsDurable><IsShared>true</IsShared></ClientAffineProperties>" +
$"<UnknownElement3>prop3</UnknownElement3>" +
$"<UnknownElement4>prop4</UnknownElement4>" +
$"</SubscriptionDescription>" +
$"</content>" +
$"</entry>";
SubscriptionDescription subscriptionDesc = SubscriptionDescriptionExtensions.ParseFromContent("abcd", subscriptionDescriptionXml);
Assert.NotNull(subscriptionDesc.UnknownProperties);
XDocument doc = SubscriptionDescriptionExtensions.Serialize(subscriptionDesc);
XName subscriptionDescriptionElementName = XName.Get("SubscriptionDescription", ManagementClientConstants.ServiceBusNamespace);
XElement expectedSubscriptionDecriptionElement = XElement.Parse(subscriptionDescriptionXml).Descendants(subscriptionDescriptionElementName).FirstOrDefault();
XElement serializedSubscriptionDescritionElement = doc.Descendants(subscriptionDescriptionElementName).FirstOrDefault();
XNode expectedChildNode = expectedSubscriptionDecriptionElement.FirstNode;
XNode actualChildNode = serializedSubscriptionDescritionElement.FirstNode;
while (expectedChildNode != null)
{
Assert.NotNull(actualChildNode);
Assert.True(XNode.DeepEquals(expectedChildNode, actualChildNode), $"SubscriptionDescrition parsing and serialization combo didn't work as expected. {expectedChildNode.ToString()}");
expectedChildNode = expectedChildNode.NextNode;
actualChildNode = actualChildNode.NextNode;
}
}
public static void Main(string[] args)
{
Console.WriteLine("Enter name:");
var usernamae = Console.ReadLine();
var manager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!manager.TopicExists(topicPath))
{
manager.CreateTopic(topicPath);
}
var subscriptiondesc = new SubscriptionDescription(topicPath, usernamae)
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(10)
};
manager.CreateSubscription(subscriptiondesc);
var topicClient = TopicClient.CreateFromConnectionString(connectionString, topicPath);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicPath, usernamae);
subscriptionClient.OnMessage(ProcessMessage);
var welcomeMessage = new BrokeredMessage("Has entered the room");
welcomeMessage.Label = usernamae;
topicClient.Send(welcomeMessage);
while (true)
{
var message = Console.ReadLine();
if (message == "exit")
{
break;
}
var chatMessage = new BrokeredMessage(message);
chatMessage.Label = usernamae;
topicClient.Send(chatMessage);
}
topicClient.Close();
subscriptionClient.Close();
}
public void CreateSubscription(string topicPath, string subscriptionName)
{
Console.WriteLine("Creating Subscription {0}/subscriptions/{1}", topicPath, subscriptionName);
if (!m_NamespaceManager.TopicExists(topicPath))
{
CreateTopic(topicPath);
}
if (m_NamespaceManager.SubscriptionExists(topicPath, subscriptionName))
{
Console.WriteLine("Subscription Already Exists!");
return;
}
var subscriptionDescription = new SubscriptionDescription(topicPath, subscriptionName)
{
};
var description = m_NamespaceManager.CreateSubscription(subscriptionDescription);
Console.WriteLine("Done!");
}
/// <summary>
/// 创建订阅命名空间
/// </summary>
/// <param name="topicName">主题名称</param>
/// <param name="subscriptionName">订阅名称</param>
public void CreateSubscription(string topicName, string subscriptionName)
{
if (string.IsNullOrEmpty(topicName))
{
throw new ArgumentNullException("topicName");
}
if (string.IsNullOrEmpty(subscriptionName))
{
throw new ArgumentNullException("subscriptionName");
}
GetNamespaceManager();
if (!NamespaceManager.SubscriptionExists(topicName, subscriptionName))
{
SubscriptionDescription sd = new SubscriptionDescription(topicName, subscriptionName);
NamespaceManager.CreateSubscription(sd);
}
}
public void GetQMessageCount(TopicDescription TopicDesc, SubscriptionDescription SubscriptionDesc)
{
SubscriptionWrapper SW = new SubscriptionWrapper(SubscriptionDesc, TopicDesc);
long lngCount = namespaceManager.GetSubscription(TopicDesc.Path, SubscriptionDesc.Name).MessageCount;
string strlabelMessageCount = lngCount.ToString();
MessageCountDetails MsgCD = namespaceManager.GetSubscription(TopicDesc.Path, SubscriptionDesc.Name).MessageCountDetails;
string strlabelTransferMessageCount = MsgCD.TransferMessageCount.ToString();
string strlabelActiveMessageCount = MsgCD.ActiveMessageCount.ToString();
string strlabelScheduledMessageCount = MsgCD.ScheduledMessageCount.ToString();
string strlabelDeadLetterMessageCount = MsgCD.DeadLetterMessageCount.ToString();
string strlabelMaxDeliveryCount = namespaceManager.GetSubscription(TopicDesc.Path, SubscriptionDesc.Name).MaxDeliveryCount.ToString();
String strStatus = namespaceManager.GetSubscription(TopicDesc.Path, SubscriptionDesc.Name).Status.ToString();
string strlabelStatus = strStatus;
tc.TrackEvent("GetQMessageCount");
tc.TrackMetric("Topic: " + SW.TopicDescription.Path, lngCount);
tc.TrackMetric(SW.SubscriptionDescription.Name, lngCount);
tc.TrackMetric("TransferMessageCount", MsgCD.TransferMessageCount);
tc.TrackMetric("ActiveMessageCount", MsgCD.ActiveMessageCount);
tc.TrackMetric("ScheduledMessageCount", MsgCD.ScheduledMessageCount);
tc.TrackMetric("DeadLetterMessageCount", MsgCD.DeadLetterMessageCount);
lngIndex++;
Console.WriteLine(lngIndex.ToString() + ".\n");
Console.WriteLine("Topic: " + SW.TopicDescription.Path);
Console.WriteLine("Subscription: " + SW.SubscriptionDescription.Name);
Console.WriteLine("Messages Count: " + lngCount);
Console.WriteLine("Status: " + strStatus);
Console.WriteLine("TransferMessageCount:" + MsgCD.TransferMessageCount);
Console.WriteLine("ActiveMessageCount:" + MsgCD.ActiveMessageCount);
Console.WriteLine("ScheduledMessageCount:" + MsgCD.ScheduledMessageCount);
Console.WriteLine("DeadLetterMessageCount:" + MsgCD.DeadLetterMessageCount);
Console.WriteLine("\n");
GetMessages(true, true, (int)lngCount, SW);
}
public void TestSqlFilter()
{
string topicName = "TestSqlFilter";
string SubscriptionName = "TestSqlFilter".ToLower() + Guid.NewGuid().ToString().Substring(0, 5);
var ns = NamespaceManager.CreateFromConnectionString(TestServiceBus.serviceBusConnectionString);
try
{
ns.CreateTopic(topicName);
var filter = new SqlFilter("From LIKE '%Smith'");
SubscriptionDescription initialDesc = ns.CreateSubscription(topicName, SubscriptionName, filter);
IEnumerable <RuleDescription> rules = ns.GetRules(topicName, SubscriptionName);
Assert.IsTrue((rules.First().Filter as SqlFilter).SqlExpression.Equals("From LIKE '%Smith'"));
}
finally
{
ns.DeleteTopic(topicName);
}
}
public async Task CreateSubscriptionAsync(string topicName, string subscriptionName, Filter filter)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
var namespaceManager = NamespaceManager.CreateFromConnectionString(Settings.ServiceBusConnectionString);
if (!await namespaceManager.SubscriptionExistsAsync(topicName, subscriptionName))
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName)
{
LockDuration = TimeSpan.FromMinutes(5)
};
await namespaceManager.CreateSubscriptionAsync(subscriptionDescription, filter);
}
}
public async Task <object> CreatetopicsqlFilterSubscription(string topicname)
{
var client = new ManagementClient(sbconnection);
bool topicExists = await client.TopicExistsAsync(topicname).ConfigureAwait(false);
if (topicExists)
{
SubscriptionDescription subName = new SubscriptionDescription(topicname, "SQLFilterSubscription");
subName.Status = 0;
RuleDescription subscriptionRule = new RuleDescription();
var result01 = await client.CreateSubscriptionAsync(subName, subscriptionRule).ConfigureAwait(false);
return(result01);
}
else
{
return("Unable to create sqlfilter Subscription!!");
}
}
public async Task DeleteSubscription(string topicPath, string subscriptionName, SubscriptionMetadataInternal metadata, string sqlFilter, INamespaceManagerInternal namespaceManager, string forwardTo)
{
var meta = metadata as ForwardingTopologySubscriptionMetadata;
// var subscriptionDescription = subscriptionDescriptionFactory(topicPath, subscriptionName, settings);
var subscriptionDescription = new SubscriptionDescription(topicPath, subscriptionName);
try
{
if (await ExistsAsync(topicPath, subscriptionName, metadata.Description, namespaceManager, removeCacheEntry: true).ConfigureAwait(false))
{
var ruleDescription = new RuleDescription
{
Filter = new SqlFilter(sqlFilter),
Name = metadata.SubscriptionNameBasedOnEventWithNamespace
};
logger.Info($"Removing subscription rule '{ruleDescription.Name}' for event '{meta.SubscribedEventFullName}'.");
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(meta.NamespaceInfo.ConnectionString, topicPath, subscriptionName);
await subscriptionClient.RemoveRuleAsync(ruleDescription.Name).ConfigureAwait(false);
var remainingRules = await namespaceManager.GetRules(subscriptionDescription).ConfigureAwait(false);
if (!remainingRules.Any())
{
await namespaceManager.DeleteSubscription(subscriptionDescription).ConfigureAwait(false);
logger.Debug($"Subscription '{metadata.Description}' created as '{subscriptionDescription.Name}' was removed as part of unsubscribe since events are subscribed to.");
}
}
}
catch (MessagingException ex)
{
var loggedMessage = $"{(ex.IsTransient ? "Transient" : "Non transient")} {ex.GetType().Name} occurred on subscription '{subscriptionDescription.Name}' deletion for topic '{subscriptionDescription.TopicPath}' in namespace '{namespaceManager.Address.Host}'.";
if (!ex.IsTransient)
{
logger.Fatal(loggedMessage, ex);
throw;
}
logger.Info(loggedMessage, ex);
}
}
private HeaterStatus DoCommunication(string correlationId, string action)
{
var subscriptionDesc = new SubscriptionDescription(_topicNameReceive, correlationId);
subscriptionDesc.DefaultMessageTimeToLive = TimeSpan.FromSeconds(30);
_namespaceMgr.CreateSubscription(subscriptionDesc, new CorrelationFilter(correlationId));
Trace.TraceInformation("Performing Heater Action: {0}", action);
_client.Send(CreateMessage(correlationId, action));
var receiveClient = _factory.CreateSubscriptionClient(_topicNameReceive, correlationId, ReceiveMode.ReceiveAndDelete);
var receiveMessage = receiveClient.Receive();
Stream ms = receiveMessage.GetBody<Stream>();
var s = new StreamReader(ms).ReadToEnd();
Trace.TraceInformation("Heater Reports: {0}", s);
_namespaceMgr.DeleteSubscription(_topicNameReceive, correlationId);
return Parse(s);
}
public static async Task CreateSubscriptionIfNotExists(this NamespaceManager namespaceManager, ILogger logger, string topicIdentifier,
string subscriptionIdentifier)
{
if (await namespaceManager.SubscriptionExistsAsync(topicIdentifier, subscriptionIdentifier))
return;
await namespaceManager.CreateTopicIfNotExists(logger, topicIdentifier);
try
{
logger.Debug("Creating subscription:{0} for topic:{1}", subscriptionIdentifier, topicIdentifier);
var subscriptionDescription = new SubscriptionDescription(topicIdentifier, subscriptionIdentifier);
await namespaceManager.CreateSubscriptionAsync(subscriptionDescription);
}
catch (MessagingEntityAlreadyExistsException)
{
// the subscription was created while we were trying to create it.
logger.Warn("A subscription with the name {0} already exists", subscriptionIdentifier);
}
}
public SubscriptionClient Create(Type eventType, string topicPath, string subscriptionname)
{
if (NamespaceClient.TopicExists(topicPath))
{
try
{
if (!NamespaceClient.SubscriptionExists(topicPath, subscriptionname))
{
var description = new SubscriptionDescription(topicPath, subscriptionname)
{
LockDuration = LockDuration,
RequiresSession = RequiresSession,
DefaultMessageTimeToLive = DefaultMessageTimeToLive,
EnableDeadLetteringOnMessageExpiration = EnableDeadLetteringOnMessageExpiration,
MaxDeliveryCount = MaxDeliveryCount,
EnableBatchedOperations = EnableBatchedOperations,
EnableDeadLetteringOnFilterEvaluationExceptions =
EnableDeadLetteringOnFilterEvaluationExceptions
};
var filter = string.Format( "[{0}] LIKE '{1}%' OR [{0}] LIKE '%{1}%' OR [{0}] LIKE '%{1}' OR [{0}] = '{1}'", Headers.EnclosedMessageTypes, eventType.AssemblyQualifiedName);
var typefilter = new SqlFilter(filter);
NamespaceClient.CreateSubscription(description, typefilter);
}
}
catch (MessagingEntityAlreadyExistsException)
{
// the queue already exists or another node beat us to it, which is ok
}
return Factory.CreateSubscriptionClient(topicPath, subscriptionname, ReceiveMode.PeekLock);
}
return null;
}
public async Task<IEnumerable<string>> Post()
{
var namespaceManager = new NamespaceManager(_address, _settings.TokenProvider);
if (!await namespaceManager.TopicExistsAsync(TopicName))
{
var topicDescription = new TopicDescription(TopicName);
var subscriptionDescription = new SubscriptionDescription(TopicName, SubscriptionName);
topicDescription.EnablePartitioning = true;
topicDescription.EnableBatchedOperations = false;
subscriptionDescription.EnableBatchedOperations = false;
await namespaceManager.CreateTopicAsync(topicDescription);
await namespaceManager.CreateSubscriptionAsync(subscriptionDescription);
}
var messagingFactory = MessagingFactory.Create(_address, _settings);
var client = messagingFactory.CreateTopicClient(TopicName);
IEnumerable<string> result = ProcessPost(client);
Task clientTask = client.CloseAsync();
Task factoryTask = messagingFactory.CloseAsync();
await Task.WhenAll(clientTask, factoryTask);
return result;
}
private ServiceBusSingleton()
{
var connectionString = CloudConfigurationManager.GetSetting(ServiceBusConnectionStrings.NodeServiceBusConnection);
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(ServiceBusPathNames.ServiceBusEventQueue))
{
namespaceManager.CreateQueue(ServiceBusPathNames.ServiceBusEventQueue);
}
_queueClient = QueueClient.CreateFromConnectionString(connectionString, ServiceBusPathNames.ServiceBusEventQueue);
var subName = _rnd.Next().ToString(); //Guid.NewGuid().ToString();
var conn = CloudConfigurationManager.GetSetting(ServiceBusConnectionStrings.WorkerServiceBusConnection);
var ns = NamespaceManager.CreateFromConnectionString(conn);
if (!ns.SubscriptionExists(ServiceBusPathNames.ServiceBusUpdateTopic, subName))
{
var sd = new SubscriptionDescription(ServiceBusPathNames.ServiceBusUpdateTopic, subName)
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(5)
};
ns.CreateSubscription(sd);
}
_subscriptionClient = SubscriptionClient.CreateFromConnectionString(conn, ServiceBusPathNames.ServiceBusUpdateTopic, subName);
}
/// <summary>
/// Removes the rule passed as a argument.
/// </summary>
/// <param name="subscriptionDescription">A subscription belonging to the current service namespace base.</param>
/// <param name="rule">The rule to remove.</param>
public void RemoveRule(SubscriptionDescription subscriptionDescription, RuleDescription rule)
{
if (subscriptionDescription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
if (rule == null)
{
throw new ArgumentException(RuleCannotBeNull);
}
var subscriptionClient = MessagingFactory.CreateSubscriptionClient(subscriptionDescription.TopicPath,
subscriptionDescription.Name);
RetryHelper.RetryAction(() => subscriptionClient.RemoveRule(rule.Name), writeToLog);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, RuleDeleted, rule.Name, subscriptionClient.Name));
OnDelete(new ServiceBusHelperEventArgs(new RuleWrapper(rule, subscriptionDescription), EntityType.Rule));
}
/// <summary>
/// Initializes a new instance of the SubscriptionWrapper class.
/// </summary>
/// <param name="subscription">A subscription.</param>
/// <param name="topic">The topic the subscription belongs to.</param>
/// <param name="filter">The OData filter.</param>
public SubscriptionWrapper(SubscriptionDescription subscription, TopicDescription topic, string filter)
{
SubscriptionDescription = subscription;
TopicDescription = topic;
Filter = filter;
}
/// <summary>
/// Removes the subscription passed as a argument.
/// </summary>
/// <param name="subscriptionDescription">The subscription to remove.</param>
public void DeleteSubscription(SubscriptionDescription subscriptionDescription)
{
if (subscriptionDescription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
RetryHelper.RetryAction(() => namespaceManager.DeleteSubscription(subscriptionDescription.TopicPath, subscriptionDescription.Name), writeToLog);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, SubscriptionDeleted, subscriptionDescription.Name, subscriptionDescription.TopicPath));
OnDelete(new ServiceBusHelperEventArgs(subscriptionDescription, EntityType.Subscription));
}
/// <summary>
/// Adds a rule to this subscription, with a default pass-through filter added.
/// </summary>
/// <param name="subscriptionDescription">The subscription to add the rule to.</param>
/// <param name="ruleDescription">Metadata of the rule to be created.</param>
/// <returns>Returns a newly-created RuleDescription object.</returns>
public RuleDescription AddRule(SubscriptionDescription subscriptionDescription, RuleDescription ruleDescription)
{
if (subscriptionDescription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
if (ruleDescription == null)
{
throw new ArgumentException(RuleDescriptionCannotBeNull);
}
var subscriptionClient = RetryHelper.RetryFunc(() => MessagingFactory.CreateSubscriptionClient(subscriptionDescription.TopicPath,
subscriptionDescription.Name),
writeToLog);
RetryHelper.RetryAction(() => subscriptionClient.AddRule(ruleDescription), writeToLog);
Func<IEnumerable<RuleDescription>> func = (() => namespaceManager.GetRules(subscriptionDescription.TopicPath, subscriptionDescription.Name));
var rules = RetryHelper.RetryFunc(func, writeToLog);
var rule = rules.FirstOrDefault(r => r.Name == ruleDescription.Name);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, RuleCreated, ruleDescription.Name, subscriptionDescription.Name));
OnCreate(new ServiceBusHelperEventArgs(new RuleWrapper(rule, subscriptionDescription), EntityType.Rule));
return rule;
}
/// <summary>
/// Retrieves an enumerated collection of rules attached to the subscription passed as a parameter.
/// </summary>
/// <param name="subscription">A subscription belonging to the current service namespace base.</param>
/// <returns>Returns an IEnumerable<SubscriptionDescription/> collection of rules attached to the subscription passed as a parameter.</returns>
public IEnumerable<RuleDescription> GetRules(SubscriptionDescription subscription)
{
if (subscription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
if (namespaceManager != null)
{
return RetryHelper.RetryFunc(() => namespaceManager.GetRules(subscription.TopicPath, subscription.Name), writeToLog);
}
throw new ApplicationException(ServiceBusIsDisconnected);
}
/// <summary>
/// Updates a subscription to this topic.
/// </summary>
/// <param name="topicDescription">A topic belonging to the current service namespace base.</param>
/// <param name="subscriptionDescription">Metadata of the subscription to be updated.</param>
/// <returns>Returns an updated SubscriptionDescription object.</returns>
public SubscriptionDescription UpdateSubscription(TopicDescription topicDescription, SubscriptionDescription subscriptionDescription)
{
if (topicDescription == null)
{
throw new ArgumentException(TopicDescriptionCannotBeNull);
}
if (subscriptionDescription == null)
{
throw new ArgumentException(DescriptionCannotBeNull);
}
var subscription = RetryHelper.RetryFunc(() => namespaceManager.UpdateSubscription(subscriptionDescription), writeToLog);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, SubscriptionUpdated, subscription.Name, topicDescription.Path));
//OnCreate(new ServiceBusHelperEventArgs(new SubscriptionWrapper(subscription, topicDescription), EntityType.Subscription));
return subscription;
}
public SubscriptionDescription CreateSubscription(SubscriptionDescription description, Filter filter)
{
return namespaceManager.CreateSubscription(description, filter);
}
public static async Task<SubscriptionDescription> CreateTopicSubscriptionSafeAsync(this NamespaceManager namespaceManager,
SubscriptionDescription description)
{
var create = true;
SubscriptionDescription subscriptionDescription = null;
try
{
subscriptionDescription = await namespaceManager.GetSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(subscriptionDescription.ForwardTo))
{
if (_log.IsWarnEnabled)
{
_log.WarnFormat("Removing invalid subscription: {0} ({1} -> {2})", subscriptionDescription.Name, subscriptionDescription.TopicPath,
subscriptionDescription.ForwardTo);
}
await namespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
}
else
{
create = false;
}
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
var created = false;
try
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Creating subscription {0} -> {1}", description.TopicPath, description.Name);
subscriptionDescription = await namespaceManager.CreateSubscriptionAsync(description).ConfigureAwait(false);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
throw;
}
if (!created)
subscriptionDescription = await namespaceManager.GetSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Subscription: {0} ({1} -> {2})", subscriptionDescription.Name, subscriptionDescription.TopicPath,
subscriptionDescription.ForwardTo);
}
return subscriptionDescription;
}
private void CreateSubscription(ServiceBusConnectionContext connectionContext, int topicIndex)
{
lock (connectionContext.SubscriptionsLock)
{
if (connectionContext.IsDisposed)
{
return;
}
string topicName = connectionContext.TopicNames[topicIndex];
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = _idleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
connectionContext.SetSubscriptionContext(new SubscriptionContext(topicName, subscriptionName, receiver), topicIndex);
var receiverContext = new ReceiverContext(topicIndex, receiver, connectionContext);
ProcessMessages(receiverContext);
// Open the stream
connectionContext.OpenStream(topicIndex);
}
}
/// <summary>
/// Initializes a new instance of the SubscriptionWrapper class.
/// </summary>
/// <param name="subscription">A subscription.</param>
/// <param name="topic">The topic the subscription belongs to.</param>
public SubscriptionWrapper(SubscriptionDescription subscription, TopicDescription topic)
{
SubscriptionDescription = subscription;
TopicDescription = topic;
}
private void btnCreateDelete_Click(object sender, EventArgs e)
{
try
{
if (serviceBusHelper == null ||
subscriptionWrapper == null ||
subscriptionWrapper.TopicDescription == null)
{
return;
}
if (btnCreateDelete.Text == DeleteText &&
subscriptionWrapper.SubscriptionDescription != null &&
!string.IsNullOrWhiteSpace(subscriptionWrapper.SubscriptionDescription.Name))
{
using (var deleteForm = new DeleteForm(subscriptionWrapper.SubscriptionDescription.Name, SubscriptionEntity.ToLower()))
{
if (deleteForm.ShowDialog() == DialogResult.OK)
{
serviceBusHelper.DeleteSubscription(subscriptionWrapper.SubscriptionDescription);
}
}
return;
}
if (btnCreateDelete.Text == CreateText)
{
if (string.IsNullOrWhiteSpace(txtName.Text))
{
writeToLog(NameCannotBeNull);
return;
}
var subscriptionDescription = new SubscriptionDescription(subscriptionWrapper.TopicDescription.Path, txtName.Text);
if (!string.IsNullOrWhiteSpace(txtUserMetadata.Text))
{
subscriptionDescription.UserMetadata = txtUserMetadata.Text;
}
if (!string.IsNullOrWhiteSpace(txtForwardTo.Text))
{
subscriptionDescription.ForwardTo = txtForwardTo.Text;
}
if (!string.IsNullOrWhiteSpace(txtForwardDeadLetteredMessagesTo.Text))
{
subscriptionDescription.ForwardDeadLetteredMessagesTo = txtForwardDeadLetteredMessagesTo.Text;
}
if (!string.IsNullOrWhiteSpace(txtMaxDeliveryCount.Text))
{
int value;
if (int.TryParse(txtMaxDeliveryCount.Text, out value))
{
subscriptionDescription.MaxDeliveryCount = value;
}
else
{
writeToLog(MaxDeliveryCountMustBeANumber);
return;
}
}
var days = 0;
var hours = 0;
var minutes = 0;
var seconds = 0;
var milliseconds = 0;
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveDays.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveHours.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMinutes.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveSeconds.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMilliseconds.Text))
{
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveDays.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveDays.Text, out days))
{
writeToLog(DefaultMessageTimeToLiveDaysMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveHours.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveHours.Text, out hours))
{
writeToLog(DefaultMessageTimeToLiveHoursMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMinutes.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveMinutes.Text, out minutes))
{
writeToLog(DefaultMessageTimeToLiveMinutesMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveSeconds.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveSeconds.Text, out seconds))
{
writeToLog(DefaultMessageTimeToLiveSecondsMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMilliseconds.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveMilliseconds.Text, out milliseconds))
{
writeToLog(DefaultMessageTimeToLiveMillisecondsMustBeANumber);
return;
}
}
subscriptionDescription.DefaultMessageTimeToLive = new TimeSpan(days, hours, minutes, seconds, milliseconds);
}
days = 0;
hours = 0;
minutes = 0;
seconds = 0;
milliseconds = 0;
if (!string.IsNullOrWhiteSpace(txtLockDurationDays.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationHours.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationMinutes.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationSeconds.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationMilliseconds.Text))
{
if (!string.IsNullOrWhiteSpace(txtLockDurationDays.Text))
{
if (!int.TryParse(txtLockDurationDays.Text, out days))
{
writeToLog(LockDurationDaysMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationHours.Text))
{
if (!int.TryParse(txtLockDurationHours.Text, out hours))
{
writeToLog(LockDurationHoursMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationMinutes.Text))
{
if (!int.TryParse(txtLockDurationMinutes.Text, out minutes))
{
writeToLog(LockDurationMinutesMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationSeconds.Text))
{
if (!int.TryParse(txtLockDurationSeconds.Text, out seconds))
{
writeToLog(LockDurationSecondsMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationMilliseconds.Text))
{
if (!int.TryParse(txtLockDurationMilliseconds.Text, out milliseconds))
{
writeToLog(LockDurationMillisecondsMustBeANumber);
return;
}
}
subscriptionDescription.LockDuration = new TimeSpan(days, hours, minutes, seconds, milliseconds);
}
days = 0;
hours = 0;
minutes = 0;
seconds = 0;
milliseconds = 0;
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleDays.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleHours.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMinutes.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleSeconds.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMilliseconds.Text))
{
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleDays.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleDays.Text, out days))
{
writeToLog(AutoDeleteOnIdleDaysMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleHours.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleHours.Text, out hours))
{
writeToLog(AutoDeleteOnIdleHoursMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMinutes.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleMinutes.Text, out minutes))
{
writeToLog(AutoDeleteOnIdleMinutesMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleSeconds.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleSeconds.Text, out seconds))
{
writeToLog(AutoDeleteOnIdleSecondsMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMilliseconds.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleMilliseconds.Text, out milliseconds))
{
writeToLog(AutoDeleteOnIdleMillisecondsMustBeANumber);
return;
}
}
subscriptionDescription.AutoDeleteOnIdle = new TimeSpan(days, hours, minutes, seconds, milliseconds);
}
subscriptionDescription.EnableBatchedOperations = checkedListBox.GetItemChecked(EnableBatchedOperationsIndex);
subscriptionDescription.EnableDeadLetteringOnFilterEvaluationExceptions = checkedListBox.GetItemChecked(EnableDeadLetteringOnFilterEvaluationExceptionsIndex);
subscriptionDescription.EnableDeadLetteringOnMessageExpiration = checkedListBox.GetItemChecked(EnableDeadLetteringOnMessageExpirationIndex);
subscriptionDescription.RequiresSession = checkedListBox.GetItemChecked(RequiresSessionIndex);
var ruleDescription = new RuleDescription();
if (!string.IsNullOrWhiteSpace(txtFilter.Text))
{
ruleDescription.Filter = new SqlFilter(txtFilter.Text);
}
if (!string.IsNullOrWhiteSpace(txtAction.Text))
{
ruleDescription.Action = new SqlRuleAction(txtAction.Text);
}
subscriptionWrapper.SubscriptionDescription = serviceBusHelper.CreateSubscription(subscriptionWrapper.TopicDescription,
subscriptionDescription,
ruleDescription);
InitializeData();
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
private void InitializeSubscriptionClient()
{
var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(OwnerIssuer, OwnerKey);
var serviceUrl = ServiceBusEnvironment.CreateServiceUri("sb", ServiceBusNamespace, string.Empty);
var namespaceManager = new NamespaceManager(serviceUrl, tokenProvider);
Trace.WriteLine("Initializing Subscription...", "Info");
SubscriptionDescription subscriptionDescription = new SubscriptionDescription(SensorApiTopic, "TemperatureTap");
if (!namespaceManager.SubscriptionExists(SensorApiTopic, "TemperatureTap"))
{
namespaceManager.CreateSubscription(subscriptionDescription);
}
Trace.WriteLine("Initialized Subscription.", "Info");
Trace.WriteLine("Initializing SubscriptionClient...", "Info");
var messagingFactory = MessagingFactory.Create(serviceUrl, tokenProvider);
_subscriptionClient = messagingFactory.CreateSubscriptionClient(SensorApiTopic, "TemperatureTap");
Trace.WriteLine("Initialized SubscriptionClient...", "Info");
}
/// <summary>
/// This topic is used to route messages to the correct analysis machine for analytics.
/// </summary>
/// <returns></returns>
private static async Task DeployAnalysisTopic(TextWriter writer, bool recreate = false)
{
var SubscriptionsAndConditions = new Dictionary<string, SqlFilter>()
{
{ "ubuntu", new SqlFilter("target_os = 'ubuntu'") },
{ "centos", new SqlFilter("target_os = 'centos' OR target_os = 'rhel' OR target_os = 'redhat'") },
{ "windows", new SqlFilter("target_os = 'windows'") }
};
// check if the topic exists, then create it.
var nsManager = NamespaceManager.CreateFromConnectionString(NearbyConfig.Settings["dumpling-service bus connection string"]);
var topicName = NearbyConfig.Settings["dumpling-service analysis topic path"];
CreationDelegate createTopic = async () =>
{
var topicDescription = new TopicDescription(topicName);
await nsManager.CreateTopicAsync(topicDescription);
writer.WriteLine("topic created");
};
var exists = await nsManager.TopicExistsAsync(topicName);
if (exists && recreate)
{
writer.WriteLine($"topic {topicName} deleting it");
await nsManager.DeleteTopicAsync(topicName);
createTopic();
}
else if (!exists)
{
createTopic();
}
else
{
writer.WriteLine($"'{topicName}' exists and we are not recreating.");
}
// Topic is created, now we'll do the subscriptions.
foreach (var subscription in SubscriptionsAndConditions)
{
// I use this to avoid repeating myself in the createSubscription(...) calls below.
CreationDelegate createSubscription = async () =>
{
SubscriptionDescription description = new SubscriptionDescription(topicName, subscription.Key);
// When an item is retrieved from the subscription, a machine owns that lock, and then must clean up after it.
// if the lock expires that machine will not be able to delete the message and it is possible for another machine to take it.
description.LockDuration = TimeSpan.FromMinutes(5);
// after 16 hours, dead letter any messages in the queue. In my experience this is necessary
// because sometimes messages can get 'stuck' if they take too long to evaluate. We won't just delete
// them though, we'll dead letter them.
description.DefaultMessageTimeToLive = TimeSpan.FromHours(16);
description.EnableDeadLetteringOnMessageExpiration = true;
await nsManager.CreateSubscriptionAsync(description, subscription.Value);
writer.WriteLine($"created subscription: {subscription.Key}");
};
// next we'll (re)create the subscriptions
exists = await nsManager.SubscriptionExistsAsync(topicName, subscription.Key);
if (exists && recreate)
{
writer.WriteLine($"'{subscription.Key}' already exists; deleting");
await nsManager.DeleteSubscriptionAsync(topicName, subscription.Key);
createSubscription();
}
else if (!exists)
{
createSubscription();
}
else
{
writer.WriteLine($"'{subscription.Key}' already exists and we're not recreating.");
}
}
}
public static async Task<SubscriptionDescription> CreateTopicSubscriptionSafeAsync(this NamespaceManager namespaceManager, string subscriptionName, string topicPath, string queuePath)
{
bool create = true;
SubscriptionDescription subscriptionDescription = null;
try
{
subscriptionDescription = await namespaceManager.GetSubscriptionAsync(topicPath, subscriptionName);
if (!queuePath.Equals(subscriptionDescription.ForwardTo))
{
if (_log.IsWarnEnabled)
{
_log.WarnFormat("Removing invalid subscription: {0} ({1} -> {2})", subscriptionDescription.Name, subscriptionDescription.TopicPath,
subscriptionDescription.ForwardTo);
}
await namespaceManager.DeleteSubscriptionAsync(topicPath, subscriptionName);
}
else
create = false;
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
bool created = false;
try
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Creating subscription {0} -> {1}", topicPath, queuePath);
var description = new SubscriptionDescription(topicPath, subscriptionName)
{
ForwardTo = queuePath,
};
subscriptionDescription = await namespaceManager.CreateSubscriptionAsync(description);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
throw;
}
if (!created)
subscriptionDescription = await namespaceManager.GetSubscriptionAsync(topicPath, subscriptionName);
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Subscription: {0} ({1} -> {2})", subscriptionDescription.Name, subscriptionDescription.TopicPath,
subscriptionDescription.ForwardTo);
}
return subscriptionDescription;
}
/// <summary>
/// Retrieves an enumerable collection of all message sessions for the subscription passed as argument.
/// </summary>
/// <param name="subscription">The subscription for which to search message sessions.</param>
/// <param name="dateTime">The time the session was last updated.</param>
/// <returns>Returns an IEnumerable<QueueDescription/> collection of message sessions.</returns>
public IEnumerable<MessageSession> GetMessageSessions(SubscriptionDescription subscription, DateTime? dateTime)
{
if (subscription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
if (messagingFactory == null)
{
throw new ApplicationException(ServiceBusIsDisconnected);
}
var subscriptionClient = messagingFactory.CreateSubscriptionClient(subscription.TopicPath, subscription.Name);
return RetryHelper.RetryFunc(() => dateTime != null ? subscriptionClient.GetMessageSessions(dateTime.Value) : subscriptionClient.GetMessageSessions(), writeToLog);
}
public ServiceBusSubscription Subscribe(IList<string> topicNames,
Action<int, IEnumerable<BrokeredMessage>> handler,
Action<int, Exception> errorHandler)
{
if (topicNames == null)
{
throw new ArgumentNullException("topicNames");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
_trace.TraceInformation("Subscribing to {0} topic(s) in the service bus...", topicNames.Count);
var subscriptions = new ServiceBusSubscription.SubscriptionContext[topicNames.Count];
var clients = new TopicClient[topicNames.Count];
for (var topicIndex = 0; topicIndex < topicNames.Count; ++topicIndex)
{
string topicName = topicNames[topicIndex];
if (!_namespaceManager.TopicExists(topicName))
{
try
{
_trace.TraceInformation("Creating a new topic {0} in the service bus...", topicName);
_namespaceManager.CreateTopic(topicName);
_trace.TraceInformation("Creation of a new topic {0} in the service bus completed successfully.", topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new topic {0} threw an MessagingEntityAlreadyExistsException.", topicName);
}
}
// Create a client for this topic
clients[topicIndex] = TopicClient.CreateFromConnectionString(_configuration.ConnectionString, topicName);
_trace.TraceInformation("Creation of a new topic client {0} completed successfully.", topicName);
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = IdleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
subscriptions[topicIndex] = new ServiceBusSubscription.SubscriptionContext(topicName, subscriptionName, receiver);
var receiverContext = new ReceiverContext(topicIndex, receiver, handler, errorHandler);
ProcessMessages(receiverContext);
}
_trace.TraceInformation("Subscription to {0} topics in the service bus Topic service completed successfully.", topicNames.Count);
return new ServiceBusSubscription(_configuration, _namespaceManager, subscriptions, clients);
}
private void RefreshIndividualSubscription(SubscriptionDescription subscriptionDescription, TreeNode subscriptionNode)
{
var rules = serviceBusHelper.GetRules(subscriptionDescription);
var ruleDescriptions = rules as RuleDescription[] ?? rules.ToArray();
if (rules == null || !ruleDescriptions.Any())
return;
var subscriptionNodeWasExpanded = subscriptionNode.IsExpanded;
var rulesNodeWasExpanded = subscriptionNode.Nodes.Count > 0 ? subscriptionNode.Nodes[0].IsExpanded : false;
subscriptionNode.Nodes.Clear();
var rulesNode = subscriptionNode.Nodes.Add(RuleEntities, RuleEntities, RuleListIconIndex, RuleListIconIndex);
rulesNode.ContextMenuStrip = rulesContextMenuStrip;
rulesNode.Tag = new RuleWrapper(null, subscriptionDescription);
foreach (var rule in ruleDescriptions)
{
var ruleNode = rulesNode.Nodes.Add(rule.Name, rule.Name, RuleIconIndex, RuleIconIndex);
ruleNode.ContextMenuStrip = ruleContextMenuStrip;
ruleNode.Tag = new RuleWrapper(rule, subscriptionDescription);
WriteToLog(string.Format(CultureInfo.CurrentCulture, RuleRetrievedFormat, rule.Name, subscriptionDescription.Name, subscriptionDescription.TopicPath), false);
}
if (rulesNodeWasExpanded)
rulesNode.Expand();
if (subscriptionNodeWasExpanded)
subscriptionNode.Expand();
}
