public TransportNode(IChannelGraph graph, string machineName)
{
ServiceName = graph.Name;
MachineName = machineName;
Id = $"{ServiceName}@{machineName}";
}
// TODO -- just pull in MessagingRoot?
public MessageContext(IMessageRouter router, IReplyWatcher watcher, IHandlerPipeline pipeline, MessagingSerializationGraph serialization, MessagingSettings settings, IChannelGraph channels, IDurableMessagingFactory factory, IMessageLogger logger, Envelope originalEnvelope)
{
_router = router;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
Factory = factory;
_logger = logger;
Envelope = originalEnvelope;
_sagaId = originalEnvelope.SagaId;
var persistor = new InMemoryEnvelopeTransaction();
EnlistedInTransaction = true;
Transaction = persistor;
if (Envelope.AckRequested)
{
var ack = buildAcknowledgement();
persistor.Queued.Fill(ack);
_outstanding.Add(ack);
}
}
public EnvelopeSender(CompositeLogger logger, IMessageRouter router, IChannelGraph channels, UriAliasLookup aliases, BusSettings settings)
{
_router = router;
_channels = channels;
_aliases = aliases;
_settings = settings;
Logger = logger;
}
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 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;
}
public ServiceBus(IEnvelopeSender sender, IReplyWatcher watcher, IHandlerPipeline pipeline, BusMessageSerializationGraph serialization, BusSettings settings, IChannelGraph channels, IPersistence persistence)
{
_sender = sender;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
_persistence = persistence;
}
// TODO -- just pull in MessagingRoot?
public MessageContext(IMessageRouter router, IReplyWatcher watcher, IHandlerPipeline pipeline, MessagingSerializationGraph serialization, MessagingSettings settings, IChannelGraph channels, IDurableMessagingFactory factory, IMessageLogger logger)
{
_router = router;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
Factory = factory;
_logger = logger;
}
public ServiceBus(IMessageRouter router, IReplyWatcher watcher, IHandlerPipeline pipeline, BusMessageSerializationGraph serialization, BusSettings settings, IChannelGraph channels, IPersistence persistence, CompositeMessageLogger logger)
{
_router = router;
_watcher = watcher;
_pipeline = pipeline;
_serialization = serialization;
_settings = settings;
_channels = channels;
Persistence = persistence;
_logger = logger;
}
public SchedulingAgent(IChannelGraph channels, IWorkerQueue workers, SqlServerSettings mssqlSettings,
MessagingSettings settings, ITransportLogger logger, IRetries retries)
: base(settings, logger,
new RunScheduledJobs(workers, mssqlSettings, logger, retries, settings),
new RecoverIncomingMessages(workers, settings, mssqlSettings, logger),
new RecoverOutgoingMessages(channels, settings, mssqlSettings, logger),
new ReassignFromDormantNodes(mssqlSettings, settings)
)
{
_mssqlSettings = mssqlSettings;
}
public RecoverOutgoingMessages(IChannelGraph channels, MessagingSettings settings, SqlServerSettings mssqlSettings,
ITransportLogger logger)
{
_channels = channels;
_settings = settings;
_mssqlSettings = mssqlSettings;
_logger = logger;
_findUniqueDestinations = $"select distinct destination from {_mssqlSettings.SchemaName}.{SqlServerEnvelopePersistor.OutgoingTable}";
_findOutgoingEnvelopesSql = $"select top {settings.Retries.RecoveryBatchSize} body from {_mssqlSettings.SchemaName}.{SqlServerEnvelopePersistor.OutgoingTable} where owner_id = {TransportConstants.AnyNode} and destination = @destination";
_deleteOutgoingSql = $"delete from {_mssqlSettings.SchemaName}.{SqlServerEnvelopePersistor.OutgoingTable} where owner_id = :owner and destination = @destination";
}
public RecoverOutgoingMessages(IChannelGraph channels, BusSettings settings, EnvelopeTables marker, ISchedulingAgent schedulingAgent, CompositeTransportLogger logger)
{
_channels = channels;
_settings = settings;
_marker = marker;
_schedulingAgent = schedulingAgent;
_logger = logger;
_findUniqueDestinations = $"select distinct destination from {_marker.Outgoing}";
_findOutgoingEnvelopesSql = $"select body from {marker.Outgoing} where owner_id = {TransportConstants.AnyNode} and destination = :destination limit {settings.Retries.RecoveryBatchSize}";
_deleteOutgoingSql = $"delete from {marker.Outgoing} where owner_id = :owner and destination = :destination";
}
public HandlerPipeline(IEnvelopeSender sender, SerializationGraph serializers, HandlerGraph graph, IReplyWatcher replies, IDelayedJobProcessor delayedJobs, CompositeLogger logger, IChannelGraph channels, IEnumerable <IMissingHandler> missingHandlers)
{
_sender = sender;
_serializer = serializers;
_graph = graph;
_replies = replies;
_delayedJobs = delayedJobs;
_channels = channels;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
public SchedulingAgent(IChannelGraph channels, IWorkerQueue workers, IDocumentStore store, MessagingSettings settings, ITransportLogger logger, StoreOptions storeOptions, IRetries retries, EnvelopeTables tables)
: base(settings, logger,
new RunScheduledJobs(workers, store, tables, logger, retries),
new RecoverIncomingMessages(workers, settings, tables, logger),
new RecoverOutgoingMessages(channels, settings, tables, logger),
new ReassignFromDormantNodes(tables, settings)
)
{
_store = store;
}
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 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 SchedulingAgent(IChannelGraph channels, IWorkerQueue workers, IDocumentStore store, BusSettings settings, CompositeTransportLogger logger, StoreOptions storeOptions, MartenRetries retries)
{
_channels = channels;
_workers = workers;
_store = store;
_settings = settings;
_logger = logger;
_storeOptions = storeOptions;
_worker = new ActionBlock <IMessagingAction>(processAction, new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = 1
});
var marker = new EnvelopeTables(_settings, _storeOptions);
_scheduledJobs = new RunScheduledJobs(_workers, _store, marker, logger, retries);
_incomingMessages = new RecoverIncomingMessages(_workers, _settings, marker, this, _logger);
_outgoingMessages = new RecoverOutgoingMessages(_channels, _settings, marker, this, _logger);
_nodeReassignment = new ReassignFromDormantNodes(marker, settings);
}
public ConsulSubscriptionRepository(ConsulSettings settings, IChannelGraph channels, MessagingSettings envSettings)
: base(settings, channels, envSettings)
{
_settings = settings;
}
public void Start(IHandlerPipeline pipeline, IChannelGraph channels)
{
_channel = channels[LoopbackTransport.Delayed];
}
public ConsulNodeDiscovery(ConsulSettings settings, IChannelGraph channels, BusSettings envSettings) : base(settings, channels, envSettings)
{
}
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 void Start(IHandlerPipeline pipeline, IChannelGraph channels)
{
}
protected ConsulService(ConsulSettings settings, IChannelGraph channels, BusSettings envSettings)
{
_channels = channels;
client = settings.Client;
MachineName = envSettings.MachineName;
}
public PublishedMessage(Type messageType, ModelWriter modelWriter, IChannelGraph channels) : this(messageType)
{
ContentTypes = modelWriter.ContentTypes;
Transports = channels.ValidTransports;
}
private PublishedMessage[] determinePublishedMessages(SerializationGraph serialization, IChannelGraph channels, string[] validTransports)
{
foreach (var published in _published)
{
published.ServiceName = channels.Name;
var writer = serialization.WriterFor(published.DotNetType);
published.ContentTypes = writer.ContentTypes;
published.Transports = validTransports;
}
return(_published.ToArray());
}
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 ConsulSubscriptionRepository(ConsulSettings settings, IChannelGraph channels, BusSettings envSettings)
: base(settings, channels, envSettings)
{
}
