private void getReady() { theSender = JasperHost.For(_ => { _.Handlers.DisableConventionalDiscovery(); _.Extensions.UseMessageTrackingTestingSupport(); }); var receiver = new JasperOptions(); receiver.Handlers.DisableConventionalDiscovery(); receiver.Endpoints.ListenForMessagesFrom(theAddress); receiver.Handlers.Retries.MaximumAttempts = 3; receiver.Handlers.IncludeType <MessageConsumer>(); scheduledJobs = new FakeScheduledJobProcessor(); receiver.Services.For <IScheduledJobProcessor>().Use(scheduledJobs); receiver.Extensions.UseMessageTrackingTestingSupport(); theReceiver = JasperHost.For(receiver); }
internal async Task <HandlerCall[]> FindCalls(JasperOptions options) { if (_conventionalDiscoveryDisabled) { return(_explicitTypes.SelectMany(actionsFromType).ToArray()); } if (options.ApplicationAssembly == null) { return(new HandlerCall[0]); } _assemblies.Add(options.ApplicationAssembly); var types = await TypeRepository.FindTypes(_assemblies, TypeClassification.Concretes | TypeClassification.Closed, type => _typeFilters.Matches(type)) .ConfigureAwait(false); return(types .Where(x => !x.HasAttribute <JasperIgnoreAttribute>()) .Concat(_explicitTypes) .Distinct() .SelectMany(actionsFromType).ToArray()); }
public void Configure(JasperOptions options) { // this will force the transport collection // to add Rabbit MQ if it does not alreay // exist options.Endpoints.RabbitMqTransport(); }
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 Configure(JasperOptions options) { var frameProvider = new EFCorePersistenceFrameProvider(); options.Advanced.CodeGeneration.SetSagaPersistence(frameProvider); options.Advanced.CodeGeneration.SetTransactions(frameProvider); }
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 MartenBackedListenerContext() { theStore = DocumentStore.For(_ => { _.Connection(Servers.PostgresConnectionString); _.PLV8Enabled = false; _.Storage.Add <PostgresqlEnvelopeStorage>(); }); theStore.Advanced.Clean.CompletelyRemoveAll(); theStore.Schema.ApplyAllConfiguredChangesToDatabase(); theWorkerQueue = Substitute.For <IWorkerQueue>(); theSettings = new JasperOptions(); var tables = new EnvelopeTables(theSettings, new StoreOptions()); var retries = new EnvelopeRetries(new MartenEnvelopePersistor(theStore, tables), TransportLogger.Empty(), theSettings); theListener = new DurableListener( Substitute.For <IListeningAgent>(), theWorkerQueue, TransportLogger.Empty(), theSettings, retries, new MartenEnvelopePersistor(theStore, tables)); }
public ReassignFromDormantNodes(EnvelopeTables marker, JasperOptions settings) { _marker = marker; _reassignDormantNodeIncomingSql = $@" update {marker.Incoming} set owner_id = 0 where owner_id in ( select distinct owner_id from {marker.Incoming} where owner_id != 0 AND owner_id != {settings.UniqueNodeId} AND pg_try_advisory_xact_lock(owner_id) ); "; _reassignDormantNodeOutgoingSql = $@" update {marker.Outgoing} set owner_id = 0 where owner_id in ( select distinct owner_id from {marker.Outgoing} where owner_id != 0 AND owner_id != {settings.UniqueNodeId} AND pg_try_advisory_xact_lock(owner_id) ); "; }
public ApplicationInsightsMetrics(TelemetryClient client, JasperOptions settings) { _client = client; _settings = settings; _client.Context.Properties.Add("Node", settings.NodeId); }
public void Start(IMessagingRoot root) { var settings = root.Options; _settings = settings; _logger = root.Logger; _root = root; organizeTransports(settings, root.Transports); assertNoUnknownTransportsInSubscribers(settings); assertNoUnknownTransportsInListeners(settings); foreach (var transport in root.Transports) { transport.StartListening(root); } buildInitialSendingAgents(root); GetOrBuild(TransportConstants.RetryUri); }
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 async Task enqueue_locally() { var registry = new JasperOptions(); registry.Handlers.DisableConventionalDiscovery(); registry.Services.Scan(x => { x.TheCallingAssembly(); x.WithDefaultConventions(); }); registry.Handlers.IncludeType <MessageConsumer>(); registry.Services.ForSingletonOf <IFakeStore>().Use <FakeStore>(); registry.Extensions.UseMessageTrackingTestingSupport(); using (var host = JasperHost.For(registry)) { var message = new Message1 { Id = Guid.NewGuid() }; var session = await host.ExecuteAndWait(c => c.Enqueue(message)); var tracked = session.FindSingleTrackedMessageOfType <Message1>(); tracked.Id.ShouldBe(message.Id); } }
protected override IListeningAgent buildListeningAgent(Uri uri, JasperOptions settings) { var agent = _settings.For(uri); agent.Start(); return(agent.CreateListeningAgent(uri, settings, logger)); }
public MessagingRoot(MessagingSerializationGraph serialization, JasperOptions options, IMessageLogger messageLogger, IContainer container, ITransportLogger transportLogger ) { Options = options; Handlers = options.HandlerGraph; TransportLogger = transportLogger; Settings = options.Advanced; Serialization = serialization; MessageLogger = messageLogger; Pipeline = new HandlerPipeline(Serialization, Handlers, MessageLogger, container.QuickBuildAll <IMissingHandler>(), this); Runtime = new TransportRuntime(this); _persistence = new Lazy <IEnvelopePersistence>(() => container.GetInstance <IEnvelopePersistence>()); Router = new EnvelopeRouter(this); _container = container; Cancellation = Settings.Cancellation; }
public async Task SendMessage([SelectionList("MessageTypes")] string messageType, string name) { if (!_initialized) { if (_publisher == null) { var registry = new JasperOptions { ServiceName = "Publisher" }; registry.Extensions.UseMessageTrackingTestingSupport(); _publisher = _nodes.Add(registry); } _initialized = true; } var type = messageTypeFor(messageType); var message = Activator.CreateInstance(type).As <Message>(); message.Name = name; await _publisher.SendMessageAndWait(message); }
public TransportBase(string protocol, ITransportLogger logger, JasperOptions options) { this.logger = logger; JasperOptions = options; Protocol = protocol; }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, JasperOptions messaging) { // This is optional, but it's awfully helpful // to configure the message bus part of Jasper directly // from configuration messaging.ListenForMessagesFrom(Configuration["ListeningEndpoint"]); messaging.AddSubscription(Subscription.All(Configuration["OtherServiceUri"])); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. app.UseHsts(); } app.UseHttpsRedirection(); // The ordering here is meaningful, but we think that // Jasper's routing is more efficient, so let it try // first app.UseJasper(); app.UseMvc(); }
public static JasperStorytellerHost <JasperOptions> Basic(Action <JasperOptions> configure = null) { var jasperRegistry = new JasperOptions(); configure?.Invoke(jasperRegistry); return(new JasperStorytellerHost <JasperOptions>(jasperRegistry)); }
public RecoverIncomingMessages(IEnvelopePersistence persistence, IWorkerQueue workers, JasperOptions options, ITransportLogger logger) { _persistence = persistence; _workers = workers; _options = options; _logger = logger; }
public static JasperStorytellerHost <JasperOptions> Basic(Action <JasperOptions> configure = null) { var JasperOptions = new JasperOptions(); configure?.Invoke(JasperOptions); return(new JasperStorytellerHost <JasperOptions>(JasperOptions)); }
public TransportBase(string protocol, IDurableMessagingFactory factory, ITransportLogger logger, JasperOptions settings) { _durableMessagingFactory = factory; this.logger = logger; JasperOptions = settings; Protocol = protocol; }
protected override void configureSender(JasperOptions senderOptions) { senderOptions.UseMarten(marten => { marten.Connection(Servers.PostgresConnectionString); marten.DatabaseSchemaName = "outbox_sender"; }); }
protected override void configureReceiver(JasperOptions receiverOptions) { receiverOptions.Extensions.UseMarten(marten => { marten.Connection(Servers.PostgresConnectionString); marten.DatabaseSchemaName = "outbox_receiver"; }); }
public override void SetUp() { var receiverPort = PortFinder.FindPort(3340); var senderPort = PortFinder.FindPort(3370); var publishingUri = $"tcp://localhost:{receiverPort}/durable"; var senderRegistry = new JasperOptions(); senderRegistry.Handlers .DisableConventionalDiscovery() .IncludeType <CascadeReceiver>() .IncludeType <ScheduledMessageHandler>(); senderRegistry.Extensions.UseMessageTrackingTestingSupport(); senderRegistry.Endpoints.Publish(x => { x.Message <TriggerMessage>(); x.Message <ItemCreated>(); x.Message <Question>(); x.Message <ScheduledMessage>(); x.ToPort(receiverPort).Durably(); }); senderRegistry.Endpoints.ListenAtPort(senderPort).Durable(); configureSender(senderRegistry); theSender = JasperHost.For(senderRegistry); theSender.RebuildMessageStorage(); var receiverRegistry = new JasperOptions(); receiverRegistry.Extensions.UseMessageTrackingTestingSupport(); receiverRegistry.Handlers.DisableConventionalDiscovery() .IncludeType <TTriggerHandler>() .IncludeType <TItemCreatedHandler>() .IncludeType <QuestionHandler>() .IncludeType <ScheduledMessageHandler>(); receiverRegistry.Endpoints.ListenAtPort(receiverPort).Durable(); receiverRegistry.Extensions.UseMessageTrackingTestingSupport(); configureReceiver(receiverRegistry); theReceiver = JasperHost.For(receiverRegistry); theReceiver.RebuildMessageStorage(); initializeStorage(theSender, theReceiver); }
public DurableListener(IListeningAgent agent, IWorkerQueue queues, ITransportLogger logger, JasperOptions options, IEnvelopePersistence persistence) { _agent = agent; _queues = queues; _logger = logger; _options = options; _persistence = persistence; }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IConfiguration configuration, JasperOptions jasper) { jasper.ServiceName = configuration["name"]; var listener = $"{env.EnvironmentName}Listener"; jasper.ListenForMessagesFrom(configuration[listener]); }
public MessageRouter(IMessagingRoot root, HandlerGraph handlers) { _serializers = root.Serialization; _subscribers = root.Subscribers; _handlers = handlers; _logger = root.Logger; _settings = root.Options; _workers = _handlers.Workers; }
public MetricsCollector(IMetrics metrics, IEnvelopePersistor persistor, IMessageLogger logger, JasperOptions settings, IWorkerQueue workers) { _metrics = metrics; _persistor = persistor; _logger = logger; _settings = settings; _workers = workers; }
protected void with(Action <JasperOptions> configuration) { var registry = new JasperOptions(); configuration(registry); with(registry); }
private void assertNoUnknownTransportsInSubscribers(JasperOptions settings) { var unknowns = settings.Subscriptions.Where(x => !ValidTransports.Contains(x.Uri.Scheme)).ToArray(); if (unknowns.Length > 0) { throw new UnknownTransportException( $"Unknown transports referenced in {unknowns.Select(x => x.Uri.ToString()).Join(", ")}"); } }