private void DeleteQueueInternal(Uri address, string path, TokenProvider tokenProvider)
{
var settings = new NamespaceManagerSettings()
{
TokenProvider = tokenProvider
};
var namespaceClient = new ServiceBus.NamespaceManager(address, settings);
try
{
namespaceClient.DeleteQueue(path);
Console.WriteLine("Queue deleted successfully.");
}
catch (FaultException e)
{
Console.WriteLine("Exception when deleting queue.. {0}", e);
}
}
private void DeleteQueueInternal(Uri address, string path, TokenProvider tokenProvider)
{
var settings = new NamespaceManagerSettings() { TokenProvider = tokenProvider };
var namespaceClient = new ServiceBus.NamespaceManager(address, settings);
try
{
namespaceClient.DeleteQueue(path);
Console.WriteLine("Queue deleted successfully.");
}
catch (FaultException e)
{
Console.WriteLine("Exception when deleting queue.. {0}", e);
}
}
/// <summary>
/// Connects the ServiceBusHelper object to service bus namespace contained in the ServiceBusNamespaces dictionary.
/// </summary>
/// <param name="serviceBusNamespace">The Service Bus namespace.</param>
/// <returns>True if the operation succeeds, false otherwise.</returns>
public bool Connect(ServiceBusNamespace serviceBusNamespace)
{
Func<bool> func = (() =>
{
if (serviceBusNamespace == null ||
string.IsNullOrWhiteSpace(serviceBusNamespace.ConnectionString))
{
throw new ArgumentException(ServiceBusConnectionStringCannotBeNull);
}
connectionString = serviceBusNamespace.ConnectionString;
currentIssuerName = serviceBusNamespace.IssuerName;
currentIssuerSecret = serviceBusNamespace.IssuerSecret;
currentSharedAccessKey = serviceBusNamespace.SharedAccessKey;
currentSharedAccessKeyName = serviceBusNamespace.SharedAccessKeyName;
currentTransportType = serviceBusNamespace.TransportType;
// The NamespaceManager class can be used for managing entities,
// such as queues, topics, subscriptions, and rules, in your service namespace.
// You must provide service namespace address and access credentials in order
// to manage your service namespace.
namespaceManager = ServiceBus.NamespaceManager.CreateFromConnectionString(connectionString);
try
{
notificationHubNamespaceManager = Azure.NotificationHubs.NamespaceManager.CreateFromConnectionString(connectionString);
}
catch (Exception)
{
// ignored
}
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, ServiceBusIsConnected, namespaceManager.Address.AbsoluteUri));
namespaceUri = namespaceManager.Address;
ns = IsCloudNamespace ? namespaceUri.Host.Split('.')[0] : namespaceUri.Segments[namespaceUri.Segments.Length - 1];
atomFeedUri = new Uri(string.Format("{0}://{1}", Uri.UriSchemeHttp, namespaceUri.Host));
// As the name suggests, the MessagingFactory class is a Factory class that allows to create
// instances of the QueueClient, TopicClient and SubscriptionClient classes.
MessagingFactory = MessagingFactory.CreateFromConnectionString(connectionString);
WriteToLogIf(traceEnabled, MessageFactorySuccessfullyCreated);
return true;
});
return RetryHelper.RetryFunc(func, writeToLog);
}
/// <summary>
/// Connects the ServiceBusHelper object to service bus namespace contained in the ServiceBusNamespaces dictionary.
/// </summary>
/// <param name="uri">The full uri of the service namespace.</param>
/// <param name="issuerName">The issuer name of the shared secret credentials.</param>
/// <param name="issuerSecret">The issuer secret of the shared secret credentials.</param>
/// <param name="transportType">The current transport type.</param>
/// <param name="sharedAccessKeyName">The shared access key name.</param>
/// <param name="sharedAccessKey">The shared access key.</param>
/// <returns>True if the operation succeeds, false otherwise.</returns>
public bool Connect(string uri,
string issuerName,
string issuerSecret,
string sharedAccessKeyName,
string sharedAccessKey,
TransportType transportType)
{
Func<bool> func = (() =>
{
if (string.IsNullOrWhiteSpace(uri))
{
throw new ArgumentException(ServiceBusUriArgumentCannotBeNull);
}
if (string.IsNullOrWhiteSpace(issuerName))
{
throw new ArgumentException(ServiceBusIssuerNameArgumentCannotBeNull);
}
if (string.IsNullOrWhiteSpace(issuerSecret))
{
throw new ArgumentException(ServiceBusIssuerSecretArgumentCannotBeNull);
}
// Create the service URI using the uri specified in the Connect form
namespaceUri = new Uri(uri);
if (!string.IsNullOrWhiteSpace(namespaceUri.Host) &&
namespaceUri.Host.Contains('.'))
{
Namespace = namespaceUri.Host.Substring(0, namespaceUri.Host.IndexOf('.'));
}
// Create the atom feed URI using the scheme, namespace and service name (optional)
if (uri.Substring(0, 4) != Uri.UriSchemeHttp)
{
var index = uri.IndexOf("://", StringComparison.Ordinal);
if (index > 0)
{
uri = Uri.UriSchemeHttp + uri.Substring(index);
}
}
atomFeedUri = new Uri(uri);
ServicePath = string.Empty;
// Create shared secret credentials to to authenticate with the Access Control service,
// and acquire an access token that proves to the Service Bus insfrastructure that the
// the Service Bus Explorer is authorized to access the entities in the specified namespace.
tokenProvider = ServiceBus.TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
try
{
notificationHubTokenProvider = Azure.NotificationHubs.TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
}
catch (Exception)
{
// ignored
}
currentIssuerName = issuerName;
currentIssuerSecret = issuerSecret;
currentSharedAccessKeyName = sharedAccessKeyName;
currentSharedAccessKey = sharedAccessKey;
currentTransportType = transportType;
// Create and instance of the NamespaceManagerSettings which
// specifies service namespace client settings and metadata.
var namespaceManagerSettings = new ServiceBus.NamespaceManagerSettings
{
TokenProvider = tokenProvider,
OperationTimeout = TimeSpan.FromMinutes(5)
};
var notificationHubNamespaceManagerSettings = new Azure.NotificationHubs.NamespaceManagerSettings
{
TokenProvider = notificationHubTokenProvider,
OperationTimeout = TimeSpan.FromMinutes(5)
};
// The NamespaceManager class can be used for managing entities,
// such as queues, topics, subscriptions, and rules, in your service namespace.
// You must provide service namespace address and access credentials in order
// to manage your service namespace.
namespaceManager = new ServiceBus.NamespaceManager(namespaceUri, namespaceManagerSettings);
try
{
notificationHubNamespaceManager = new Azure.NotificationHubs.NamespaceManager(namespaceUri, notificationHubNamespaceManagerSettings);
}
catch (Exception)
{
// ignored
}
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, ServiceBusIsConnected, namespaceUri.AbsoluteUri));
// The MessagingFactorySettings specifies the service bus messaging factory settings.
var messagingFactorySettings = new MessagingFactorySettings
{
TokenProvider = tokenProvider,
OperationTimeout = TimeSpan.FromMinutes(5)
};
// In the first release of the service bus, the only available transport protocol is sb
if (scheme == DefaultScheme)
{
messagingFactorySettings.NetMessagingTransportSettings = new NetMessagingTransportSettings();
}
// As the name suggests, the MessagingFactory class is a Factory class that allows to create
// instances of the QueueClient, TopicClient and SubscriptionClient classes.
MessagingFactory = MessagingFactory.Create(namespaceUri, messagingFactorySettings);
WriteToLogIf(traceEnabled, MessageFactorySuccessfullyCreated);
return true;
});
return RetryHelper.RetryFunc(func, writeToLog);
}
/// <summary>
/// Initializes a new instance of the ServiceBusHelper class.
/// </summary>
/// <param name="writeToLog">WriteToLog method.</param>
/// <param name="serviceBusHelper">Base ServiceBusHelper.</param>
public ServiceBusHelper(WriteToLogDelegate writeToLog, ServiceBusHelper serviceBusHelper)
{
this.writeToLog = writeToLog;
AtomFeedUri = serviceBusHelper.AtomFeedUri;
MessageDeferProviderType = serviceBusHelper.MessageDeferProviderType;
connectionString = serviceBusHelper.ConnectionString;
namespaceManager = serviceBusHelper.NamespaceManager;
notificationHubNamespaceManager = serviceBusHelper.NotificationHubNamespaceManager;
MessagingFactory = serviceBusHelper.MessagingFactory;
Namespace = serviceBusHelper.Namespace;
NamespaceUri = serviceBusHelper.NamespaceUri;
MessageDeferProviderType = serviceBusHelper.MessageDeferProviderType;
Scheme = serviceBusHelper.Scheme;
ServiceBusNamespaces = serviceBusHelper.ServiceBusNamespaces;
BrokeredMessageInspectors = serviceBusHelper.BrokeredMessageInspectors;
EventDataInspectors = serviceBusHelper.EventDataInspectors;
BrokeredMessageGenerators = serviceBusHelper.BrokeredMessageGenerators;
EventDataGenerators = serviceBusHelper.EventDataGenerators;
ServicePath = serviceBusHelper.ServicePath;
TokenProvider = serviceBusHelper.TokenProvider;
notificationHubTokenProvider = serviceBusHelper.notificationHubTokenProvider;
TraceEnabled = serviceBusHelper.TraceEnabled;
IssuerName = serviceBusHelper.IssuerName;
IssuerSecret = serviceBusHelper.IssuerSecret;
SharedAccessKey = serviceBusHelper.SharedAccessKey;
SharedAccessKeyName = serviceBusHelper.SharedAccessKeyName;
TransportType = serviceBusHelper.TransportType;
}