public IInboundTransport BuildInbound(ITransportSettings settings)
{
try
{
var msmqEndpointAddress = new MsmqEndpointAddress(settings.Address.Uri);
var msmqSettings = new TransportSettings(msmqEndpointAddress, settings)
{
Transactional = msmqEndpointAddress.IsTransactional
};
if (msmqSettings.MsmqAddress().IsLocal)
{
ValidateLocalTransport(msmqSettings);
PurgeExistingMessagesIfRequested(msmqSettings);
}
if (msmqSettings.Transactional)
return new TransactionalInboundMsmqTransport(msmqSettings.MsmqAddress(),
msmqSettings.TransactionTimeout, msmqSettings.IsolationLevel);
return new NonTransactionalInboundMsmqTransport(msmqSettings.MsmqAddress());
}
catch (Exception ex)
{
throw new TransportException(settings.Address.Uri, "Failed to create MSMQ inbound transport", ex);
}
}
public IOutboundTransport BuildOutbound(ITransportSettings settings)
{
try
{
var msmqEndpointAddress = new MsmqEndpointAddress(settings.Address.Uri);
var msmqSettings = new TransportSettings(msmqEndpointAddress, settings)
{
Transactional = msmqEndpointAddress.IsTransactional
};
if (msmqSettings.MsmqAddress().IsLocal)
{
ValidateLocalTransport(msmqSettings);
}
if (msmqSettings.Transactional)
return new TransactionalOutboundMsmqTransport(msmqSettings.MsmqAddress());
return new NonTransactionalOutboundMsmqTransport(msmqSettings.MsmqAddress());
}
catch (Exception ex)
{
throw new TransportException(settings.Address.Uri, "Failed to create MSMQ outbound transport", ex);
}
}
public IInboundTransport BuildInbound(ITransportSettings settings)
{
try
{
var msmqEndpointAddress = new MsmqEndpointAddress(settings.Address.Uri);
var msmqSettings = new TransportSettings(msmqEndpointAddress, settings)
{
Transactional = settings.Transactional || msmqEndpointAddress.IsTransactional
};
IMsmqEndpointAddress transportAddress = msmqSettings.MsmqAddress();
if (transportAddress.IsLocal)
{
ValidateLocalTransport(msmqSettings);
PurgeExistingMessagesIfRequested(msmqSettings);
}
var connection = new MessageQueueConnection(transportAddress, QueueAccessMode.Receive);
var connectionHandler = new ConnectionHandlerImpl<MessageQueueConnection>(connection);
if (msmqSettings.Transactional)
return new TransactionalInboundMsmqTransport(transportAddress, connectionHandler,
msmqSettings.TransactionTimeout, msmqSettings.IsolationLevel);
return new NonTransactionalInboundMsmqTransport(transportAddress, connectionHandler);
}
catch (Exception ex)
{
throw new TransportException(settings.Address.Uri, "Failed to create MSMQ inbound transport", ex);
}
}
public void Should_throw_an_endpoint_exception_from_the_msmq_endpoint_factory()
{
var transportFactory = new MsmqTransportFactory();
var settings = new TransportSettings(new EndpointAddress(_uri));
settings.CreateIfMissing = false;
transportFactory.BuildInbound(settings);
}
static TransportSettings GetTransportSettings(ITransportSettings settings, MsmqEndpointAddress msmqEndpointAddress)
{
var msmqSettings = new TransportSettings(msmqEndpointAddress, settings)
{
Transactional = msmqEndpointAddress.IsTransactional,
};
return msmqSettings;
}
public SubscriptionActivator(ISubscriptionRepository repository, IEnvelopeSender sender, ISubscriptionCache cache, IEnumerable<ISubscriptionRequirement> requirements, ChannelGraph graph,
TransportSettings settings)
{
_repository = repository;
_sender = sender;
_cache = cache;
_requirements = requirements;
_graph = graph;
_settings = settings;
}
public static ObjectDef DetermineSagaRepositoryDef(TransportSettings settings, SagaTypes sagaTypes)
{
var def = settings.SagaStorageProviders.FirstValue(x => x.RepositoryFor(sagaTypes))
?? new InMemorySagaStorage().RepositoryFor(sagaTypes);
if (def == null)
{
throw new SagaRepositoryUnresolvableException(sagaTypes);
}
return def;
}
public IDuplexTransport BuildLoopback(ITransportSettings settings)
{
try
{
ITransportSettings msmqSettings = new TransportSettings(new MsmqEndpointAddress(settings.Address.Uri), settings);
IInboundTransport inboundTransport = BuildInbound(settings);
IOutboundTransport outboundTransport = BuildOutbound(settings);
return new Transport(msmqSettings.Address, () => inboundTransport, () => outboundTransport);
}
catch (Exception ex)
{
throw new TransportException(settings.Address.Uri, "Failed to create MSMQ transport", ex);
}
}
public IInboundTransport BuildInbound(ITransportSettings settings)
{
try
{
ITransportSettings msmqSettings = new TransportSettings(new MsmqEndpointAddress(settings.Address.Uri), settings);
if (msmqSettings.MsmqAddress().IsLocal)
{
ValidateLocalTransport(msmqSettings);
PurgeExistingMessagesIfRequested(msmqSettings);
}
return new NonTransactionalInboundMsmqTransport(msmqSettings.MsmqAddress());
}
catch (Exception ex)
{
throw new TransportException(settings.Address.Uri, "Failed to create MSMQ inbound transport", ex);
}
}
internal static TransportBase AcceptServerTransport(TransportSettings settings)
{
ManualResetEvent complete = new ManualResetEvent(false);
int closed = 0;
TransportBase transport = null;
Action<TransportListener, TransportAsyncCallbackArgs> onTransport = (l, a) =>
{
if (a.Exception != null)
{
Debug.WriteLine(a.Exception.Message);
}
else
{
Debug.WriteLine("Listener accepted a transport.");
transport = a.Transport;
}
if (Interlocked.Exchange(ref closed, 1) == 0)
{
complete.Set();
}
};
TransportListener listener = settings.CreateListener();
Debug.WriteLine("Listeners are waiting for connections...");
listener.Listen(onTransport);
complete.WaitOne();
complete.Dispose();
transport.Closed += (s, a) =>
{
listener.Close();
Debug.WriteLine("Listeners Closed.");
};
return transport;
}
public IOutboundTransport BuildOutbound(ITransportSettings settings)
{
try
{
ITransportSettings msmqSettings = new TransportSettings(new MsmqEndpointAddress(settings.Address.Uri), settings);
IMsmqEndpointAddress transportAddress = msmqSettings.MsmqAddress();
if (transportAddress.IsLocal)
{
ValidateLocalTransport(msmqSettings);
}
var connection = new MessageQueueConnection(transportAddress, QueueAccessMode.Send);
var connectionHandler = new ConnectionHandlerImpl<MessageQueueConnection>(connection);
return new NonTransactionalOutboundMsmqTransport(transportAddress, connectionHandler);
}
catch (Exception ex)
{
throw new TransportException(settings.Address.Uri, "Failed to create MSMQ outbound transport", ex);
}
}
public void Configure(TransportSettings settings)
{
StartSubscriptionService(settings);
StartTimeoutService(settings);
}
static void ConfigureTransport(TransportExtensions <RabbitMQTransport> transport, TransportSettings transportSettings)
{
transport.UseDirectRoutingTopology(routingKeyConvention: type => type.FullName.Replace(".", "-"));
transport.Transactions(TransportTransactionMode.ReceiveOnly);
transport.ApplyConnectionString(transportSettings.ConnectionString);
}
public override void CustomizeServiceControlEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeEndpoint(endpointConfiguration, transportSettings);
}
public EventAggregationListener(IEventAggregator events, TransportSettings settings)
{
_events = events;
_settings = settings;
}
static void ConfigureConnection(TransportExtensions <SqlServerTransport> transport, TransportSettings transportSettings)
{
var connectionString = transportSettings.ConnectionString
.RemoveCustomConnectionStringParts(out var customSchema, out var subscriptionsTableSetting);
var subscriptions = transport.SubscriptionSettings();
if (customSchema != null)
{
transport.DefaultSchema(customSchema);
subscriptions.SubscriptionTableName(defaultSubscriptionTableName, customSchema);
}
if (subscriptionsTableSetting != null)
{
var subscriptionsAddress = QueueAddress.Parse(subscriptionsTableSetting);
subscriptions.SubscriptionTableName(
tableName: subscriptionsAddress.Table,
schemaName: subscriptionsAddress.Schema ?? customSchema,
catalogName: subscriptionsAddress.Catalog
);
}
transport.ConnectionString(connectionString);
}
public override void CustomizeSendOnlyEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.ReceiveOnly);
//Do not EnableMessageDrivenPubSubCompatibilityMode for send-only endpoint
}
public override void CustomizeForReturnToSenderIngestion(RawEndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeRawEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.SendsAtomicWithReceive);
}
public AzureServiceBusTransport(TransportSettings settings)
{
_settings = settings;
_metaDataMapper = new AzureServiceBusMetaDataMapper();
}
public override void CustomizeForAuditIngestion(RawEndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeRawEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.ReceiveOnly);
}
public override void CustomizeForMonitoringIngestion(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.ReceiveOnly);
}
public override void CustomizeServiceControlEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.SendsAtomicWithReceive);
}
public JsonMessageSerializer(TransportSettings settings)
{
_serializer = JsonSerializer.Create(settings.JsonMessageSerializerSettings);
}
public InMemoryTransport(TransportSettings settings)
{
_settings = settings;
}
public override void CustomizeRawEndpoint(RawEndpointConfiguration endpointConfig, TransportSettings transportSettings)
{
var transport = endpointConfig.UseTransport <AzureServiceBusTransport>();
transport.ApplyHacksForNsbRaw();
transport.UseForwardingTopology();
transport.Sanitization().UseStrategy <ValidateAndHashIfNeeded>();
transport.ConfigureTransport(transportSettings);
}
public override void CustomizeSendOnlyEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.ReceiveOnly);
}
public override void CustomizeRawEndpoint(RawEndpointConfiguration endpointConfig, TransportSettings transportSettings)
{
var transport = endpointConfig.UseTransport <SqsTransport>();
ConfigureTransport(transport, transportSettings);
}
public override void CustomizeSendOnlyEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
var transport = endpointConfiguration.UseTransport <SqsTransport>();
ConfigureTransport(transport, transportSettings);
//Do not ConfigurePubSub for send-only endpoint
}
public IOutboundTransport BuildError(ITransportSettings settings)
{
ITransportSettings msmqSettings = new TransportSettings(settings.Address.Uri.GetQueueAddress(), settings);
return(BuildOutbound(msmqSettings));
}
public override void CustomizeServiceControlEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
var transport = endpointConfiguration.UseTransport <SqsTransport>();
ConfigureTransport(transport, transportSettings);
ConfigurePubSub(transport, transportSettings);
}
public override void CustomizeRawEndpoint(RawEndpointConfiguration endpointConfig, TransportSettings transportSettings)
{
var transport = endpointConfig.UseTransport <AzureServiceBusTransport>();
transport.UseEndpointOrientedTopology();
transport.ApplyHacksForNsbRaw();
transport.ConfigureTransport(transportSettings);
}
public static Task <IStartableEndpoint> Create(Settings.Settings settings, TransportCustomization transportCustomization, TransportSettings transportSettings, LoggingSettings loggingSettings, IContainer container, Action <ICriticalErrorContext> onCriticalError, EmbeddableDocumentStore documentStore, EndpointConfiguration configuration, bool isRunningAcceptanceTests)
{
var endpointName = settings.ServiceName;
if (configuration == null)
{
configuration = new EndpointConfiguration(endpointName);
var assemblyScanner = configuration.AssemblyScanner();
assemblyScanner.ExcludeAssemblies("ServiceControl.Plugin");
}
// HACK: Yes I know, I am hacking it to pass it to RavenBootstrapper!
configuration.GetSettings().Set(documentStore);
configuration.GetSettings().Set("ServiceControl.Settings", settings);
MapSettings(transportSettings, settings);
transportCustomization.CustomizeEndpoint(configuration, transportSettings);
configuration.GetSettings().Set(loggingSettings);
// Disable Auditing for the service control endpoint
configuration.DisableFeature <Audit>();
configuration.DisableFeature <AutoSubscribe>();
configuration.DisableFeature <TimeoutManager>();
configuration.DisableFeature <Outbox>();
var recoverability = configuration.Recoverability();
recoverability.Immediate(c => c.NumberOfRetries(3));
recoverability.Delayed(c => c.NumberOfRetries(0));
configuration.SendFailedMessagesTo($"{endpointName}.Errors");
configuration.UseSerialization <NewtonsoftSerializer>();
configuration.LimitMessageProcessingConcurrencyTo(settings.MaximumConcurrencyLevel);
configuration.Conventions().DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t));
if (!isRunningAcceptanceTests)
{
configuration.ReportCustomChecksTo(endpointName);
}
configuration.UseContainer <AutofacBuilder>(c => c.ExistingLifetimeScope(container));
configuration.DefineCriticalErrorAction(criticalErrorContext =>
{
onCriticalError(criticalErrorContext);
return(Task.FromResult(0));
});
if (Environment.UserInteractive && Debugger.IsAttached)
{
configuration.EnableInstallers();
}
return(Endpoint.Create(configuration));
}
public override void CustomizeForMonitoringIngestion(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeEndpoint(endpointConfiguration, transportSettings);
}
public IOutboundTransport BuildError(ITransportSettings settings)
{
ITransportSettings msmqSettings = new TransportSettings(settings.Address.Uri.GetQueueAddress(), settings);
return BuildOutbound(msmqSettings);
}
internal static TransportBase EstablistClientTransport(TransportSettings settings)
{
ManualResetEvent complete = new ManualResetEvent(false);
TransportBase transport = null;
Action<TransportAsyncCallbackArgs> onTransport = (a) =>
{
if (a.Exception != null)
{
Debug.WriteLine(a.Exception.Message);
}
else
{
Debug.WriteLine("Initiator established a transport.");
transport = a.Transport;
}
complete.Set();
};
TransportInitiator initiator = settings.CreateInitiator();
Debug.WriteLine("Initiator is connecting to the server...");
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = onTransport;
initiator.ConnectAsync(TimeSpan.FromSeconds(10), args);
complete.WaitOne();
complete.Dispose();
return transport;
}
static TransportSettings GetTransportSettings(ITransportSettings settings,
MsmqEndpointAddress msmqEndpointAddress)
{
var msmqSettings = new TransportSettings(msmqEndpointAddress, settings)
{
CreateIfMissing = settings.CreateIfMissing,
IsolationLevel = settings.IsolationLevel,
PurgeExistingMessages = settings.PurgeExistingMessages,
RequireTransactional = settings.RequireTransactional,
Transactional = msmqEndpointAddress.IsTransactional,
TransactionTimeout = settings.TransactionTimeout,
};
return msmqSettings;
}
public EndpointBuilder CreateBuilder()
{
ITransportSettings errorSettings = new TransportSettings(_errorAddress ?? _settings.ErrorAddress, _settings);
var endpointBuilder = new EndpointBuilderImpl(_uri, _settings, errorSettings, _transportFactory,
_errorTransportFactory, () => _settings.TrackerFactory(_settings.RetryLimit));
return endpointBuilder;
}
public static async Task <BusInstance> CreateAndStart(Settings.Settings settings, TransportCustomization transportCustomization, TransportSettings transportSettings, LoggingSettings loggingSettings, IContainer container, Action <ICriticalErrorContext> onCriticalError, EmbeddableDocumentStore documentStore, EndpointConfiguration configuration, bool isRunningAcceptanceTests)
{
var startableEndpoint = await Create(settings, transportCustomization, transportSettings, loggingSettings, container, onCriticalError, documentStore, configuration, isRunningAcceptanceTests)
.ConfigureAwait(false);
var domainEvents = container.Resolve <IDomainEvents>();
var importFailedErrors = container.Resolve <ImportFailedErrors>();
var endpointInstance = await startableEndpoint.Start().ConfigureAwait(false);
var builder = new ContainerBuilder();
builder.RegisterInstance(endpointInstance).As <IMessageSession>();
builder.Update(container.ComponentRegistry);
return(new BusInstance(endpointInstance, domainEvents, importFailedErrors));
}
static TransportExtensions <SqlServerTransport> CustomizeEndpoint(EndpointConfiguration endpointConfig, TransportSettings transportSettings, TransportTransactionMode transportTransactionMode)
{
var transport = endpointConfig.UseTransport <SqlServerTransport>();
ConfigureConnection(transport, transportSettings);
if (transportSettings.GetOrDefault <bool>("TransportSettings.EnableDtc"))
{
Logger.Error("The EnableDtc setting is no longer supported natively within ServiceControl. If you require distributed transactions, you will have to use a Transport Adapter (https://docs.particular.net/servicecontrol/transport-adapter/)");
}
endpointConfig.GetSettings().Set("SqlServer.DisableDelayedDelivery", true);
var sendOnlyEndpoint = transport.GetSettings().GetOrDefault <bool>("Endpoint.SendOnly");
if (!sendOnlyEndpoint)
{
transport.NativeDelayedDelivery();
}
transport.Transactions(transportTransactionMode);
return(transport);
}
static void CustomizeRawEndpoint(RawEndpointConfiguration endpointConfig, TransportSettings transportSettings)
{
var transport = endpointConfig.UseTransport <RabbitMQTransport>();
ConfigureTransport(transport, transportSettings);
}
public override void CustomizeForReturnToSenderIngestion(RawEndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeRawEndpoint(endpointConfiguration, transportSettings);
}
static void ConfigureTransport(TransportExtensions <SqsTransport> transport, TransportSettings transportSettings)
{
var builder = new DbConnectionStringBuilder {
ConnectionString = transportSettings.ConnectionString
};
var alwaysLoadFromEnvironmentVariable = false;
if (builder.ContainsKey("AccessKeyId") || builder.ContainsKey("SecretAccessKey"))
{
PromoteEnvironmentVariableFromConnectionString(builder, "AccessKeyId", "AWS_ACCESS_KEY_ID");
PromoteEnvironmentVariableFromConnectionString(builder, "SecretAccessKey", "AWS_SECRET_ACCESS_KEY");
// if the user provided the access key and secret access key they should always be loaded from environment credentials
alwaysLoadFromEnvironmentVariable = true;
transport.ClientFactory(() => new AmazonSQSClient(new EnvironmentVariablesAWSCredentials()));
transport.ClientFactory(() => new AmazonSimpleNotificationServiceClient(new EnvironmentVariablesAWSCredentials()));
}
else
{
//See https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html#creds-assign
log.Info("BasicAWSCredentials have not been supplied in the connection string. Attempting to use existing environment or IAM role credentials for SQS Client.");
}
var region = PromoteEnvironmentVariableFromConnectionString(builder, "Region", "AWS_REGION");
var awsRegion = RegionEndpoint.EnumerableAllRegions
.SingleOrDefault(x => x.SystemName == region);
if (awsRegion == null)
{
throw new ArgumentException($"Unknown region: \"{region}\"");
}
if (builder.TryGetValue("QueueNamePrefix", out var queueNamePrefix))
{
var queueNamePrefixAsString = (string)queueNamePrefix;
if (!string.IsNullOrEmpty(queueNamePrefixAsString))
{
transport.QueueNamePrefix(queueNamePrefixAsString);
}
}
if (builder.TryGetValue("TopicNamePrefix", out var topicNamePrefix))
{
var topicNamePrefixAsString = (string)topicNamePrefix;
if (!string.IsNullOrEmpty(topicNamePrefixAsString))
{
transport.TopicNamePrefix(topicNamePrefixAsString);
}
}
if (builder.TryGetValue("S3BucketForLargeMessages", out var bucketForLargeMessages))
{
var bucketForLargeMessagesAsString = (string)bucketForLargeMessages;
if (!string.IsNullOrEmpty(bucketForLargeMessagesAsString))
{
var keyPrefixAsString = string.Empty;
if (builder.TryGetValue("S3KeyPrefix", out var keyPrefix))
{
keyPrefixAsString = (string)keyPrefix;
}
var s3Settings = transport.S3(bucketForLargeMessagesAsString, keyPrefixAsString);
if (alwaysLoadFromEnvironmentVariable)
{
s3Settings.ClientFactory(() => new AmazonS3Client(new EnvironmentVariablesAWSCredentials()));
}
else
{
log.Info("BasicAWSCredentials have not been supplied in the connection string. Attempting to use existing environment or IAM role credentials for S3 Client.");
}
}
}
//HINT: This is needed to make Core doesn't load a connection string value from the app.config.
// This prevents SQS from throwing on startup.
var connectionString = transport.GetSettings().Get("NServiceBus.TransportConnectionString");
connectionString.GetType()
.GetField("GetValue", BindingFlags.NonPublic | BindingFlags.Instance)
?.SetValue(connectionString, (Func <string>)(() => null));
transport.Transactions(TransportTransactionMode.ReceiveOnly);
}
public override void CustomizeRawSendOnlyEndpoint(RawEndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
CustomizeRawEndpoint(endpointConfiguration, transportSettings);
}
private static void MapSettings(TransportSettings transportSettings, Settings.Settings settings)
{
transportSettings.EndpointName = settings.ServiceName;
transportSettings.ConnectionString = settings.TransportConnectionString;
transportSettings.MaxConcurrency = settings.MaximumConcurrencyLevel;
}
public override void CustomizeForMonitoringIngestion(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
var transport = endpointConfiguration.UseTransport <SqsTransport>();
ConfigureTransport(transport, transportSettings);
}
public override void CustomizeServiceControlEndpoint(EndpointConfiguration endpointConfiguration, TransportSettings transportSettings)
{
var transport = CustomizeEndpoint(endpointConfiguration, transportSettings, TransportTransactionMode.SendsAtomicWithReceive);
transport.EnableMessageDrivenPubSubCompatibilityMode();
}
