public void Start(IMessagingRoot root) { var settings = root.Settings; _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); }
protected override IListeningAgent buildListeningAgent(Uri uri, MessagingSettings settings) { var agent = _settings.For(uri); agent.Start(); return(agent.CreateListeningAgent(uri, settings, logger)); }
public ApplicationInsightsMetrics(TelemetryClient client, MessagingSettings settings) { _client = client; _settings = settings; _client.Context.Properties.Add("Node", settings.NodeId); }
public MessagingRoot(MessagingSerializationGraph serialization, MessagingSettings 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; } }
/// <summary> /// Initializes a new instance of the <see cref="TopicSender"/> class, /// automatically creating the given topic if it does not exist. /// </summary> protected TopicSender(MessagingSettings settings, string topic, RetryStrategy retryStrategy) { this.settings = settings; this.topic = topic; this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey); this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath); try { new NamespaceManager(this.serviceUri, this.tokenProvider) .CreateTopic( new TopicDescription(topic) { RequiresDuplicateDetection = true, DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(30) }); } catch (MessagingEntityAlreadyExistsException) { } // TODO: This could be injected. this.retryPolicy = new RetryPolicy<ServiceBusTransientErrorDetectionStrategy>(retryStrategy); this.retryPolicy.Retrying += (s, e) => { Trace.TraceError("An error occurred in attempt number {1} to send a message: {0}", e.LastException.Message, e.CurrentRetryCount); }; var factory = MessagingFactory.Create(this.serviceUri, this.tokenProvider); this.topicClient = factory.CreateTopicClient(this.topic); }
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 MessagingSettings(); 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)); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var connectionString = Configuration.GetConnectionString("DefaultConnection"); var migrationsAssembly = typeof(UsersDbContext).GetTypeInfo().Assembly.GetName().Name; services.AddDbContext <UsersDbContext>(options => options.UseSqlServer(connectionString)); services.AddAuthorization(); services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddJwtBearer(options => { options.Authority = Configuration.GetValue <string>("Authority"); options.Audience = "GraphQL.Users"; options.RequireHttpsMetadata = false; }); services.AddHttpContextAccessor(); services.AddGraphQL(sp => SchemaBuilder.New() .AddQueryType <Query>() .AddAuthorizeDirectiveType() .AddServices(sp) .Create()); var messagingSettings = new MessagingSettings(); Configuration.GetSection("MqttSetup").Bind(messagingSettings); services.AddSingleton <MessagingSettings>(messagingSettings); services.AddMqttClientProvider(messagingSettings); services.AddHostedService <MessagingService>(); }
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); } buildInitialSendingAgents(root); GetOrBuildChannel(TransportConstants.RetryUri); SystemReplyUri = capabilities.DefaultReceiverLocation ?? tryGetReplyUri("http") ?? tryGetReplyUri("tcp") ?? _transports.Values.FirstOrDefault(x => x.LocalReplyUri != null)?.LocalReplyUri; }
public given_a_sender_and_receiver() { using (var file = File.OpenRead("Settings.xml")) { this.settings = (MessagingSettings)serializer.Deserialize(file); } }
public TransportBase(string protocol, IDurableMessagingFactory factory, ITransportLogger logger, MessagingSettings settings) { _durableMessagingFactory = factory; this.logger = logger; MessagingSettings = settings; Protocol = protocol; }
public ReassignFromDormantNodes(EnvelopeTables marker, MessagingSettings 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) ); "; }
// 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 static void CreateTopic(this MessagingSettings settings, string topic) { new NamespaceManager( ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath), TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey)) .CreateTopic(topic); }
public NodeRegistration(MessagingSettings settings, INodeDiscovery nodes, JasperRuntime runtime, IMessageLogger logger) { _settings = settings; _nodes = nodes; _runtime = runtime; _logger = logger; }
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 static MessageReceiver CreateMessageReceiver(this MessagingSettings settings, string topic, string subscription) { var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey); var serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath); var messagingFactory = MessagingFactory.Create(serviceUri, tokenProvider); return(messagingFactory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(topic, subscription))); }
public HttpTransport(MessagingSettings settings, JasperRuntime runtime, IDurableMessagingFactory factory, ITransportLogger logger) { _settings = settings; _httpSettings = settings.Http; _runtime = runtime; _durableMessagingFactory = factory; _logger = logger; }
public void when_read_from_reader_then_succeeds() { using (var reader = XmlReader.Create("Settings.Template.xml")) { var settings = MessagingSettings.Read(reader); Assert.NotNull(settings); } }
public EnvelopeTables(MessagingSettings settings, StoreOptions storeConfiguration) { Incoming = new DbObjectName(storeConfiguration.DatabaseSchemaName, PostgresqlEnvelopeStorage.IncomingTableName); Outgoing = new DbObjectName(storeConfiguration.DatabaseSchemaName, PostgresqlEnvelopeStorage.OutgoingTableName); CurrentNodeId = settings.UniqueNodeId; }
public HttpSenderProtocol(MessagingSettings settings) { _client = new HttpClient { Timeout = settings.Http.ConnectionTimeout }; _settings = settings; }
public MessageRouter(IMessagingRoot root, HandlerGraph handlers) { _serializers = root.Serialization; _subscribers = root.Subscribers; _handlers = handlers; _logger = root.Logger; _settings = root.Settings; _workers = _handlers.Workers; }
public static MessagingSettingsViewData Create(MessagingSettings messagingSettings) { return(Create( messagingSettings.StudentMessagingEnabled, messagingSettings.StudentToClassMessagingOnly, messagingSettings.TeacherToStudentMessaginEnabled, messagingSettings.TeacherToClassMessagingOnly )); }
public MetricsCollector(IMetrics metrics, IEnvelopePersistor persistor, IMessageLogger logger, MessagingSettings settings, IWorkerQueue workers) { _metrics = metrics; _persistor = persistor; _logger = logger; _settings = settings; _workers = workers; }
public HttpSettings(MessagingSettings settings) { _methodFilters = new ActionMethodFilter(); _methodFilters.Excludes += m => m.Name == "Configure"; _transport = settings.Http; IncludeClassesSuffixedWithEndpoint(); }
public SqlServerBackedDurableMessagingFactory(SqlServerSettings sqlServerSettings, ITransportLogger logger, MessagingSettings settings) { Settings = settings; _sqlServerSettings = sqlServerSettings; _logger = logger; _persistor = new SqlServerEnvelopePersistor(sqlServerSettings); _retries = new EnvelopeRetries(_persistor, logger, settings); }
public DurableListener(IListeningAgent agent, IWorkerQueue queues, ITransportLogger logger, MessagingSettings settings, IRetries retries, IEnvelopePersistor persistor) { _agent = agent; _queues = queues; _logger = logger; _settings = settings; _retries = retries; _persistor = persistor; }
public RecoverIncomingMessages(IWorkerQueue workers, MessagingSettings settings, SqlServerSettings mssqlSettings, ITransportLogger logger) { _workers = workers; _settings = settings; _mssqlSettings = mssqlSettings; _logger = logger; _findAtLargeEnvelopesSql = $"select top {settings.Retries.RecoveryBatchSize} body from {mssqlSettings.SchemaName}.{SqlServerEnvelopePersistor.IncomingTable} where owner_id = {TransportConstants.AnyNode} and status = '{TransportConstants.Incoming}'"; }
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 RecoverIncomingMessages(IWorkerQueue workers, MessagingSettings settings, EnvelopeTables marker, ITransportLogger logger) { _workers = workers; _settings = settings; _marker = marker; _logger = logger; _findAtLargeEnvelopesSql = $"select body from {marker.Incoming} where owner_id = {TransportConstants.AnyNode} and status = '{TransportConstants.Incoming}' limit {settings.Retries.RecoveryBatchSize}"; }
private void assertNoUnknownTransportsInSubscribers(MessagingSettings settings) { var unknowns = settings.KnownSubscribers.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(", ")}"); } }
private void assertNoUnknownTransportsInListeners(MessagingSettings settings) { var unknowns = settings.Listeners.Where(x => !ValidTransports.Contains(x.Scheme)).ToArray(); if (unknowns.Any()) { throw new UnknownTransportException( $"Unknown transports referenced in listeners: {unknowns.Select(x => x.ToString()).Join(", ")}"); } }
public TestableSubscriptionReceiver(MessagingSettings settings, string topic, string subscription, RetryStrategy background, RetryStrategy blocking) : base(settings, topic, subscription, background, blocking) { this.DoReceiveMessageDelegate = base.DoReceiveMessage; }
public given_a_sender_and_receiver() { this.settings = InfrastructureSettings.ReadMessaging("Settings.xml"); }
/// <summary> /// Initializes a new instance of the <see cref="TopicSender"/> class, /// automatically creating the given topic if it does not exist. /// </summary> public TopicSender(MessagingSettings settings, string topic) : this(settings, topic, GetRetryStrategy()) { }