public void Apply(HandlerGraph graph, GenerationRules rules, IContainer container)
{
foreach (var chain in graph.Chains)
{
applyToChain(chain);
}
}
public DiagnosticsListener(
IDiagnosticsClient client,
HandlerGraph graph)
{
_client = client;
_graph = graph;
}
public void Apply(HandlerGraph graph)
{
foreach (var chain in graph.Chains)
{
applyToChain(chain);
}
}
private async Task <ServiceRegistry> bootstrap(JasperRegistry registry)
{
var calls = await Handlers.FindCalls(registry).ConfigureAwait(false);
_graph = new HandlerGraph();
_graph.AddRange(calls);
_graph.Add(HandlerCall.For <SubscriptionsHandler>(x => x.Handle(new SubscriptionsChanged())));
_graph.Group();
Handlers.ApplyPolicies(_graph);
Services.AddSingleton(_graph);
Services.AddSingleton <IChannelGraph>(_channels);
Services.AddSingleton <ILocalWorkerSender>(_localWorker);
Services.AddTransient <ServiceBusActivator>();
if (registry.Logging.UseConsoleLogging)
{
Services.For <IBusLogger>().Use <ConsoleBusLogger>();
Services.For <ITransportLogger>().Use <ConsoleTransportLogger>();
}
Services.ForSingletonOf <IDelayedJobProcessor>().UseIfNone <InMemoryDelayedJobProcessor>();
return(Services);
}
private async Task <ServiceRegistry> bootstrap(JasperRegistry registry)
{
var calls = await Handlers.FindCalls(registry).ConfigureAwait(false);
_graph = new HandlerGraph();
_graph.AddRange(calls);
_graph.Add(HandlerCall.For <SubscriptionsHandler>(x => x.Handle(new SubscriptionsChanged())));
_graph.Group();
Handlers.ApplyPolicies(_graph);
// Because the built in DI container is too stupid to just build out concrete types
foreach (var type in _graph.Chains.SelectMany(x => x.Handlers).Select(x => x.HandlerType).Distinct())
{
Services.AddScoped(type, type);
}
Services.AddSingleton(_graph);
Services.AddSingleton <IChannelGraph>(_channels);
Services.AddTransient <ServiceBusActivator>();
if (registry.Logging.UseConsoleLogging)
{
Services.For <IBusLogger>().Use <ConsoleBusLogger>();
}
Services.ForSingletonOf <IDelayedJobProcessor>().UseIfNone <InMemoryDelayedJobProcessor>();
return(Services);
}
public MessagingRoot(MessagingSerializationGraph serialization,
JasperOptions settings,
HandlerGraph handlers,
IDurableMessagingFactory factory,
ISubscriberGraph subscribers,
IMessageLogger messageLogger,
IContainer container,
ITransportLogger transportLogger)
{
Settings = settings;
_handlers = handlers;
_transportLogger = transportLogger;
Factory = factory;
Subscribers = subscribers;
Transports = container.QuickBuildAll <ITransport>().ToArray();
Serialization = serialization;
Logger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, handlers, Logger,
container.QuickBuildAll <IMissingHandler>(),
this);
Workers = new WorkerQueue(Logger, Pipeline, settings);
Router = new MessageRouter(this, handlers);
// TODO -- ZOMG this is horrible, and I admit it.
if (Factory is NulloDurableMessagingFactory f)
{
f.ScheduledJobs = ScheduledJobs;
}
}
public MessagingRoot(MessagingSerializationGraph serialization,
JasperOptions options,
HandlerGraph handlers,
ISubscriberGraph subscribers,
IMessageLogger messageLogger,
IContainer container,
ITransportLogger transportLogger
)
{
Options = options;
Handlers = handlers;
_transportLogger = transportLogger;
Subscribers = subscribers;
Transports = container.QuickBuildAll <ITransport>().ToArray();
Serialization = serialization;
Logger = messageLogger;
Pipeline = new HandlerPipeline(Serialization, handlers, Logger,
container.QuickBuildAll <IMissingHandler>(),
this);
Workers = new WorkerQueue(Logger, Pipeline, options);
Router = new MessageRouter(this, handlers);
_persistence = new Lazy <IEnvelopePersistence>(() => container.GetInstance <IEnvelopePersistence>());
}
public override void SetUp()
{
_tracker = new AttemptTracker();
var options = new JasperOptions();
options.Extensions.UseMessageTrackingTestingSupport();
options.Endpoints.As <TransportCollection>().Add(new StubTransport());
options.Services.AddSingleton(_tracker);
options.Endpoints.Publish(x => x.Message <ErrorCausingMessage>()
.To("local://1".ToUri()));
_host = JasperHost.For(options);
_transport = _host.GetStubTransport();
_graph = _host.Get <HandlerGraph>();
_chain = _graph.ChainFor <ErrorCausingMessage>();
_bus = _host.Get <IMessageContext>();
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var chain in graph.Chains.Where(IsSagaRelated))
{
Apply(chain, rules.SagaPersistence);
}
}
public void Apply(HandlerGraph graph, GenerationRules rules, IContainer container)
{
foreach (var chain in graph.Chains.Where(IsSagaRelated))
{
Apply(chain, rules.GetSagaPersistence(), container);
}
}
public void Apply(HandlerGraph graph)
{
foreach (var chain in graph.Chains.Where(IsSagaRelated))
{
Apply(chain, graph.SagaPersistence);
}
}
public async Task Activate(HandlerGraph handlers, CapabilityGraph capabilities, JasperRuntime runtime, OutgoingChannels channels)
{
var capabilityCompilation = capabilities.Compile(handlers, _serialization, channels, runtime, _transports, _lookups);
var transports = _transports.Where(x => x.State == TransportState.Enabled).ToArray();
if (!_settings.DisableAllTransports)
{
await _settings.ApplyLookups(_lookups);
channels.StartTransports(_pipeline, _settings, transports);
_delayedJobs.Start(_pipeline, channels);
var local = new TransportNode(channels, _settings.MachineName);
await _nodes.Register(local);
}
runtime.Capabilities = await capabilityCompilation;
if (runtime.Capabilities.Errors.Any() && _settings.ThrowOnValidationErrors)
{
throw new InvalidSubscriptionException(runtime.Capabilities.Errors);
}
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var chain in graph.Chains)
{
applyToChain(chain);
}
}
public async Task Activate(HandlerGraph handlers, CapabilityGraph capabilities, JasperRuntime runtime, ChannelGraph channels, LocalWorkerSender localWorker)
{
var capabilityCompilation = capabilities.Compile(handlers, _serialization, channels, runtime, _transports, _lookups);
var transports = _transports.Where(x => _settings.StateFor(x.Protocol) != TransportState.Disabled)
.ToArray();
_settings.Workers.Compile(handlers.Chains.Select(x => x.MessageType));
localWorker.Start(_persistence, _workerQueue);
if (!_settings.DisableAllTransports)
{
await _settings.ApplyLookups(_lookups);
channels.Start(_settings, transports, _lookups, capabilities);
_delayedJobs.Start(_workerQueue);
}
runtime.Capabilities = await capabilityCompilation;
if (runtime.Capabilities.Errors.Any() && _settings.ThrowOnValidationErrors)
{
throw new InvalidSubscriptionException(runtime.Capabilities.Errors);
}
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var chain in graph.Chains)
{
chain.Middleware.Add(new SimpleWrapper());
}
}
public void Apply(HandlerGraph graph)
{
foreach (var chain in graph.Chains)
{
chain.Middleware.Add(new SimpleWrapper());
}
}
public MessagingSerializationGraph(ObjectPoolProvider pooling, MessagingSettings messagingSettings, HandlerGraph handlers, Forwarders forwarders, IEnumerable <ISerializerFactory> serializers, IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers)
: base(pooling, messagingSettings.MediaSelectionMode, messagingSettings.JsonSerialization, forwarders, serializers, readers, writers)
{
_handlers = handlers;
// Work around here to seed this type in the serialization
RegisterType(typeof(Acknowledgement));
}
public MessageExecutor(IPartialFactory factory, IFubuRequest request, HandlerGraph graph, ILogger logger, Envelope envelope)
{
_factory = factory;
_request = request;
_graph = graph;
_logger = logger;
_envelope = envelope;
}
public MessageExecutor(IPartialFactory factory, IFubuRequest request, HandlerGraph graph, ILogger logger, Envelope envelope)
{
_factory = factory;
_request = request;
_graph = graph;
_logger = logger;
_envelope = envelope;
}
public HandlerPipeline(IEnvelopeSender sender, IEnvelopeSerializer serializer, HandlerGraph graph, IReplyWatcher replies, IBusLogger[] loggers)
{
_sender = sender;
_serializer = serializer;
_graph = graph;
_replies = replies;
Logger = BusLogger.Combine(loggers);
}
public void Apply(HandlerGraph graph, GenerationRules rules, IContainer container)
{
// We're adding the StopwatchFrame to all message types,
// but we *could* filter the application
foreach (var chain in graph.Chains)
{
chain.Middleware.Add(new StopwatchFrame(chain));
}
}
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 MessagingSerializationGraph(HandlerGraph handlers, IEnumerable <ISerializerFactory <IMessageDeserializer, IMessageSerializer> > serializers,
IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers)
: base(serializers, readers, writers)
{
_handlers = handlers;
// Work around here to seed this type in the serialization
RegisterType(typeof(Acknowledgement));
}
public void Apply(HandlerGraph graph, GenerationRules rules, IContainer container)
{
// Important! Create a brand new TransactionalFrame
// for each chain
graph
.Chains
.Where(x => x.MessageType.Name.EndsWith("Command"))
.Each(x => x.Middleware.Add(new TransactionalFrame()));
}
public MessageRouter(IMessagingRoot root, HandlerGraph handlers)
{
_serializers = root.Serialization;
_subscribers = root.Subscribers;
_handlers = handlers;
_logger = root.Logger;
_settings = root.Settings;
_workers = _handlers.Workers;
}
internal void Apply(HandlerGraph graph)
{
foreach (var policy in _globals)
{
policy.Apply(graph);
}
graph.ErrorHandlers.AddRange(this.As <IHasErrorHandlers>().ErrorHandlers);
}
public HandlerPipeline(BusMessageSerializationGraph serializers, HandlerGraph graph, IReplyWatcher replies, CompositeMessageLogger logger, IEnumerable <IMissingHandler> missingHandlers, Lazy <IServiceBus> bus)
{
_serializer = serializers;
_graph = graph;
_replies = replies;
_bus = bus;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
public HandlerPipeline(MessagingSerializationGraph serializers, HandlerGraph graph, IMessageLogger logger,
IEnumerable <IMissingHandler> missingHandlers, IMessagingRoot root)
{
_serializer = serializers;
_graph = graph;
_root = root;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
public override void TearDown()
{
_host.Dispose();
_graph = null;
_chain = null;
_transport = null;
_bus = null;
_host = null;
}
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 HandlerPipeline(IEnvelopeSender sender, BusMessageSerializationGraph serializers, HandlerGraph graph, IReplyWatcher replies, CompositeLogger logger, IEnumerable <IMissingHandler> missingHandlers)
{
_sender = sender;
_serializer = serializers;
_graph = graph;
_replies = replies;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
public HandlersTableTag(HandlerGraph handlers)
{
AddClass("table");
AddClass("handlers");
AddHeaderRow(row => {
row.Header("Message");
row.Header("Exception Policies");
row.Header("Other");
row.Header("Handlers");
});
handlers.Where(x => !FubuCore.TypeExtensions.Closes(x.InputType(), typeof(JobRequest<>))).OrderBy(x => x.InputType().Name)
.Each(chain => AddBodyRow(row => addRow(row, chain)));
}
public Task<BehaviorChain[]> BuildChains(BehaviorGraph graph, IPerfTimer timer)
{
var finders = HandlerSources.Select(x => x.FindCalls(graph.ApplicationAssembly)).ToArray();
return Task.WhenAll(finders).ContinueWith(all =>
{
var handlers = new HandlerGraph();
var allCalls = all.Result.SelectMany(x => x).Distinct();
handlers.Add(allCalls);
handlers.Compile();
return handlers.OfType<BehaviorChain>().ToArray();
});
}
private static IEnumerable<BehaviorChain> buildChains(BehaviorGraph graph)
{
var handlers = new HandlerGraph
{
HandlerCall.For<SubscriptionsHandler>(x => x.Handle(new SubscriptionRequested())),
HandlerCall.For<SubscriptionsHandler>(x => x.Handle(new SubscriptionsChanged())),
HandlerCall.For<SubscriptionsHandler>(x => x.Handle(new SubscriptionsRemoved())),
HandlerCall.For<MonitoringControlHandler>(x => x.Handle(new TakeOwnershipRequest())),
HandlerCall.For<MonitoringControlHandler>(x => x.Handle(new TaskHealthRequest())),
HandlerCall.For<MonitoringControlHandler>(x => x.Handle(new TaskDeactivation()))
};
handlers.Compile();
// TODO -- need to apply [ModifyChainAttribute]'s here. See GH-958
return handlers;
}
public MessagesFubuDiagnostics(HandlerGraph graph)
{
_graph = graph;
}
public void SetUp()
{
theGraph = new HandlerGraph();
concreteCall = HandlerCall.For<ConcreteHandler>(x => x.M1(null));
concreteCall.Clone().ShouldEqual(concreteCall);
concreteCall2 = HandlerCall.For<ConcreteHandler>(x => x.M2(null));
concreteCall3 = HandlerCall.For<ConcreteHandler>(x => x.M3(null));
concreteCall4 = HandlerCall.For<ConcreteHandler>(x => x.M4(null));
}
public void merging_matching_chains_merges_the_handlers_for_the_same_message()
{
theGraph.Add(concreteCall);
var other = new HandlerGraph();
other.Add(concreteCall2);
other.Add(concreteCall3);
theGraph.Import(other);
theGraph.ShouldHaveCount(1);
var chain = theGraph.ChainFor(typeof (Input));
chain.ElementAt(0).Equals(concreteCall).ShouldBeTrue();
chain.ElementAt(1).Equals(concreteCall2).ShouldBeTrue();
chain.ElementAt(2).Equals(concreteCall3).ShouldBeTrue();
}
public void merging_adds_a_chain_for_all_new_message_type()
{
theGraph.Add(concreteCall);
var other = new HandlerGraph();
other.Add(concreteCall4);
theGraph.Import(other);
theGraph.Select(x => x.InputType())
.ShouldHaveTheSameElementsAs(typeof(Input), typeof(DifferentInput));
}
public void applies_general_action_from_imported_graph()
{
var general = HandlerCall.For<ConcreteHandler>(x => x.General(null));
var specific1 = HandlerCall.For<ConcreteHandler>(x => x.Specific1(null));
var specific2 = HandlerCall.For<ConcreteHandler>(x => x.Specific2(null));
theGraph.Add(specific1);
var other = new HandlerGraph();
other.Add(general);
other.Add(specific2);
theGraph.Import(other);
theGraph.ApplyGeneralizedHandlers();
theGraph.ChainFor(typeof(Concrete1)).Last()
.Equals(general).ShouldBeTrue();
theGraph.ChainFor(typeof(Concrete2)).Last()
.Equals(general).ShouldBeTrue();
}