public MessagingSerializationGraph(ObjectPoolProvider pooling, JasperOptions jasperOptions,
HandlerGraph handlers, Forwarders forwarders, IEnumerable <ISerializerFactory> serializers,
IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers)
: base(pooling, jasperOptions.JsonSerialization, serializers, readers, writers)
{
_handlers = handlers;
// Work around here to seed this type in the serialization
RegisterType(typeof(Acknowledgement));
}
private static void RunWithReplacementDecorator(string arg)
{
var currentType = MethodBase.GetCurrentMethod().DeclaringType;
var thingsThatHaveRun = (Dictionary <string, object[]>)currentType
.GetProperty("ThingsThatHaveRun", BindingFlags.Public | BindingFlags.Static)
.GetValue(null);
thingsThatHaveRun.Add("Decorated RunWithReplacement", new object[] { arg });
Forwarders.ForwardToOriginalAction(arg);
}
void Trivial()
{
Debug.Assert(false);
Debug.Assert(true);
Assert.IsTrue(false);
Assert.IsTrue(true);
Assert.IsFalse(true);
Assert.IsFalse(false);
Forwarders.MyAssert(false);
Forwarders.MyAssert(true);
Forwarders.MyAssert2(false);
Forwarders.MyAssert2(true);
}
void M()
{
string s = null;
Debug.Assert(s != null);
Assert.IsNull(s);
Assert.IsNotNull(s);
Assert.IsTrue(s == null);
Assert.IsTrue(s != null);
Assert.IsFalse(s != null);
Assert.IsFalse(s == null);
Forwarders.MyAssert(s == null);
Forwarders.MyAssert2(s == null);
}
private void conneg(JasperRegistry parent)
{
this.AddOptions();
var forwarding = new Forwarders();
For <Forwarders>().Use(forwarding);
Scan(_ =>
{
_.Assembly(parent.ApplicationAssembly);
_.AddAllTypesOf <IMessageSerializer>();
_.AddAllTypesOf <IMessageDeserializer>();
_.With(new ForwardingRegistration(forwarding));
});
}
public void AddForwarders(Forwarders forwarders)
{
foreach (var pair in forwarders.Relationships)
{
var source = pair.Key;
var destination = pair.Value;
if (_chains.TryFind(destination, out var inner))
{
var handler =
TypeExtensions.CloseAndBuildAs <MessageHandler>(typeof(ForwardingHandler <,>), this, new Type[] { source, destination });
_chains = _chains.AddOrUpdate(source, handler.Chain);
_handlers = _handlers.AddOrUpdate(source, handler);
}
}
}
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 JasperServiceRegistry(JasperOptions parent)
{
For <IMetrics>().Use <NulloMetrics>();
//For<IHostedService>().Use<MetricsCollector>();
this.AddSingleton <IServiceProviderFactory <IServiceCollection> >(new DefaultServiceProviderFactory());
this.AddLogging();
For <IMessageLogger>().Use <MessageLogger>().Singleton();
For <ITransportLogger>().Use <TransportLogger>().Singleton();
For <IMessageSerializer>().Use <EnvelopeReaderWriter>();
For <IMessageDeserializer>().Use <EnvelopeReaderWriter>();
For <ISerializerFactory <IMessageDeserializer, IMessageSerializer> >().Use <NewtonsoftSerializerFactory>();
this.AddSingleton(parent.Advanced);
this.AddOptions();
var forwarding = new Forwarders();
For <Forwarders>().Use(forwarding);
Scan(_ =>
{
_.Assembly(parent.ApplicationAssembly);
_.AddAllTypesOf <IMessageSerializer>();
_.AddAllTypesOf <IMessageDeserializer>();
_.With(new ForwardingRegistration(forwarding));
});
Policies.Add(new HandlerScopingPolicy(parent.HandlerGraph));
ForSingletonOf <MessagingSerializationGraph>().Use <MessagingSerializationGraph>();
For <IEnvelopePersistence>().Use <NulloEnvelopePersistence>();
this.AddSingleton <InMemorySagaPersistor>();
this.AddSingleton(parent.HandlerGraph);
Scan(x =>
{
x.AssemblyContainingType <JasperServiceRegistry>();
x.ConnectImplementationsToTypesClosing(typeof(ISerializerFactory <,>));
});
ForSingletonOf <IMessagingRoot>().Use <MessagingRoot>();
ForSingletonOf <ObjectPoolProvider>().Use(new DefaultObjectPoolProvider());
MessagingRootService(x => x.Pipeline);
MessagingRootService(x => x.Router);
MessagingRootService(x => x.ScheduledJobs);
MessagingRootService(x => x.Runtime);
For <IMessageContext>().Use(c => c.GetInstance <IMessagingRoot>().NewContext());
For <ICommandBus>().Use(c => c.GetInstance <IMessagingRoot>().NewContext());
For <IMessagePublisher>().Use(c => c.GetInstance <IMessagingRoot>().NewContext());
// I'm not proud of this code, but you need a non-null
// Container property to use the codegen
For <IGeneratesCode>().Use(c =>
{
var handlers = c.GetInstance <HandlerGraph>();
handlers.Container = (IContainer)c;
return(handlers);
});
}
public BusMessageSerializationGraph(ObjectPoolProvider pooling, BusSettings busSettings, HandlerGraph handlers, Forwarders forwarders, IEnumerable <ISerializerFactory> serializers, IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers)
: base(pooling, busSettings.MediaSelectionMode, busSettings.JsonSerialization, forwarders, serializers, readers, writers)
{
_handlers = handlers;
// Work around here to seed this type in the serialization
RegisterType(typeof(Acknowledgement));
}
public HttpSerializationGraph(HttpSettings settings, ObjectPoolProvider pooling, Forwarders forwarders, IEnumerable <ISerializerFactory> serializers, IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers)
: base(pooling, settings.MediaSelectionMode, settings.JsonSerialization, forwarders, serializers, readers, writers)
{
}
public BusMessageSerializationGraph(ObjectPoolProvider pooling, BusSettings busSettings, HandlerGraph handlers, Forwarders forwarders, IEnumerable <ISerializerFactory> serializers, IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers)
: base(pooling, busSettings.MediaSelectionMode, busSettings.JsonSerialization, forwarders, serializers, readers, writers)
{
_handlers = handlers;
}
