Exemple #1
0
        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));
        }
Exemple #3
0
        public ApplicationInsightsMetrics(TelemetryClient client, MessagingSettings settings)
        {
            _client   = client;
            _settings = settings;

            _client.Context.Properties.Add("Node", settings.NodeId);
        }
Exemple #4
0
        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));
        }
Exemple #7
0
        // 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>();
        }
Exemple #8
0
        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;
        }
Exemple #9
0
 public given_a_sender_and_receiver()
 {
     using (var file = File.OpenRead("Settings.xml"))
     {
         this.settings = (MessagingSettings)serializer.Deserialize(file);
     }
 }
Exemple #10
0
 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)
  );
";
        }
Exemple #12
0
        // 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);
            }
        }
Exemple #13
0
 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);
 }
Exemple #14
0
 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));
        }
Exemple #16
0
        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)));
        }
Exemple #17
0
 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);
            }
        }
Exemple #19
0
        public EnvelopeTables(MessagingSettings settings, StoreOptions storeConfiguration)
        {
            Incoming = new DbObjectName(storeConfiguration.DatabaseSchemaName,
                                        PostgresqlEnvelopeStorage.IncomingTableName);
            Outgoing = new DbObjectName(storeConfiguration.DatabaseSchemaName,
                                        PostgresqlEnvelopeStorage.OutgoingTableName);

            CurrentNodeId = settings.UniqueNodeId;
        }
Exemple #20
0
        public HttpSenderProtocol(MessagingSettings settings)
        {
            _client = new HttpClient
            {
                Timeout = settings.Http.ConnectionTimeout
            };

            _settings = settings;
        }
Exemple #21
0
 public MessageRouter(IMessagingRoot root, HandlerGraph handlers)
 {
     _serializers = root.Serialization;
     _subscribers = root.Subscribers;
     _handlers    = handlers;
     _logger      = root.Logger;
     _settings    = root.Settings;
     _workers     = _handlers.Workers;
 }
Exemple #22
0
 public static MessagingSettingsViewData Create(MessagingSettings messagingSettings)
 {
     return(Create(
                messagingSettings.StudentMessagingEnabled,
                messagingSettings.StudentToClassMessagingOnly,
                messagingSettings.TeacherToStudentMessaginEnabled,
                messagingSettings.TeacherToClassMessagingOnly
                ));
 }
Exemple #23
0
 public MetricsCollector(IMetrics metrics, IEnvelopePersistor persistor, IMessageLogger logger,
                         MessagingSettings settings, IWorkerQueue workers)
 {
     _metrics   = metrics;
     _persistor = persistor;
     _logger    = logger;
     _settings  = settings;
     _workers   = workers;
 }
Exemple #24
0
        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);
        }
Exemple #26
0
 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;
 }
Exemple #27
0
        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}'";
        }
Exemple #28
0
 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;
 }
Exemple #29
0
        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}";
        }
Exemple #30
0
        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(", ")}");
            }
        }
Exemple #31
0
        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())
 {
 }