public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, string inputQueueName, string errorQueueName, CancellationToken cancellationToken = default)
{
sqlServerTransport = (SqlServerTransport)transportDefinition;
this.inputQueueName = inputQueueName;
this.errorQueueName = errorQueueName;
#if !NETFRAMEWORK
if (sqlServerTransport.TransportTransactionMode == TransportTransactionMode.TransactionScope)
{
NUnit.Framework.Assert.Ignore("TransactionScope not supported in .NET Core");
}
#endif
sqlServerTransport.DelayedDelivery.TableSuffix = "Delayed";
sqlServerTransport.Subscriptions.DisableCaching = true;
var receivers = new[]
{
new ReceiveSettings(
"mainReceiver",
inputQueueName,
transportDefinition.SupportsPublishSubscribe,
true,
errorQueueName)
};
return(await sqlServerTransport.Initialize(hostSettings, receivers, new[] { errorQueueName }, cancellationToken).ConfigureAwait(false));
}
void IgnoreUnsupportedTransactionModes(TransportDefinition transportDefinition, TransportTransactionMode requestedTransactionMode)
{
if (!transportDefinition.GetSupportedTransactionModes().Contains(requestedTransactionMode))
{
Assert.Ignore($"Only relevant for transports supporting {requestedTransactionMode} or higher");
}
}
protected TransportSeam(TransportDefinition transportDefinition, HostSettings hostSettings,
QueueBindings queueBindings)
{
TransportDefinition = transportDefinition;
QueueBindings = queueBindings;
this.hostSettings = hostSettings;
}
public string GetConnectionStringOrRaiseError(TransportDefinition transportDefinition)
{
var connectionString = GetValue();
if (connectionString == null && transportDefinition.RequiresConnectionString)
{
throw new InvalidOperationException(string.Format(Message, transportDefinition.GetType().Name, transportDefinition.ExampleConnectionStringForErrorMessage));
}
return connectionString;
}
public string GetConnectionStringOrRaiseError(TransportDefinition transportDefinition)
{
var connectionString = GetValue();
if (connectionString == null && transportDefinition.RequiresConnectionString)
{
throw new InvalidOperationException(string.Format(Message, transportDefinition.GetType().Name, transportDefinition.ExampleConnectionStringForErrorMessage));
}
return(connectionString);
}
public async Task <TransportInfrastructure> CreateTransportInfrastructure(CancellationToken cancellationToken)
{
TransportInfrastructure = await TransportDefinition.Initialize(hostSettings, receivers, QueueBindings.SendingAddresses.ToArray(), cancellationToken)
.ConfigureAwait(false);
var eventHandlers = TransportInfrastructureCreated;
eventHandlers?.Invoke(this, TransportInfrastructure);
return(TransportInfrastructure);
}
public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, QueueAddress inputQueueName, string errorQueueName, CancellationToken cancellationToken = default)
{
var msmqSettings = (MsmqTransport)transportDefinition;
var infrastructure = await msmqSettings.Initialize(hostSettings,
new[] { new ReceiveSettings("TestReceiver", inputQueueName, false, true, errorQueueName) },
new[] { errorQueueName },
cancellationToken);
receiveQueue = infrastructure.ToTransportAddress(inputQueueName);
return(infrastructure);
}
public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, QueueAddress inputQueue, string errorQueueName, CancellationToken cancellationToken = default)
{
var mainReceiverSettings = new ReceiveSettings(
"mainReceiver",
inputQueue,
true,
true, errorQueueName);
var transport = await transportDefinition.Initialize(hostSettings, new[] { mainReceiverSettings }, new[] { errorQueueName }, cancellationToken);
queuesToCleanUp = new[] { transport.ToTransportAddress(inputQueue), errorQueueName };
return(transport);
}
public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, QueueAddress inputQueueName, string errorQueueName, CancellationToken cancellationToken = default)
{
var transportInfrastructure = await transportDefinition.Initialize(
hostSettings,
new[]
{
new ReceiveSettings(inputQueueName.ToString(), inputQueueName, true, false, errorQueueName),
},
new string[0],
cancellationToken);
return(transportInfrastructure);
}
public Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, string inputQueueName,
string errorQueueName, CancellationToken cancellationToken = default)
{
queuesToCleanUp = new[] { inputQueueName, errorQueueName };
var mainReceiverSettings = new ReceiveSettings(
"mainReceiver",
inputQueueName,
true,
true, errorQueueName);
return(transportDefinition.Initialize(hostSettings, new[] { mainReceiverSettings }, new[] { errorQueueName }, cancellationToken));
}
public async Task <TransportInfrastructure> Configure(TransportDefinition transportDefinition, HostSettings hostSettings, string inputQueueName, string errorQueueName, CancellationToken cancellationToken)
{
var mainReceiverSettings = new ReceiveSettings(
"mainReceiver",
inputQueueName,
transportDefinition.SupportsPublishSubscribe,
true,
errorQueueName);
var transportInfrastructure = await transportDefinition.Initialize(
hostSettings,
new[] { mainReceiverSettings },
new[] { errorQueueName },
cancellationToken);
return(transportInfrastructure);
}
public ReturnToSenderDequeuer(TransportDefinition transportDefinition, ReturnToSender returnToSender, IDocumentStore store, IDomainEvents domainEvents, string inputAddress, RawEndpointFactory rawEndpointFactory)
{
InputAddress = inputAddress;
this.returnToSender = returnToSender;
createEndpointConfiguration = () =>
{
var config = rawEndpointFactory.CreateRawEndpointConfiguration(InputAddress, Handle, transportDefinition);
config.CustomErrorHandlingPolicy(faultManager);
return(config);
};
faultManager = new CaptureIfMessageSendingFails(store, domainEvents, IncrementCounterOrProlongTimer);
timer = new Timer(state => StopInternal().GetAwaiter().GetResult());
}
bool IsAzureTransport()
{
return(TransportDefinition.GetType().Name.ToLower().Contains("azure"));
}
public void SetUp()
{
transportDefinition = new Msmq();
HandlerInvocationCache.Clear();
SettingsHolder.Reset();
SettingsHolder.SetDefault("Endpoint.SendOnly", false);
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
Configure.GetEndpointNameAction = () => "TestEndpoint";
subscriptionPredicatesEvaluator = new SubscriptionPredicatesEvaluator();
router = new StaticMessageRouter(KnownMessageTypes());
handlerRegistry = new MessageHandlerRegistry();
MessageMetadataRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = false
};
MessageSerializer = new XmlMessageSerializer(MessageMapper);
//ExtensionMethods.GetStaticOutgoingHeadersAction = () => MessageHeaderManager.staticHeaders;
gatewayAddress = MasterNodeAddress.SubScope("gateway");
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
subscriptionManager = new MessageDrivenSubscriptionManager
{
Builder = FuncBuilder,
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var pipelineBuilder = new PipelineBuilder(FuncBuilder);
pipelineFactory = new PipelineExecutor(FuncBuilder, pipelineBuilder);
FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer);
FuncBuilder.Register <ISendMessages>(() => messageSender);
FuncBuilder.Register <MessageAuditer>(() => new MessageAuditer());
FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory());
FuncBuilder.Register <IMutateIncomingMessages>(() => new FilteringMutator
{
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator
});
FuncBuilder.Register <IMutateIncomingTransportMessages>(() => subscriptionManager);
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry);
FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry);
FuncBuilder.Register <ExtractIncomingPrincipal>(() => new WindowsImpersonator());
FuncBuilder.Register <IMessageMapper>(() => MessageMapper);
FuncBuilder.Register <ExtractLogicalMessagesBehavior>(() => new ExtractLogicalMessagesBehavior
{
MessageSerializer = MessageSerializer,
MessageMetadataRegistry = MessageMetadataRegistry,
});
FuncBuilder.Register <ImpersonateSenderBehavior>(() => new ImpersonateSenderBehavior
{
ExtractIncomingPrincipal = MockRepository.GenerateStub <ExtractIncomingPrincipal>()
});
FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior());
FuncBuilder.Register <PipelineBuilder>(() => pipelineBuilder);
FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory);
FuncBuilder.Register <TransportDefinition>(() => transportDefinition);
var messagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var deferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts")
};
FuncBuilder.Register <IDeferMessages>(() => deferrer);
FuncBuilder.Register <IPublishMessages>(() => messagePublisher);
unicastBus = new UnicastBus
{
MasterNodeAddress = MasterNodeAddress,
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
SubscriptionManager = subscriptionManager,
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator,
MessageRouter = router
};
bus = unicastBus;
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
FuncBuilder.Register <UnicastBus>(() => unicastBus);
new HeaderBootstrapper
{
Builder = FuncBuilder
}.SetupHeaderActions();
}
void ConfigureTransport(TransportDefinition transportDefinition)
{
Settings.Set(transportDefinition);
}
static void ConfigureTransport(EndpointConfiguration endpointConfiguration, TransportDefinition transportDefinition)
{
endpointConfiguration.Settings.Set <TransportDefinition>(transportDefinition);
}
static void ConfigureTransport(EndpointConfiguration endpointConfiguration, TransportDefinition transportDefinition)
{
endpointConfiguration.Settings.Set <InboundTransport>(new InboundTransport());
endpointConfiguration.Settings.Set <TransportDefinition>(transportDefinition);
endpointConfiguration.Settings.Set <OutboundTransport>(new OutboundTransport());
}
public void SetUp()
{
LicenseManager.InitializeLicense();
transportDefinition = new MsmqTransport();
settings = new SettingsHolder();
settings.SetDefault("EndpointName", "TestEndpoint");
settings.SetDefault("Endpoint.SendOnly", false);
settings.SetDefault("MasterNode.Address", MasterNodeAddress);
pipelineModifications = new PipelineModifications();
settings.Set <PipelineModifications>(pipelineModifications);
ApplyPipelineModifications();
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
FuncBuilder.Register <ReadOnlySettings>(() => settings);
router = new StaticMessageRouter(KnownMessageTypes());
var conventions = new Conventions();
handlerRegistry = new MessageHandlerRegistry(conventions);
MessageMetadataRegistry = new MessageMetadataRegistry(false, conventions);
MessageSerializer = new XmlMessageSerializer(MessageMapper, conventions);
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
configure = new Configure(settings, FuncBuilder, new List <Action <IConfigureComponents> >(), new PipelineSettings(null))
{
localAddress = Address.Parse("TestEndpoint")
};
subscriptionManager = new SubscriptionManager
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage,
Configure = configure
};
pipelineFactory = new PipelineExecutor(settings, FuncBuilder);
FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer);
FuncBuilder.Register <ISendMessages>(() => messageSender);
FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory(MessageMetadataRegistry, MessageMapper, pipelineFactory));
FuncBuilder.Register <IManageSubscriptions>(() => subscriptionManager);
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry);
FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry);
FuncBuilder.Register <IMessageMapper>(() => MessageMapper);
FuncBuilder.Register <DeserializeLogicalMessagesBehavior>(() => new DeserializeLogicalMessagesBehavior
{
MessageSerializer = MessageSerializer,
MessageMetadataRegistry = MessageMetadataRegistry,
});
FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior());
FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory);
FuncBuilder.Register <TransportDefinition>(() => transportDefinition);
var messagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var deferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts"),
Configure = configure,
};
FuncBuilder.Register <IDeferMessages>(() => deferrer);
FuncBuilder.Register <IPublishMessages>(() => messagePublisher);
bus = new UnicastBus
{
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
SubscriptionManager = subscriptionManager,
MessageRouter = router,
Settings = settings,
Configure = configure,
HostInformation = new HostInformation(Guid.NewGuid(), "HelloWorld")
};
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
FuncBuilder.Register <UnicastBus>(() => bus);
FuncBuilder.Register <Conventions>(() => conventions);
FuncBuilder.Register <Configure>(() => configure);
}
static void ConfigureTransport(EndpointConfiguration endpointConfiguration, TransportDefinition transportDefinition)
{
endpointConfiguration.Settings.Get <TransportSeam.Settings>().TransportDefinition = transportDefinition;
}
public RawEndpointConfiguration CreateRawEndpointConfiguration(string name, Func <MessageContext, IDispatchMessages, Task> onMessage, TransportDefinition transportDefinition)
{
var config = RawEndpointConfiguration.Create(name, onMessage, $"{transportSettings.EndpointName}.Errors");
config.LimitMessageProcessingConcurrencyTo(settings.MaximumConcurrencyLevel);
transportCustomization.CustomizeRawEndpoint(config, transportSettings);
return(config);
}
string GetConnectionString(TransportDefinition transportDefinition)
{
var instance = settings.Get(connectionStringType.FullName);
return((string)connectionStringGetter.Invoke(instance, new object[] { transportDefinition }));
}
