public async Task <string> CreateTopic(Topology.Entities.Topic topic)
{
lock (_lock)
{
if (_topicArns.TryGetValue(topic.EntityName, out var result))
{
return(result);
}
}
var request = new CreateTopicRequest(topic.EntityName)
{
Attributes = topic.TopicAttributes.ToDictionary(x => x.Key, x => x.Value.ToString()),
Tags = topic.TopicTags.Select(x => new Tag
{
Key = x.Key,
Value = x.Value
}).ToList()
};
TransportLogMessages.CreateTopic(topic.EntityName);
var response = await _amazonSns.CreateTopicAsync(request, _cancellationToken).ConfigureAwait(false);
EnsureSuccessfulResponse(response);
var topicArn = response.TopicArn;
lock (_lock)
_topicArns[topic.EntityName] = topicArn;
await Task.Delay(500, _cancellationToken).ConfigureAwait(false);
return(topicArn);
}
public Task <ISendTransport> CreateSendTransport(IClientContextSupervisor clientContextSupervisor, Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new AmazonSqsEndpointAddress(_hostConfiguration.HostAddress, address);
TransportLogMessages.CreateSendTransport(endpointAddress);
if (endpointAddress.Type == AmazonSqsEndpointAddress.AddressType.Queue)
{
var settings = _topologyConfiguration.Send.GetSendSettings(endpointAddress);
IPipe <ClientContext> configureTopology = new ConfigureTopologyFilter <EntitySettings>(settings, settings.GetBrokerTopology()).ToPipe();
return(CreateTransport(clientContextSupervisor, configureTopology, settings.EntityName, x => new QueueSendTransport(x)));
}
else
{
var settings = new TopicPublishSettings(endpointAddress);
var builder = new PublishEndpointBrokerTopologyBuilder();
var topicHandle = builder.CreateTopic(settings.EntityName, settings.Durable, settings.AutoDelete, settings.TopicAttributes, settings
.TopicSubscriptionAttributes, settings.Tags);
builder.Topic ??= topicHandle;
IPipe <ClientContext> configureTopology = new ConfigureTopologyFilter <EntitySettings>(settings, builder.BuildBrokerTopology()).ToPipe();
return(CreateTransport(clientContextSupervisor, configureTopology, settings.EntityName, x => new TopicSendTransport(x)));
}
}
public async Task <TopicDescription> CreateTopic(TopicDescription topicDescription)
{
var topicExists = await TopicExistsAsync(topicDescription.Path).ConfigureAwait(false);
if (topicExists)
{
topicDescription = await GetTopicAsync(topicDescription.Path).ConfigureAwait(false);
}
else
{
try
{
TransportLogMessages.CreateTopic(topicDescription.Path);
topicDescription = await CreateTopicAsync(topicDescription).ConfigureAwait(false);
}
catch (MessagingEntityAlreadyExistsException)
{
await GetTopicAsync(topicDescription.Path).ConfigureAwait(false);
}
}
LogContext.Debug?.Log("Topic: {Topic} ({Attributes})", topicDescription.Path,
string.Join(", ",
new[]
{
topicDescription.RequiresDuplicateDetection ? "dupe detect" : "",
topicDescription.EnablePartitioning ? "partitioned" : "",
topicDescription.SupportOrdering ? "ordered" : ""
}.Where(x => !string.IsNullOrWhiteSpace(x))));
return(topicDescription);
}
async Task <ConnectionContext> CreateConnection(ISupervisor supervisor)
{
return(await _connectionRetryPolicy.Retry(async() =>
{
if (supervisor.Stopping.IsCancellationRequested)
{
throw new OperationCanceledException($"The connection is stopping and cannot be used: {_configuration.HostAddress}");
}
IConnection connection = null;
try
{
TransportLogMessages.ConnectHost(_configuration.Settings.ToString());
connection = _configuration.Settings.CreateConnection();
return new AmazonSqsConnectionContext(connection, _configuration, _hostTopology, supervisor.Stopped);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
throw new AmazonSqsConnectException("Connect failed: " + _configuration.Settings, ex);
}
}, supervisor.Stopping).ConfigureAwait(false));
}
public async Task <QueueDescription> CreateQueue(QueueDescription queueDescription)
{
var create = true;
try
{
queueDescription = await _namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
create = false;
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
var created = false;
try
{
TransportLogMessages.CreateQueue(queueDescription.Path);
queueDescription = await _namespaceManager.CreateQueueAsync(queueDescription).ConfigureAwait(false);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
{
throw;
}
}
if (!created)
{
queueDescription = await _namespaceManager.GetQueueAsync(queueDescription.Path).ConfigureAwait(false);
}
}
LogContext.Debug?.Log("Queue: {Queue} ({Attributes})", queueDescription.Path,
string.Join(", ",
new[]
{
queueDescription.EnableExpress ? "express" : "",
queueDescription.RequiresDuplicateDetection ? "dupe detect" : "",
queueDescription.EnableDeadLetteringOnMessageExpiration ? "dead letter" : "",
queueDescription.RequiresSession ? "session" : ""
}.Where(x => !string.IsNullOrWhiteSpace(x))));
return(queueDescription);
}
async Task ClientContext.DeleteQueue(Queue queue)
{
var queueUrl = await CreateQueue(queue).ConfigureAwait(false);
TransportLogMessages.DeleteQueue(queueUrl);
var response = await _amazonSqs.DeleteQueueAsync(queueUrl, _cancellationToken).ConfigureAwait(false);
EnsureSuccessfulResponse(response);
}
async Task ClientContext.DeleteTopic(Topology.Entities.Topic topic)
{
var topicArn = await CreateTopic(topic).ConfigureAwait(false);
TransportLogMessages.DeleteTopic(topicArn);
var response = await _amazonSns.DeleteTopicAsync(topicArn, _cancellationToken).ConfigureAwait(false);
EnsureSuccessfulResponse(response);
}
ISendTransport CreateSendTransport(Uri address, SendSettings settings)
{
TransportLogMessages.CreateSendTransport(address);
var endpointContextSupervisor = CreateSendEndpointContextSupervisor(settings);
var transportContext = new SendTransportContext(_hostConfiguration, address, endpointContextSupervisor);
return(new ServiceBusSendTransport(transportContext));
}
public async Task DisposeAsync(CancellationToken cancellationToken = new CancellationToken())
{
var address = _messagingFactory.Address.ToString();
TransportLogMessages.DisconnectHost(address);
await _messagingFactory.CloseAsync().ConfigureAwait(false);
TransportLogMessages.DisconnectedHost(address);
}
async Task <ConnectionContext> CreateConnection(IAsyncPipeContextAgent <ConnectionContext> asyncContext, IAgent supervisor)
{
return(await _connectionRetryPolicy.Retry(async() =>
{
if (supervisor.Stopping.IsCancellationRequested)
{
throw new OperationCanceledException($"The connection is stopping and cannot be used: {_configuration.Description}");
}
IConnection connection = null;
try
{
TransportLogMessages.ConnectHost(_configuration.Description);
connection = _configuration.Settings.CreateConnection();
void HandleConnectionException(Exception exception)
{
asyncContext.Stop($"Connection Exception: {exception}");
}
connection.ExceptionListener += HandleConnectionException;
#pragma warning disable 4014
asyncContext.Completed.ContinueWith(_ => connection.ExceptionListener -= HandleConnectionException);
#pragma warning restore 4014
connection.Start();
LogContext.Debug?.Log("Connected: {Host} (client-id: {ClientId}, version: {Version})", _configuration.Description, connection.ClientId,
connection.MetaData.NMSVersion);
var connectionContext = new ActiveMqConnectionContext(connection, _configuration, _hostTopology, supervisor.Stopped);
await asyncContext.Created(connectionContext).ConfigureAwait(false);
return connectionContext;
}
catch (OperationCanceledException)
{
await asyncContext.CreateCanceled().ConfigureAwait(false);
throw;
}
catch (NMSConnectionException ex)
{
LogContext.Error?.Log(ex, "ActiveMQ connection failed");
await asyncContext.CreateFaulted(ex).ConfigureAwait(false);
connection?.Dispose();
throw new ActiveMqConnectException("Connect failed: " + _configuration.Description, ex);
}
}));
}
ISendTransport CreateSendTransport(Uri address, SendSettings settings)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
TransportLogMessages.CreateSendTransport(address);
var endpointContextSupervisor = CreateSendEndpointContextSupervisor(settings);
var transportContext = new SendTransportContext(address, endpointContextSupervisor, _hostConfiguration.SendLogContext);
return(new ServiceBusSendTransport(transportContext));
}
async Task ClientContext.DeleteQueue(Queue queue)
{
var queueInfo = await _queueCache.Get(queue, _cancellationToken).ConfigureAwait(false);
TransportLogMessages.DeleteQueue(queueInfo.Url);
var response = await _amazonSqs.DeleteQueueAsync(queueInfo.Url, _cancellationToken).ConfigureAwait(false);
response.EnsureSuccessfulResponse();
_queueCache.RemoveByName(queue.EntityName);
}
Task IAsyncDisposable.DisposeAsync(CancellationToken cancellationToken)
{
_connection.ConnectionShutdown -= OnConnectionShutdown;
TransportLogMessages.DisconnectHost(Description);
_connection.Cleanup(200, "Connection Disposed");
TransportLogMessages.DisconnectedHost(Description);
return(TaskUtil.Completed);
}
public Task <ISendTransport> CreateSendTransport(ActiveMqEndpointAddress address)
{
TransportLogMessages.CreateSendTransport(address);
var settings = _hostTopology.SendTopology.GetSendSettings(address);
var sessionContextSupervisor = CreateSessionContextSupervisor();
var configureTopology = new ConfigureTopologyFilter <SendSettings>(settings, settings.GetBrokerTopology()).ToPipe();
return(CreateSendTransport(sessionContextSupervisor, configureTopology, settings.EntityName, DestinationType.Queue));
}
async Task ClientContext.DeleteTopic(Topology.Entities.Topic topic)
{
var topicInfo = await _topicCache.Get(topic, _cancellationToken).ConfigureAwait(false);
TransportLogMessages.DeleteTopic(topicInfo.Arn);
var response = await _amazonSns.DeleteTopicAsync(topicInfo.Arn, _cancellationToken).ConfigureAwait(false);
response.EnsureSuccessfulResponse();
_topicCache.RemoveByName(topic.EntityName);
}
async ValueTask IAsyncDisposable.DisposeAsync()
{
_connection.ConnectionShutdown -= OnConnectionShutdown;
TransportLogMessages.DisconnectHost(Description);
_connection.Cleanup(200, "Connection Disposed");
TransportLogMessages.DisconnectedHost(Description);
await _executor.DisposeAsync().ConfigureAwait(false);
}
public async ValueTask DisposeAsync()
{
var address = _connection.Endpoint.ToString();
TransportLogMessages.DisconnectHost(address);
await _managementClient.CloseAsync().ConfigureAwait(false);
await _connection.CloseAsync().ConfigureAwait(false);
TransportLogMessages.DisconnectedHost(address);
}
public async Task <TopicDescription> CreateTopic(TopicDescription topicDescription)
{
var create = true;
try
{
topicDescription = await _namespaceManager.GetTopicAsync(topicDescription.Path).ConfigureAwait(false);
create = false;
}
catch (MessagingEntityNotFoundException)
{
}
if (create)
{
var created = false;
try
{
TransportLogMessages.CreateTopic(topicDescription.Path);
topicDescription = await _namespaceManager.CreateTopicAsync(topicDescription).ConfigureAwait(false);
created = true;
}
catch (MessagingEntityAlreadyExistsException)
{
}
catch (MessagingException mex)
{
if (mex.Message.Contains("(409)"))
{
}
else
{
throw;
}
}
if (!created)
{
topicDescription = await _namespaceManager.GetTopicAsync(topicDescription.Path).ConfigureAwait(false);
}
}
LogContext.Debug?.Log("Topic: {Topic} ({Attributes})", topicDescription.Path,
string.Join(", ",
new[] { topicDescription.EnableExpress ? "express" : "", topicDescription.RequiresDuplicateDetection ? "dupe detect" : "" }.Where(x =>
!string.IsNullOrWhiteSpace(x))));
return(topicDescription);
}
public Task <ISendTransport> GetSendTransport(Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new GrpcEndpointAddress(HostAddress, address);
TransportLogMessages.CreateSendTransport(address);
var exchange = _messageFabric.GetExchange(HostNodeContext, endpointAddress.Name, endpointAddress.ExchangeType);
var transportContext = new ExchangeGrpcSendTransportContext(_hostConfiguration, exchange);
return(Task.FromResult <ISendTransport>(new GrpcSendTransport(transportContext)));
}
public HostReceiveEndpointHandle ConnectReceiveEndpoint(string queueName, Action <IAmazonSqsReceiveEndpointConfigurator> configure = null)
{
LogContext.SetCurrentIfNull(DefaultLogContext);
var configuration = _hostConfiguration.CreateReceiveEndpointConfiguration(queueName, configure);
BusConfigurationResult.CompileResults(configuration.Validate());
TransportLogMessages.ConnectReceiveEndpoint(configuration.InputAddress);
configuration.Build(this);
return(ReceiveEndpoints.Start(queueName));
}
public async Task <ISendTransport> GetSendTransport(Uri address)
{
LogContext.SetCurrentIfNull(DefaultLogContext);
var exchangeName = address.GetQueueOrExchangeName();
TransportLogMessages.CreateSendTransport(address);
var exchange = _messageFabric.GetExchange(exchangeName);
var context = new ExchangeInMemorySendTransportContext(exchange, SendLogContext);
return(new InMemorySendTransport(context));
}
public async Task <ISendTransport> GetSendTransport(Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new InMemoryEndpointAddress(_hostConfiguration.HostAddress, address);
TransportLogMessages.CreateSendTransport(address);
var exchange = _messageFabric.Value.GetExchange(endpointAddress.Name);
var context = new ExchangeInMemorySendTransportContext(exchange, _hostConfiguration.SendLogContext);
return(new InMemorySendTransport(context));
}
HostReceiveEndpointHandle ConnectSubscriptionEndpoint(SubscriptionEndpointSettings settings,
Action <IServiceBusSubscriptionEndpointConfigurator> configure)
{
LogContext.SetCurrentIfNull(DefaultLogContext);
var configuration = _hostConfiguration.CreateSubscriptionEndpointConfiguration(settings, configure);
TransportLogMessages.ConnectSubscriptionEndpoint(configuration.InputAddress, settings.Name);
BusConfigurationResult.CompileResults(configuration.Validate());
configuration.Build(this);
return(ReceiveEndpoints.Start(configuration.Settings.Path));
}
public Task <ISendTransport> CreateSendTransport(ISessionContextSupervisor sessionContextSupervisor, Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new ActiveMqEndpointAddress(_hostConfiguration.HostAddress, address);
TransportLogMessages.CreateSendTransport(endpointAddress);
var settings = _topologyConfiguration.Send.GetSendSettings(endpointAddress);
IPipe <SessionContext> configureTopology = new ConfigureTopologyFilter <SendSettings>(settings, settings.GetBrokerTopology()).ToPipe();
return(CreateSendTransport(sessionContextSupervisor, configureTopology, settings.EntityName,
endpointAddress.Type == ActiveMqEndpointAddress.AddressType.Queue ? DestinationType.Queue : DestinationType.Topic));
}
public async Task <ISendTransport> CreateSendTransport(ServiceBusEndpointAddress address)
{
Task <CachedSendTransport> Create(Uri transportAddress)
{
TransportLogMessages.CreateSendTransport(address);
var settings = _hostTopology.SendTopology.GetSendSettings(address);
var transport = CreateSendTransport(address, settings);
return(Task.FromResult(new CachedSendTransport(transportAddress, transport)));
}
return(await _index.Get(address, Create).ConfigureAwait(false));
}
public Task <ISendTransport> CreateSendTransport(IModelContextSupervisor modelContextSupervisor, Uri address)
{
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
var endpointAddress = new RabbitMqEndpointAddress(_hostConfiguration.HostAddress, address);
TransportLogMessages.CreateSendTransport(endpointAddress);
var settings = _topologyConfiguration.Send.GetSendSettings(endpointAddress);
var brokerTopology = settings.GetBrokerTopology();
IPipe <ModelContext> configureTopology = new ConfigureTopologyFilter <SendSettings>(settings, brokerTopology).ToPipe();
return(CreateSendTransport(modelContextSupervisor, configureTopology, settings.ExchangeName, endpointAddress));
}
public Task <ISendTransport> CreateSendTransport(RabbitMqEndpointAddress address, IModelContextSupervisor modelContextSupervisor)
{
TransportLogMessages.CreateSendTransport(address);
var settings = _hostTopology.SendTopology.GetSendSettings(address);
var brokerTopology = settings.GetBrokerTopology();
IPipe <ModelContext> pipe = new ConfigureTopologyFilter <SendSettings>(settings, brokerTopology).ToPipe();
var supervisor = new ModelContextSupervisor(modelContextSupervisor);
var transport = CreateSendTransport(supervisor, pipe, settings.ExchangeName);
return(Task.FromResult(transport));
}
Task <ISendTransport> ISendTransportProvider.GetSendTransport(Uri address)
{
var endpointAddress = new AmazonSqsEndpointAddress(_hostConfiguration.HostAddress, address);
LogContext.SetCurrentIfNull(_hostConfiguration.LogContext);
TransportLogMessages.CreateSendTransport(endpointAddress);
if (endpointAddress.Type == AmazonSqsEndpointAddress.AddressType.Queue)
{
var settings = _topologyConfiguration.Send.GetSendSettings(endpointAddress);
var clientContextSupervisor = new ClientContextSupervisor(this);
IPipe <ClientContext> configureTopologyPipe = new ConfigureTopologyFilter <SendSettings>(settings, settings.GetBrokerTopology()).ToPipe();
var transportContext = new SendTransportContext(clientContextSupervisor, configureTopologyPipe, settings.EntityName,
_hostConfiguration.SendLogContext, _hostConfiguration.Settings.AllowTransportHeader);
var transport = new QueueSendTransport(transportContext);
Add(transport);
return(Task.FromResult <ISendTransport>(transport));
}
else
{
var settings = new TopicPublishSettings(endpointAddress);
var clientContextSupervisor = new ClientContextSupervisor(this);
var builder = new PublishEndpointBrokerTopologyBuilder();
var topicHandle = builder.CreateTopic(settings.EntityName, settings.Durable, settings.AutoDelete, settings.TopicAttributes, settings
.TopicSubscriptionAttributes, settings.Tags);
builder.Topic ??= topicHandle;
IPipe <ClientContext> configureTopologyPipe = new ConfigureTopologyFilter <PublishSettings>(settings, builder.BuildBrokerTopology()).ToPipe();
var transportContext = new SendTransportContext(clientContextSupervisor, configureTopologyPipe, settings.EntityName,
_hostConfiguration.SendLogContext, _hostConfiguration.Settings.AllowTransportHeader);
var transport = new TopicSendTransport(transportContext);
Add(transport);
return(Task.FromResult <ISendTransport>(transport));
}
}
public async Task <ISendTransport> GetSendTransport(Uri address)
{
LogContext.SetCurrentIfNull(DefaultLogContext);
var exchangeName = address.GetQueueOrExchangeName();
return(await _index.Get(exchangeName, async key =>
{
TransportLogMessages.CreateSendTransport(address);
var exchange = _messageFabric.GetExchange(exchangeName);
var context = new ExchangeInMemorySendTransportContext(exchange, SendLogContext);
return new InMemorySendTransport(context);
}).ConfigureAwait(false));
}
public Task <ISendTransport> CreateSendTransport(AmazonSqsEndpointAddress address)
{
TransportLogMessages.CreateSendTransport(address);
var settings = _hostTopology.SendTopology.GetSendSettings(address);
var clientContextSupervisor = new AmazonSqsClientContextSupervisor(ConnectionContextSupervisor);
var configureTopologyPipe = new ConfigureTopologyFilter <SendSettings>(settings, settings.GetBrokerTopology()).ToPipe();
var transportContext = new HostSqsSendTransportContext(clientContextSupervisor, configureTopologyPipe, settings.EntityName, SendLogContext,
_hostConfiguration.Settings.AllowTransportHeader);
var transport = new QueueSendTransport(transportContext);
Add(transport);
return(Task.FromResult <ISendTransport>(transport));
}
