public NamespaceContextFactory(IServiceBusHostConfiguration configuration)
{
_serviceUri = new UriBuilder(configuration.HostAddress)
{
Path = ""
}.Uri;
_settings = CreateNamespaceManagerSettings(configuration.Settings, CreateRetryPolicy(configuration.Settings));
}
public NamespaceContextFactory(Uri serviceUri, NamespaceManagerSettings settings)
{
_serviceUri = new UriBuilder(serviceUri)
{
Path = ""
}.Uri;
_settings = settings;
}
NamespaceManager CreateNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = Settings.TokenProvider,
OperationTimeout = Settings.OperationTimeout
};
return(new NamespaceManager(Settings.ServiceUri, nms));
}
static NamespaceManagerSettings CreateNamespaceManagerSettings(ServiceBusHostSettings settings, RetryPolicy retryPolicy)
{
var nms = new NamespaceManagerSettings
{
TokenProvider = settings.TokenProvider,
OperationTimeout = settings.OperationTimeout,
RetryPolicy = retryPolicy
};
return(nms);
}
Task <NamespaceManager> CreateNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = _settings.TokenProvider,
OperationTimeout = _settings.OperationTimeout,
RetryPolicy = new RetryExponential(_settings.RetryMinBackoff, _settings.RetryMaxBackoff, _settings.RetryLimit)
};
return(Task.FromResult(new NamespaceManager(_settings.ServiceUri, nms)));
}
Task <NamespaceManager> CreateNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = _settings.TokenProvider,
OperationTimeout = TimeSpan.FromSeconds(10),
RetryPolicy = RetryPolicy.NoRetry
};
return(Task.FromResult(new NamespaceManager(_settings.ServiceUri, nms)));
}
NamespaceManager CreateNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = Settings.TokenProvider,
OperationTimeout = Settings.OperationTimeout,
RetryPolicy = new RetryExponential(Settings.RetryMinBackoff, Settings.RetryMaxBackoff, Settings.RetryLimit)
};
return(new NamespaceManager(Settings.ServiceUri, nms));
}
public static NamespaceManager CreateFromConnectionString(string connectionString)
{
var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString);
var tokenProvider = CreateTokenProvider(connectionStringBuilder);
var uri = new Uri(connectionStringBuilder.Endpoint);
var settings = new NamespaceManagerSettings {
TokenProvider = tokenProvider
};
return(new NamespaceManager(uri, settings));
}
public NamespaceManager GetNamespaceManager(long timeoutSeconds)
{
if (!string.IsNullOrWhiteSpace(serviceBroker.Service.ServiceConfiguration[ServiceConfigurationSettings.ConnectionString].ToString()))
{
return(NamespaceManager.CreateFromConnectionString(serviceBroker.Service.ServiceConfiguration[ServiceConfigurationSettings.ConnectionString].ToString()));
}
NamespaceManagerSettings nmSettings = new NamespaceManagerSettings();
nmSettings.TokenProvider = GetTokenProvider();
nmSettings.OperationTimeout = GetRequestTimeout(timeoutSeconds);
return(new NamespaceManager(GetServiceUri(), nmSettings));
}
NamespaceManager CreateRootNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = Settings.TokenProvider,
OperationTimeout = Settings.OperationTimeout
};
var builder = new UriBuilder(Settings.ServiceUri)
{
Path = ""
};
return(new NamespaceManager(builder.Uri, nms));
}
public NamespaceManager CreateNamespaceManager()
{
NamespaceManager namespaceManager;
this.Validate();
string item = this.connectionProperties["OperationTimeout"];
IEnumerable <Uri> endpointAddresses = KeyValueConfigurationManager.GetEndpointAddresses(this.connectionProperties["Endpoint"], this.connectionProperties["ManagementPort"]);
IEnumerable <Uri> uris = KeyValueConfigurationManager.GetEndpointAddresses(this.connectionProperties["StsEndpoint"], null);
string str = this.connectionProperties["SharedSecretIssuer"];
string item1 = this.connectionProperties["SharedSecretValue"];
string str1 = this.connectionProperties["SharedAccessKeyName"];
string item2 = this.connectionProperties["SharedAccessKey"];
string str2 = this.connectionProperties["WindowsDomain"];
string item3 = this.connectionProperties["WindowsUsername"];
SecureString windowsPassword = this.GetWindowsPassword();
string str3 = this.connectionProperties["OAuthDomain"];
string item4 = this.connectionProperties["OAuthUsername"];
SecureString oAuthPassword = this.GetOAuthPassword();
try
{
TokenProvider tokenProvider = KeyValueConfigurationManager.CreateTokenProvider(uris, str, item1, str1, item2, str2, item3, windowsPassword, str3, item4, oAuthPassword);
if (!string.IsNullOrEmpty(item))
{
NamespaceManagerSettings namespaceManagerSetting = new NamespaceManagerSettings()
{
OperationTimeout = TimeSpan.Parse(item, CultureInfo.CurrentCulture),
TokenProvider = tokenProvider
};
namespaceManager = new NamespaceManager(endpointAddresses, namespaceManagerSetting);
}
else
{
namespaceManager = new NamespaceManager(endpointAddresses, tokenProvider);
}
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
throw new ConfigurationErrorsException(SRClient.AppSettingsCreateManagerWithInvalidConnectionString(argumentException.Message), argumentException);
}
catch (UriFormatException uriFormatException1)
{
UriFormatException uriFormatException = uriFormatException1;
throw new ConfigurationErrorsException(SRClient.AppSettingsCreateManagerWithInvalidConnectionString(uriFormatException.Message), uriFormatException);
}
return(namespaceManager);
}
Task CreateHostQueue(ITokenProvider tokenProvider)
{
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
Configuration.ServiceNamespace,
Environment.MachineName
);
var settings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider
};
var namespaceManager = new NamespaceManager(serviceUri, settings);
return(CreateQueue(namespaceManager, serviceUri, "Control"));
}
private QueueClient PrepareWatchingQueue()
{
var namespaceManagerSetting = new NamespaceManagerSettings()
{
TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(ServiceBusIssuerName, ServiceBusIssuerSecret),
};
var namespaceManager = new NamespaceManager(ServiceBusAddress, namespaceManagerSetting);
if (!namespaceManager.QueueExists(_watchingQueueName))
{
namespaceManager.CreateQueue(_watchingQueueName);
}
var factory = MessagingFactory.Create(ServiceBusAddress, SharedSecretTokenProvider.CreateSharedSecretTokenProvider(ServiceBusIssuerName, ServiceBusIssuerSecret));
var queueClient = factory.CreateQueueClient(_watchingQueueName);
return queueClient;
}
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);
}
}
public INamespaceManager Create(string @namespace)
{
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
var connectionString = @namespace;
if (!ConnectionString.IsConnectionString(connectionString))
{
connectionString = namespacesDefinition.GetConnectionString(connectionString);
}
NamespaceManager manager;
if (settingsFactory != null)
{
var s = settingsFactory(connectionString);
var builder = new ServiceBusConnectionStringBuilder(connectionString);
manager = new NamespaceManager(builder.GetAbsoluteRuntimeEndpoints(), s);
}
else
{
if (tokenProviderFactory != null)
{
var s = new NamespaceManagerSettings()
{
TokenProvider = tokenProviderFactory(connectionString)
};
var builder = new ServiceBusConnectionStringBuilder(connectionString);
manager = new NamespaceManager(builder.GetAbsoluteRuntimeEndpoints(), s);
}
else
{
manager = NamespaceManager.CreateFromConnectionString(connectionString);
}
if (settings.HasExplicitValue(WellKnownConfigurationKeys.Connectivity.NamespaceManagers.RetryPolicy))
{
manager.Settings.RetryPolicy = settings.Get <RetryPolicy>(WellKnownConfigurationKeys.Connectivity.NamespaceManagers.RetryPolicy);
}
}
return(new NamespaceManagerAdapter(manager));
}
public MessageGateway(ILog logger)
{
this.logger = logger;
this.configuration = AzureServiceBusMessagingGatewayConfigurationSection.GetConfiguration();
var endpoint = ServiceBusEnvironment.CreateServiceUri("sb", this.configuration.Namespace.Name, String.Empty);
var tokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider(this.configuration.SharedAccessPolicy.Name,
this.configuration.SharedAccessPolicy.Key);
var factorySettings = new MessagingFactorySettings
{
TransportType = TransportType.Amqp,
OperationTimeout = TimeSpan.FromMinutes(5),
TokenProvider = tokenProvider
};
this.factory = MessagingFactory.Create(endpoint, factorySettings);
var namespaceSettings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider
};
namespaceManager = new NamespaceManager(endpoint, namespaceSettings);
}
public INamespaceManagerInternal Create(string @namespace)
{
var connectionString = @namespace;
if (!ConnectionStringInternal.IsConnectionString(connectionString))
{
connectionString = namespacesDefinition.GetConnectionString(connectionString);
}
NamespaceManager manager;
if (settingsFactory != null)
{
var s = settingsFactory(connectionString);
var builder = new ServiceBusConnectionStringBuilder(connectionString);
manager = new NamespaceManager(builder.GetAbsoluteRuntimeEndpoints(), s);
}
else
{
if (tokenProviderFactory != null)
{
var s = new NamespaceManagerSettings
{
TokenProvider = tokenProviderFactory(connectionString)
};
var builder = new ServiceBusConnectionStringBuilder(connectionString);
manager = new NamespaceManager(builder.GetAbsoluteRuntimeEndpoints(), s);
}
else
{
manager = NamespaceManager.CreateFromConnectionString(connectionString);
}
if (retryPolicy != null)
{
manager.Settings.RetryPolicy = retryPolicy;
}
}
return(new NamespaceManagerAdapterInternal(manager, connectionString));
}
public MessageGateway(ILog logger)
{
this.logger = logger;
this.configuration = AzureServiceBusMessagingGatewayConfigurationSection.GetConfiguration();
var endpoint = ServiceBusEnvironment.CreateServiceUri("sb", this.configuration.Namespace.Name, String.Empty);
var tokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider(this.configuration.SharedAccessPolicy.Name,
this.configuration.SharedAccessPolicy.Key);
var factorySettings = new MessagingFactorySettings
{
TransportType = TransportType.Amqp,
OperationTimeout = TimeSpan.FromMinutes(5),
TokenProvider = tokenProvider
};
this.factory = MessagingFactory.Create(endpoint, factorySettings);
var namespaceSettings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider
};
namespaceManager = new NamespaceManager(endpoint, namespaceSettings);
}
/// <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 = TokenProvider.CreateSharedSecretTokenProvider(issuerName,
issuerSecret);
currentIssuerName = issuerName;
currentIssuerSecret = issuerSecret;
currentSharedAccessKeyName = sharedAccessKeyName;
currentSharedAccessKey = sharedAccessKey;
TransportType = transportType;
// Create and instance of the NamespaceManagerSettings which
// specifies service namespace client settings and metadata.
var namespaceManagerSettings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider,
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 NamespaceManager(namespaceUri, namespaceManagerSettings);
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);
}
public NamespaceCache(Uri serviceUri, NamespaceManagerSettings settings)
: base(new NamespaceContextFactory(serviceUri, settings))
{
_description = $"NamespaceCache (serviceUri: {serviceUri})";
}
Task<NamespaceManager> CreateRootNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = _settings.TokenProvider,
OperationTimeout = _settings.OperationTimeout,
RetryPolicy = new RetryExponential(_settings.RetryMinBackoff, _settings.RetryMaxBackoff, _settings.RetryLimit)
};
var builder = new UriBuilder(_settings.ServiceUri)
{
Path = ""
};
return Task.FromResult(new NamespaceManager(builder.Uri, nms));
}
Task<NamespaceManager> CreateNamespaceManager()
{
var nms = new NamespaceManagerSettings
{
TokenProvider = _settings.TokenProvider,
OperationTimeout = TimeSpan.FromSeconds(10),
RetryPolicy = RetryPolicy.NoRetry
};
return Task.FromResult(new NamespaceManager(_settings.ServiceUri, nms));
}
public NamespaceManager(Uri address, NamespaceManagerSettings settings)
{
_managementClient = new ManagementClient(address.ToString(), settings.TokenProvider);
Address = address;
Settings = settings;
}
/// <summary>
/// Connects the ServiceBusHelper object to service bus namespace contained in the ServiceBusNamespaces dictionary.
/// </summary>
/// <param name="nameSpace">The namespace of the Service Bus.</param>
/// <param name="path">The service path that follows the host name section of the URI.</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>
/// <returns>True if the operation succeeds, false otherwise.</returns>
public bool Connect(string nameSpace, string path, string issuerName, string issuerSecret)
{
Func<bool> func = (() =>
{
if (string.IsNullOrEmpty(nameSpace))
{
throw new ArgumentException(ServiceBusNamespaceArgumentCannotBeNull);
}
if (string.IsNullOrEmpty(issuerName))
{
throw new ArgumentException(ServiceBusIssuerNameArgumentCannotBeNull);
}
if (string.IsNullOrEmpty(issuerSecret))
{
throw new ArgumentException(ServiceBusIssuerSecretArgumentCannotBeNull);
}
// Create the service URI using the scheme, namespace and service path (optional)
namespaceUri = ServiceBusEnvironment.CreateServiceUri(scheme,
nameSpace,
path);
// Create the atom feed URI using the scheme, namespace and service path (optional)
atomFeedUri = ServiceBusEnvironment.CreateServiceUri("http",
nameSpace,
path);
Namespace = nameSpace;
ServicePath = path;
// 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 = TokenProvider.CreateSharedSecretTokenProvider(issuerName,
// issuerSecret);
currentIssuerName = issuerName;
currentIssuerSecret = issuerSecret;
// Create and instance of the NamespaceManagerSettings which
// specifies service namespace client settings and metadata.
var namespaceManagerSettings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider,
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 NamespaceManager(namespaceUri, namespaceManagerSettings);
namespaceManager = NamespaceManager.Create();
//////////////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);
MessagingFactory = MessagingFactory.Create();
WriteToLogIf(traceEnabled, MessageFactorySuccessfullyCreated);
return true;
});
return RetryHelper.RetryFunc(func, writeToLog);
}
public async Task Should_be_configured_and_working()
{
var settings = new TestAzureServiceBusAccountSettings();
var provider = new SharedAccessKeyTokenProvider(settings);
var tokenProvider = provider.GetTokenProvider();
var namespaceSettings = new NamespaceManagerSettings
{
TokenProvider = tokenProvider
};
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
Configuration.ServiceNamespace,
"MassTransit.Azure.ServiceBus.Core.Tests"
);
var namespaceManager = new NamespaceManager(serviceUri, namespaceSettings);
await CreateQueue(namespaceManager, serviceUri, "TestClient");
await CreateHostQueue(tokenProvider);
var mfs = new MessagingFactorySettings
{
TokenProvider = tokenProvider,
OperationTimeout = TimeSpan.FromSeconds(30),
TransportType = TransportType.Amqp
};
var factory = await MessagingFactory.CreateAsync(serviceUri, mfs);
var receiver = factory.CreateQueueClient("Control");
receiver.PrefetchCount = 100;
var done = new TaskCompletionSource <bool>();
var count = 0;
const int limit = 1000;
receiver.RegisterMessageHandler(async(message, cancellationToken) =>
{
await receiver.CompleteAsync(message.SystemProperties.LockToken);
var received = Interlocked.Increment(ref count);
if (received == limit)
{
done.TrySetResult(true);
}
}, new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false,
MaxConcurrentCalls = 100,
MaxAutoRenewDuration = TimeSpan.FromSeconds(60)
});
var client = factory.CreateMessageSender("Control");
var stopwatch = Stopwatch.StartNew();
var tasks = new Task[limit];
for (var i = 0; i < limit; i++)
{
tasks[i] = SendAMessage(client);
}
await done.Task;
stopwatch.Stop();
await Task.WhenAll(tasks);
await receiver.CloseAsync();
Console.WriteLine("Performance: {0:F2}/s", limit * 1000 / stopwatch.ElapsedMilliseconds);
}
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);
}
}
