public void ReadAlias(UriAliasLookup lookups)
{
var real = lookups.Resolve(Uri);
if (real != Uri)
{
Alias = Uri;
Uri = real;
}
}
public void does_not_have_an_alias()
{
var uri = "loopback://one".ToUri();
var address = new SubscriberAddress(uri);
var lookups = new UriAliasLookup(new IUriLookup[0]);
address.ReadAlias(lookups);
address.Uri.ShouldBe(uri);
address.Alias.ShouldBeNull();
}
public ServiceBusActivator(BusSettings settings, IHandlerPipeline pipeline, IDelayedJobProcessor delayedJobs, BusMessageSerializationGraph serialization, IEnumerable <ITransport> transports, UriAliasLookup lookups, IWorkerQueue workerQueue, CompositeLogger logger, IPersistence persistence)
{
_settings = settings;
_pipeline = pipeline;
_delayedJobs = delayedJobs;
_serialization = serialization;
_transports = transports.ToArray();
_lookups = lookups;
_workerQueue = workerQueue;
_logger = logger;
_persistence = persistence;
}
public async Task applies_lookups_to_senders()
{
theSettings.SendTo("fake://one");
var lookups = new UriAliasLookup(new IUriLookup[0]);
lookups.SetAlias("fake://one", "tcp://server:2222");
await theSettings.ApplyLookups(lookups);
theSettings.KnownSubscribers.Single()
.Uri.ShouldBe("tcp://server:2222".ToUri());
}
// TODO -- take in MessagingRoot instead?
public MessageRouter(MessagingSerializationGraph serializers, IChannelGraph channels,
ISubscriptionsRepository subscriptions, HandlerGraph handlers, IMessageLogger logger, UriAliasLookup lookup,
MessagingSettings settings)
{
_serializers = serializers;
_channels = channels;
_subscriptions = subscriptions;
_handlers = handlers;
_logger = logger;
_lookup = lookup;
_settings = settings;
_workers = _settings.Workers;
}
public EnvelopeSender(CompositeLogger logger, IMessageRouter router, IChannelGraph channels, UriAliasLookup aliases, BusSettings settings, IEnumerable <ITransport> transports)
{
_router = router;
_channels = channels;
_aliases = aliases;
_settings = settings;
foreach (var transport in transports)
{
_transports.SmartAdd(transport.Protocol, transport);
}
Logger = logger;
}
public void has_an_alias()
{
var fake = "fake://one".ToUri();
var address = new SubscriberAddress(fake);
var lookups = new UriAliasLookup(new IUriLookup[0]);
var real = "real://one".ToUri();
lookups.SetAlias(fake, real);
address.ReadAlias(lookups);
address.Uri.ShouldBe(real);
address.Alias.ShouldBe(fake);
}
public async Task applies_lookups_to_listeners_happy_path()
{
theSettings.ListenForMessagesFrom("fake://one").MaximumParallelization(3);
var lookups = new UriAliasLookup(new IUriLookup[0]);
lookups.SetAlias("fake://one", "tcp://localhost:2222/incoming");
await theSettings.ApplyLookups(lookups);
theSettings.Lightweight.Port.ShouldBe(2222);
theSettings.Lightweight.Queues.Has("incoming").ShouldBeTrue();
theSettings.Lightweight.Queues["incoming"].Parallelization.ShouldBe(3);
}
public MessagingRoot(ObjectPoolProvider pooling,
MessagingSettings settings,
HandlerGraph handlers,
Forwarders forwarders,
IDurableMessagingFactory factory,
IChannelGraph channels,
ISubscriptionsRepository subscriptions,
IMessageLogger messageLogger,
IEnumerable <ISerializerFactory> serializers,
IEnumerable <IMessageDeserializer> readers,
IEnumerable <IMessageSerializer> writers,
ITransport[] transports,
IEnumerable <IMissingHandler> missingHandlers,
IEnumerable <IUriLookup> lookups, ITransportLogger transportLogger)
{
Settings = settings;
_handlers = handlers;
_transportLogger = transportLogger;
Replies = new ReplyWatcher();
Factory = factory;
Channels = channels;
Transports = transports;
Lookup = new UriAliasLookup(lookups);
Serialization = new MessagingSerializationGraph(pooling, settings, handlers, forwarders, serializers,
readers, writers);
Logger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, handlers, Replies, Logger, missingHandlers,
this);
Workers = new WorkerQueue(Logger, Pipeline, settings);
Router = new MessageRouter(Serialization, channels, subscriptions, handlers, Logger, Lookup, settings);
// TODO -- ZOMG this is horrible, and I admit it.
if (Factory is NulloDurableMessagingFactory)
{
Factory.As <NulloDurableMessagingFactory>().ScheduledJobs = ScheduledJobs;
}
}
public MessagingRoot(
ObjectPoolProvider pooling,
BusSettings settings,
HandlerGraph handlers,
Forwarders forwarders,
IPersistence persistence,
IChannelGraph channels,
ISubscriptionsRepository subscriptions,
IEnumerable <ISerializerFactory> serializers,
IEnumerable <IMessageDeserializer> readers,
IEnumerable <IMessageSerializer> writers,
IMessageLogger[] loggers,
ITransport[] transports,
IEnumerable <IMissingHandler> missingHandlers,
IEnumerable <IUriLookup> lookups)
{
_settings = settings;
_handlers = handlers;
_replies = new ReplyWatcher();
_persistence = persistence;
_channels = channels;
_transports = transports;
Lookup = new UriAliasLookup(lookups);
Serialization = new BusMessageSerializationGraph(pooling, settings, handlers, forwarders, serializers,
readers, writers);
Logger = new CompositeMessageLogger(loggers);
Pipeline = new HandlerPipeline(Serialization, handlers, _replies, Logger, missingHandlers,
new Lazy <IServiceBus>(Build));
Workers = new WorkerQueue(Logger, Pipeline, settings);
Router = new MessageRouter(Serialization, channels, subscriptions, handlers, Logger, Lookup, settings);
ScheduledJobs = new InMemoryScheduledJobProcessor();
}
public MessagingRoot(
MessagingSerializationGraph serialization,
MessagingSettings settings,
HandlerGraph handlers,
IDurableMessagingFactory factory,
IChannelGraph channels,
ISubscriptionsRepository subscriptions,
IMessageLogger messageLogger,
Lamar.IContainer container,
ITransportLogger transportLogger)
{
Settings = settings;
_handlers = handlers;
_transportLogger = transportLogger;
Replies = new ReplyWatcher();
Factory = factory;
Channels = channels;
Transports = container.QuickBuildAll <ITransport>().ToArray();
Lookup = new UriAliasLookup(container.QuickBuildAll <IUriLookup>());
Serialization = serialization;
Logger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, handlers, Replies, Logger, container.QuickBuildAll <IMissingHandler>(),
this);
Workers = new WorkerQueue(Logger, Pipeline, settings);
Router = new MessageRouter(Serialization, channels, subscriptions, handlers, Logger, Lookup, settings);
// TODO -- ZOMG this is horrible, and I admit it.
if (Factory is NulloDurableMessagingFactory f)
{
f.ScheduledJobs = ScheduledJobs;
}
}
public void Start(IMessagingRoot root, CapabilityGraph capabilities)
{
var settings = root.Settings;
_lookups = root.Lookup;
_settings = settings;
_logger = root.Logger;
_root = root;
organizeTransports(settings, root.Transports);
assertNoUnknownTransportsInSubscribers(settings);
assertNoUnknownTransportsInListeners(settings);
foreach (var transport in root.Transports)
{
transport.StartListening(root);
}
if (settings.DefaultChannelAddress != null)
{
DefaultChannel = GetOrBuildChannel(settings.DefaultChannelAddress);
}
buildInitialSendingAgents(root);
GetOrBuildChannel(TransportConstants.RetryUri);
SystemReplyUri =
capabilities.DefaultReceiverLocation
?? tryGetReplyUri("http")
?? tryGetReplyUri("tcp")
?? _transports.Values.FirstOrDefault(x => x.LocalReplyUri != null)?.LocalReplyUri;
}
public void Start(BusSettings settings, ITransport[] transports, UriAliasLookup lookups,
CapabilityGraph capabilities, CompositeMessageLogger logger, IWorkerQueue workers)
{
_lookups = lookups;
_settings = settings;
_logger = logger;
organizeTransports(settings, transports);
if (settings.DefaultChannelAddress != null)
{
DefaultChannel = GetOrBuildChannel(settings.DefaultChannelAddress);
}
assertNoUnknownTransportsInSubscribers(settings);
assertNoUnknownTransportsInListeners(settings);
foreach (var transport in _transports.Values)
{
transport.StartListening(settings, workers);
}
buildInitialSendingAgents(settings);
GetOrBuildChannel(TransportConstants.RetryUri);
SystemReplyUri =
capabilities.DefaultReceiverLocation
?? tryGetReplyUri("http")
?? tryGetReplyUri("tcp")
?? _transports.Values.FirstOrDefault(x => x.LocalReplyUri != null)?.LocalReplyUri;
}
public ServiceBusActivator(BusSettings settings, IHandlerPipeline pipeline, IDelayedJobProcessor delayedJobs, SerializationGraph serialization, IEnumerable <ITransport> transports, UriAliasLookup lookups, INodeDiscovery nodes)
{
_settings = settings;
_pipeline = pipeline;
_delayedJobs = delayedJobs;
_serialization = serialization;
_transports = transports.ToArray();
_lookups = lookups;
_nodes = nodes;
}
private async Task <ServiceCapabilities> compile(HandlerGraph handlers, SerializationGraph serialization, IChannelGraph channels, ITransport[] transports, UriAliasLookup lookups, JasperRuntime runtime)
{
var validTransports = transports.Select(x => x.Protocol).ToArray();
var capabilities = new ServiceCapabilities
{
ServiceName = runtime.ServiceName,
Subscriptions = determineSubscriptions(handlers, serialization),
Published = determinePublishedMessages(serialization, runtime, validTransports)
};
// Hokey.
foreach (var subscription in capabilities.Subscriptions)
{
subscription.ServiceName = runtime.ServiceName;
}
foreach (var message in capabilities.Published)
{
message.ServiceName = runtime.ServiceName;
}
await capabilities.ApplyLookups(lookups);
// Now, do some validation
var missingDestination = capabilities.Subscriptions
.Where(x => x.Destination == null)
.Select(s => $"Could not determine an incoming receiver for message '{s.MessageType}'");
var invalidTransport = capabilities.Subscriptions
.Where(x => x.Destination != null && !validTransports.Contains(x.Destination.Scheme))
.Select(x => $"Unknown transport '{x.Destination.Scheme}' for subscription to message '{x.MessageType}'");
var missingHandlers = capabilities.Subscriptions
.Where(x => !handlers.CanHandle(x.DotNetType))
.Select(x => $"No handler for message '{x.MessageType}' referenced in a subscription");
capabilities.Errors = missingDestination.Concat(invalidTransport).Concat(missingHandlers).ToArray();
return(capabilities);
}
public async Task <ServiceCapabilities> Compile(HandlerGraph handlers, SerializationGraph serialization, IChannelGraph channels, JasperRuntime runtime, ITransport[] transports, UriAliasLookup lookups)
{
if (runtime.ApplicationAssembly != null)
{
var publishedTypes = await TypeRepository.FindTypes(runtime.ApplicationAssembly,
TypeClassification.Concretes | TypeClassification.Closed, type => _publishFilters.Any(x => x(type)));
foreach (var type in publishedTypes)
{
Publish(type);
}
}
var capabilities = await compile(handlers, serialization, channels, transports, lookups, runtime);
capabilities.ServiceName = runtime.ServiceName;
return(capabilities);
}
public MessageRouter(SerializationGraph serializers, IChannelGraph channels, ISubscriptionsRepository subscriptions, HandlerGraph handlers, CompositeLogger logger, UriAliasLookup lookup)
{
_serializers = serializers;
_channels = channels;
_subscriptions = subscriptions;
_handlers = handlers;
_logger = logger;
_lookup = lookup;
}
public void ReadAlias(UriAliasLookup lookups)
{
Uri = lookups.Resolve(Uri);
}
public EnvelopeSender(CompositeLogger logger, IMessageRouter router, IChannelGraph channels, UriAliasLookup aliases, BusSettings settings)
{
_router = router;
_channels = channels;
_aliases = aliases;
_settings = settings;
Logger = logger;
}
