public void DefaultSerializersAdded_WhenNotSpecifiedByHost() { var settings = new BrokerSettings(); var mockExchange = new Mock <IMessageBroker>(); MessageBrokerState brokerConfig = null; mockExchange.Setup(b => b.Initialize(It.IsAny <MessageBrokerState>())) .Callback <MessageBrokerState>(cfg => brokerConfig = cfg); ModuleTest.Arrange(config => { config.AddPlugin <MockAppHostPlugin>(); }) .Act(c => { AddTestMocks(c, settings, mockExchange.Object); c.Build().Start(); }); #if NETCOREAPP1_0 brokerConfig.SerializationMgr.Serializers.Should().HaveCount(1); brokerConfig.SerializationMgr.Serializers.Select(s => s.ContentType).Should().Contain(SerializerTypes.Json); #endif #if NET461 brokerConfig.SerializationMgr.Serializers.Should().HaveCount(3); brokerConfig.SerializationMgr.Serializers.Select(s => s.ContentType).Should().Contain(SerializerTypes.Json); brokerConfig.SerializationMgr.Serializers.Select(s => s.ContentType).Should().Contain(SerializerTypes.Binary); brokerConfig.SerializationMgr.Serializers.Select(s => s.ContentType).Should().Contain(SerializerTypes.MessagePack); #endif }
public static void AddAdminQueueListener(this IServiceCollection services, IConfiguration configuration) { var listenerSection = configuration.GetSection("Queue").GetSection("Listener"); var brokerSection = configuration.GetSection("Queue").GetSection("Broker"); var queueSettings = new ReceiverSettings { Queue = listenerSection["Queue"], Durable = bool.Parse(listenerSection["Durable"]), AutoAck = bool.Parse(listenerSection["AutoAck"]), Exchange = listenerSection["Exchange"], ExchangeType = listenerSection["ExchangeType"], Keys = listenerSection["RoutingKeys"]?.Split(';')?.ToList() }; var brokerSettings = new BrokerSettings { Host = brokerSection["Host"], Port = int.Parse(brokerSection["Port"]), User = brokerSection["User"], Password = brokerSection["Password"] }; services.AddScoped(typeof(IRepository <>), typeof(EfRepository <>)); services.AddSingleton(brokerSettings); services.AddSingleton(queueSettings); services.AddHostedService <AdminQueueListener>(); }
public SmcTicketThread(SmcDto smcDto, ClientSettings clientSettings, BrokerSettings brokerSettings, IMqttClientConfiguration mqttClientConfiguration, IMqttClientMethods mqttClientMethods, Topic topic, CommandRules commandRules, IEventService eventService, IForwarderSenderService forwarderSenderService) { Smc = smcDto; _eventService = eventService; _forwarderSenderService = forwarderSenderService; Tickets = new ConcurrentPriorityQueue <TicketThreadObject>(); _executingCommandSemaphore = new SemaphoreSlim(1, 1); _waitingCommandMessageSemaphore = new SemaphoreSlim(1, 1); _answerSemaphore = new SemaphoreSlim(1, 1); var localClientSettings = new ClientSettings { ClientId = clientSettings.ClientId, ClientName = clientSettings.ClientName }; localClientSettings.ClientId = localClientSettings.ClientId.Replace("serial", smcDto.Serial); localClientSettings.ClientName = localClientSettings.ClientName.Replace("serial", smcDto.Serial); localClientSettings.DebugMode = clientSettings.DebugMode; localClientSettings.AutoReconnectDelayInSeconds = clientSettings.AutoReconnectDelayInSeconds; var localTopic = new Topic { Address = topic.Address, QoS = topic.QoS }; localTopic.Address = localTopic.Address .Replace("{smc-or-meter}", CommandDeviceType.Smc.ToString().ToLower()) .Replace("{serial}", smcDto.Serial); _mqttClient = new IoGMqttClient(localClientSettings, brokerSettings, mqttClientConfiguration, mqttClientMethods); _mqttClient.Subscribe(localTopic); _mqttClient.MessageReceivedHandler += ReceivedUpdate; _commandRules = commandRules; }
public void SettingsBrokerName_MustBeUnique() { var settings = new BrokerSettings(); var mockExchange = new Mock <IMessageBroker>(); settings.Connections = new List <BrokerConnectionSettings> { new BrokerConnectionSettings { BrokerName = "Broker1" }, new BrokerConnectionSettings { BrokerName = "Broker1" } }; ModuleTest.Arrange(config => { config.AddPlugin <MockAppHostPlugin>(); }) .Test(c => { AddTestMocks(c, settings, mockExchange.Object); c.Build().Start(); }, (c, e) => { e.Should().BeOfType <ContainerException>(); }); }
// -------------------------- UNIT-TEST SETUP ------------------------------------------- // Returns a test setup containing a configured MessageBrokerState instance and mocked // ConnectionManager. This simulates the state built by the MessageBrokerModule that is // used to initialize a MessageBroker instance and passed to the internal initialization // classes to which it delegates. public static BrokerStateSetup SetupBrokerState(BrokerSettings brokerSettings = null) { var serializer = new JsonBrokerSerializer(); var brokerState = new MessageBrokerState { BrokerSettings = brokerSettings ?? new BrokerSettings { Connections = new List <BrokerConnectionSettings> { new BrokerConnectionSettings { BrokerName = "MockTestBrokerName", HostName = "TestHost" } } } }; var serializers = new Dictionary <string, IBrokerSerializer> { { serializer.ContentType, serializer } }; var mockConnMgr = new MockConnectionManager( new TestLoggerFactory(), brokerState.BrokerSettings, new Dictionary <string, object>()); brokerState.ConnectionMgr = mockConnMgr; brokerState.SerializationMgr = new SerializationManager(serializers); return(new BrokerStateSetup { BrokerState = brokerState, MockConnMgr = mockConnMgr }); }
public static void AddIntegrations(this IServiceCollection services, IConfiguration configuration) { var senderSection = configuration.GetSection("Integration").GetSection("Sender"); var brokerSection = configuration.GetSection("Integration").GetSection("Broker"); bool.TryParse(senderSection["Durable"], out var durable); var queueSettings = new SenderSettings { Queue = senderSection["Queue"], Durable = durable, ExchangeType = senderSection["ExchangeType"], Exchange = senderSection["Exchange"] }; var brokerSettings = new BrokerSettings { Host = brokerSection["Host"], Port = int.Parse(brokerSection["Port"]), User = brokerSection["User"], Password = brokerSection["Password"] }; services.AddScoped((provider) => { return(new QueueSender(queueSettings, brokerSettings)); }); services.AddScoped <AdministrationNotifier>(); services.AddScoped <GivingPromoCodeToCustomerNotifier>(); }
private void InitializeExchanges(BrokerSettings brokerSettings) { foreach (IMessageExchange exchange in Exchanges) { exchange.InitializeSettings(brokerSettings); } }
/// <summary> /// Initializes a new instance of the <see cref="HarmonyMqttService"/> class. /// </summary> /// <param name="logger">Logging instance.</param> /// <param name="harmonyClient">The Harmony client.</param> /// <param name="harmonyName">The Harmony name.</param> /// <param name="harmonyKeyPressLength">The Harmony key press length.</param> /// <param name="brokerSettings">MQTT broker settings.</param> public HarmonyMqttService( ILogger <HarmonyMqttService> logger, IClient harmonyClient, string harmonyName, int harmonyKeyPressLength, BrokerSettings brokerSettings) : base(logger, brokerSettings, "harmony/" + harmonyName) { _log = logger; _topicActionMap = new Dictionary <string, string>(); SubscribedTopics.Add(TopicRoot + "/devices/+/+/+/set"); SubscribedTopics.Add(TopicRoot + "/activity/set"); SubscribedTopics.Add(TopicRoot + "/activity/+/set"); // Setup harmony client _client = harmonyClient; _harmonyName = harmonyName; _harmonyKeyPressLength = harmonyKeyPressLength; _client.CurrentActivityUpdated += Harmony_CurrentActivityUpdated; // Harmony client logging _client.MessageSent += (object sender, MessageSentEventArgs e) => { _log.LogInformation("Harmony Message sent: " + e.Message); }; _client.MessageReceived += (object sender, MessageReceivedEventArgs e) => { _log.LogInformation("Harmony Message received: " + e.Message); }; _client.Error += (object sender, System.IO.ErrorEventArgs e) => { var exception = e.GetException(); _log.LogError(exception, exception.Message); throw new Exception("Harmony connection lost"); }; }
public BrokerService(IOptions <BrokerSettings> settings, ISubscriptionsService subscriptionsService, ILogger <BrokerService> logger) { this.settings = settings.Value; this.subscriptionsService = subscriptionsService; this.logger = logger; this.statisticsDataSender = new DataSender <ItemModel>(this.settings.StatisticsUrl); }
public void ExchangeDefinitions_Discovered() { var settings = new BrokerSettings(); var mockExchange = new Mock <IMessageBroker>(); MessageBrokerState brokerState = null; mockExchange.Setup(b => b.Initialize(It.IsAny <MessageBrokerState>())) .Callback <MessageBrokerState>(s => brokerState = s); // Define the broker connection and an externally defined queue route key. settings.Connections = new List <BrokerConnectionSettings> { new BrokerConnectionSettings { BrokerName = "MockTestBrokerName", QueueProperties = new QueuePropertiesSettings[] { new QueuePropertiesSettings { QueueName = "MockTestQueueName", RouteKeys = new [] { "RouteKeyTwo" } } } } }; ModuleTest.Arrange(config => { config.AddPlugin <MockAppHostPlugin>() .AddPluginType <MockTopicExchange>() .AddPluginType <MockExchange>(); }) .Act(c => { c.WithConfig((MessagingConfig config) => { config.AddMessagePublisher <RabbitMqMessagePublisher>(); }); AddTestMocks(c, settings, mockExchange.Object); c.Build().Start(); }); // Verify that module initialized the message broker with the exchanges: brokerState.Should().NotBeNull(); brokerState.BrokerSettings.Should().NotBeNull(); brokerState.Exchanges.Should().NotBeNull(); // metadata.Connections.Should().NotBeNull(); // Verify that the correct exchanges were determined. brokerState.Exchanges.Should().HaveCount(2); brokerState.Exchanges.Should().Contain(e => e.ExchangeName == "MockDirectExchangeName"); brokerState.Exchanges.Should().Contain(e => e.ExchangeName == "MockTopicExchangeName"); // Verify that the externally defined route key was added to the queue: var directExchange = brokerState.Exchanges.First(e => e.ExchangeName == "MockDirectExchangeName"); var queue = directExchange.Queues.FirstOrDefault(); queue.Should().NotBeNull(); queue.RouteKeys.Should().HaveCount(1); queue.RouteKeys.Should().Contain(k => k == "RouteKeyTwo"); }
private static async Task Main() { await new HostBuilder() .ConfigureAppConfiguration((hostContext, builder) => { builder .SetBasePath(Environment.CurrentDirectory) .AddJsonFile("appsettings.json") .AddEnvironmentVariables(); }) .ConfigureServices((hostContext, services) => { var brokerSettings = new BrokerSettings(); hostContext.Configuration.GetSection("RabbitSettings").Bind(brokerSettings); services.AddSingleton <IConsumer <IMoveReservedLimitAmountToRegularAccount>, MoveReservedLimitAmountToRegularAccountConsumer>(); services.AddMassTransit(configure => { configure.AddConsumer <MoveReservedLimitAmountToRegularAccountConsumer>(); configure.AddBus(provider => Bus.Factory.CreateUsingRabbitMq(configureBus => { var hostBus = configureBus.Host(new Uri(brokerSettings.Host), configureHost => { configureHost.Username(brokerSettings.User); configureHost.Password(brokerSettings.Password); }); configureBus.ReceiveEndpoint(hostBus, brokerSettings.InputQueue, configureEndpoint => { configureEndpoint.Consumer <MoveReservedLimitAmountToRegularAccountConsumer>(provider); }); //configureBus.ConfigureEndpoints(provider); configureBus.UseSerilog(); //configureBus.UseInMemoryOutbox(); //configureBus.MessageTopology.SetEntityNameFormatter(new CustomEntityFormatter("bankdeposit")); })); //configure.AddRequestClient<IAnalyzeBankDepositTransactionRequest>(); }); services.AddMassTransitHostedService(); }) .ConfigureLogging((hostContext, configLogging) => { configLogging .AddSerilog() .AddConsole() .AddDebug() .SetMinimumLevel(LogLevel.Debug); }) .UseConsoleLifetime() .Build().StartAsync(); }
// Called by Message Broker when defining exchanges and allows a // specific declared application exchange to specific its settings. public void InitializeSettings(BrokerSettings brokerSettings) { SetOptionalScriptSettings(); OnDeclareExchange(); OnApplyConventions(); brokerSettings.ApplyQueueSettings(this); ValidateConfiguration(); }
public static void PreStart() { if (!BrokerSettings.IsValid()) { return; } AppDomain.CurrentDomain.AssemblyResolve += Broker_AssemblyResolve; Assembly.LoadFrom(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, $"broker/{BrokerSettings.Default.Version}/NVShop.Data.eNVenta.dll")); }
public MockConnectionManager( ILoggerFactory logger, BrokerSettings brokerSettings, IDictionary <string, object> clientProperties) : base(logger, brokerSettings, clientProperties) { this.MockConn = new Mock <IConnection>(); this.MockChannel = new Mock <IModel>(); this.MockConn.Setup(c => c.CreateModel()) .Returns(MockChannel.Object); }
public void MessageConsumers_Determined() { var settings = new BrokerSettings(); var mockExchange = new Mock <IMessageBroker>(); IEnumerable <MessageConsumer> consumers = null; mockExchange.Setup(b => b.BindConsumers(It.IsAny <IEnumerable <MessageConsumer> >())) .Callback <IEnumerable <MessageConsumer> >(mc => consumers = mc); // Define the broker connection and an externally defined queue route key. settings.Connections = new List <BrokerConnectionSettings> { new BrokerConnectionSettings { BrokerName = "MockTestBrokerName" } }; ModuleTest.Arrange(config => { // Add an exchange definition and consumer service. config.AddPlugin <MockAppHostPlugin>() .AddPluginType <MockExchange>() .AddPluginType <MockMessageConsumer>(); }) .Act(c => { c.WithConfig((MessagingConfig config) => { config.AddMessagePublisher <RabbitMqMessagePublisher>(); }); AddTestMocks(c, settings, mockExchange.Object); c.Build().Start(); }); consumers.Should().NotBeNull(); consumers.Should().HaveCount(2); // Verify that the consumer event hander that is joining an existing queue on the exchange. var joinedConsumer = consumers.FirstOrDefault(c => c.BindingType == QueueBindingTypes.Join); joinedConsumer.Should().NotBeNull(); joinedConsumer.ExchangeName.Should().Be("MockDirectExchangeName"); joinedConsumer.QueueName.Should().Be("MockTestQueueName"); // Verify the consumer event handler that is creating an exclusive queue on the exchange. var addConsumer = consumers.FirstOrDefault(c => c.BindingType == QueueBindingTypes.Create); addConsumer.Should().NotBeNull(); addConsumer.ExchangeName.Should().Be("MockDirectExchangeName"); addConsumer.QueueName.Should().BeEmpty(); // The server will assign name. }
public void ExchangeBrokerNameNotConfigured_Exception() { var emptySettings = new BrokerSettings(); var stateSetup = BrokerTest.SetupBrokerState(emptySettings); var brokerSetup = BrokerTest.SetupMessageBroker(); var exchange = new MockExchange(); exchange.InitializeSettings(emptySettings); stateSetup.BrokerState.Exchanges = new[] { exchange }; stateSetup.BrokerState.BrokerSettings.Connections.Clear(); Assert.Throws <BrokerException>(() => brokerSetup.Initialize(stateSetup.BrokerState)); }
public ConnectionManager( ILoggerFactory loggerFactory, BrokerSettings brokerSettings, IDictionary <string, object> clientProperties) { Check.NotNull(loggerFactory, nameof(loggerFactory)); Check.NotNull(brokerSettings, nameof(brokerSettings)); Check.NotNull(clientProperties, nameof(clientProperties)); _logger = loggerFactory.CreateLogger <ConnectionManager>(); _brokerSettings = brokerSettings; _clientProperties = clientProperties; _connections = GetConnections(brokerSettings); }
/// <summary> /// Initializes a new instance of the <see cref="NeatoMqttService"/> class. /// </summary> /// <param name="logger">Logging instance.</param> /// <param name="neatoClient">Neato client.</param> /// <param name="neatoName">Neato name.</param> /// <param name="refreshInterval">Refresh interval.</param> /// <param name="brokerSettings">MQTT broker settings.</param> public NeatoMqttService( ILogger <NeatoMqttService> logger, IRobot neatoClient, string neatoName, int refreshInterval, BrokerSettings brokerSettings) : base(logger, brokerSettings, "neato/" + neatoName) { _log = logger; _refreshInterval = refreshInterval * 1000; SubscribedTopics.Add(TopicRoot + "/+/set"); _client = neatoClient; }
/// <summary> /// Initializes a new instance of the <see cref="EcobeeMqttService"/> class. /// </summary> /// <param name="logger">Logging instance.</param> /// <param name="ecobeeClient">The Ecobee client.</param> /// <param name="ecobeeName">The target Ecobee name.</param> /// <param name="refreshInterval">The refresh interval.</param> /// <param name="brokerSettings">MQTT broker settings.</param> public EcobeeMqttService( ILogger <EcobeeMqttService> logger, Client ecobeeClient, string ecobeeName, int refreshInterval, BrokerSettings brokerSettings) : base(logger, brokerSettings, "ecobee/" + ecobeeName) { _log = logger; _refreshInterval = refreshInterval * 1000; SubscribedTopics.Add(TopicRoot + "/+/+/set"); _client = ecobeeClient; _revisionStatusCache = new Dictionary <string, RevisionStatus>(); _thermostatStatus = new Dictionary <string, ThermostatStatus>(); }
/// <summary> /// Initializes a new instance of the <see cref="ApexMqttService"/> class. /// </summary> /// <param name="logger">Logging instance.</param> /// <param name="apexClient">Apex client.</param> /// <param name="apexName">Apex name.</param> /// <param name="refreshInterval">Refresh interval.</param> /// <param name="publishOnlyChangedValues">Only publish values when they change from previous value.</param> /// <param name="brokerSettings">MQTT broker settings.</param> public ApexMqttService( ILogger <ApexMqttService> logger, Client apexClient, string apexName, int refreshInterval, bool publishOnlyChangedValues, BrokerSettings brokerSettings) : base(logger, brokerSettings, "apex/" + apexName) { _log = logger; _refreshInterval = refreshInterval * 1000; _publishOnlyChangedValues = publishOnlyChangedValues; SubscribedTopics.Add(TopicRoot + "/outlets/+/set"); SubscribedTopics.Add(TopicRoot + "/feedCycle/set"); _client = apexClient; }
public ThreadService(IMqttClientMethods mqttClientMethods, IMqttClientConfiguration mqttClientConfiguration, IOptions <Forwarder> forwarderConfig, IServiceProvider serviceProvider, ISmcService smcService, IOptions <CommandRules> commandRules, IEventService eventService, IForwarderSenderService forwarderSenderService, IMeterService meterService) { _mqttClientConfiguration = mqttClientConfiguration; _mqttClientMethods = mqttClientMethods; _brokerSettings = forwarderConfig.Value.Mqtt.BrokerSettings; _baseClientSettings = forwarderConfig.Value.Mqtt.CommandsBaseClientSettings; _subscribeTopic = forwarderConfig.Value.Mqtt.BaseCommandsSubscribeTopic; _smcService = smcService; _commandRules = commandRules.Value; _eventService = eventService; _eventService.AThreadIsShuttingDown += AThreadIsShuttingDown; _forwarderSenderService = forwarderSenderService; _meterService = meterService; }
// Sets mock broker settings and mock message broker. These specified instances will be // registered overriding the default instances. private ContainerTest AddTestMocks(IAppContainer container, BrokerSettings settings, IMessageBroker broker) { container.WithConfig <AutofacRegistrationConfig>(config => { config.Build = builder => { builder.RegisterInstance(settings) .As <BrokerSettings>() .SingleInstance(); builder.RegisterInstance(broker) .As <IMessageBroker>() .SingleInstance(); }; }); return(new ContainerTest((AppContainer)container)); }
public CommandThread(MeterDto meterDto, ClientSettings clientSettings, BrokerSettings brokerSettings, IMqttClientConfiguration mqttClientConfiguration, IMqttClientMethods mqttClientMethods, Topic topic, IServiceProvider serviceProvider, CommandRules commandRules) { MeterDto = meterDto; _mutex = new Semaphore(0, 10000); _answeredSemaphore = new Semaphore(1, 1); _commandQueue = new ConcurrentQueue <Command>(); _serviceProvider = serviceProvider; _commandRules = commandRules; clientSettings.ClientId = clientSettings.ClientId.Replace("serial", meterDto.Serial); clientSettings.ClientName = clientSettings.ClientName.Replace("serial", meterDto.Serial); topic.Address = topic.Address.Replace("{smc-or-meter}", "meter").Replace("{serial}", meterDto.Serial); _mqttClient = new IoGMqttClient(clientSettings, brokerSettings, mqttClientConfiguration, mqttClientMethods); _mqttClient.Subscribe(topic); _mqttClient.MessageReceivedHandler += ReceivedCommandAnswer; }
private IDictionary <string, BrokerConnection> GetConnections(BrokerSettings settings) { if (settings.Connections == null) { return(new Dictionary <string, BrokerConnection>()); } IEnumerable <string> duplicateBrokerNames = settings.Connections .WhereDuplicated(c => c.BrokerName); if (duplicateBrokerNames.Any()) { throw new BrokerException( $"The following broker names are specified more than " + $"once: {String.Join(", ", duplicateBrokerNames)}."); } return(settings.Connections .Select(s => new BrokerConnection(s)) .ToDictionary(c => c.Settings.BrokerName)); }
public static void AddMassTransitWithRabbitMq(this IServiceCollection services, IConfiguration configuration) { BankDepositSaga = configuration.GetSection("SagasSettings").GetSection("BankDepositSaga").GetChildren() .Select(item => new KeyValuePair <string, string>(item.Key, item.Value)) .ToDictionary(x => x.Key, x => x.Value); var brokerSettings = new BrokerSettings(); configuration.GetSection("BrokerSettings").Bind(brokerSettings); services.AddSingleton <BankDepositTransactionStateMachine>(); services.AddSingleton <ISagaRepository <BankDepositTransactionSaga>, InMemorySagaRepository <BankDepositTransactionSaga> >(); services.AddMassTransit(configure => { configure.AddSaga <BankDepositTransactionSaga>(); configure.AddBus(provider => Bus.Factory.CreateUsingRabbitMq(configureBus => { var host = configureBus.Host(new Uri(brokerSettings.Host), configureHost => { configureHost.Username(brokerSettings.User); configureHost.Password(brokerSettings.Password); }); configureBus.ReceiveEndpoint(host, brokerSettings.InputQueue, configureEndpoint => { var machine = provider.GetService <BankDepositTransactionStateMachine>(); var repository = provider.GetService <ISagaRepository <BankDepositTransactionSaga> >(); configureEndpoint.StateMachineSaga(machine, repository); }); //configureBus.UseInMemoryOutbox(); configureBus.UseSerilog(); //configureBus.MessageTopology.SetEntityNameFormatter(new CustomEntityFormatter("bankdeposit")); })); }); services.AddMassTransitHostedService(); }
/// <summary> /// Initializes a new instance of the <see cref="MqttService"/> class. /// </summary> /// <param name="logger">Logging instance.</param> /// <param name="messageHub">Message hub.</param> /// <param name="brokerSettings">MQTT broker settings.</param> /// <param name="deviceRepository">Device repository.</param> /// <param name="stateCache">State cache,</param> public MqttService( ILogger <MqttService> logger, IMessageHub messageHub, BrokerSettings brokerSettings, IGoogleDeviceRepository deviceRepository, StateCache stateCache) : base(logger, brokerSettings, "google/home") { _log = logger ?? throw new ArgumentException(nameof(logger)); _messageHub = messageHub ?? throw new ArgumentException(nameof(messageHub)); _deviceRepository = deviceRepository ?? throw new ArgumentException(nameof(deviceRepository)); _stateCache = stateCache ?? throw new ArgumentException(nameof(stateCache)); // Subscribe to google home based topics SubscribedTopics.Add(TopicRoot + "/#"); // Subscribe to all monitored state topics foreach (var topic in _stateCache.Keys) { SubscribedTopics.Add(topic); } }
public void ExchangesDecared_RabbitMqPublisher_MustBeRegistered() { var settings = new BrokerSettings(); var mockExchange = new Mock <IMessageBroker>(); ModuleTest.Arrange(config => { config.AddPlugin <MockAppHostPlugin>() .AddPluginType <MockDirectExchange>(); }) .Test(c => { AddTestMocks(c, settings, mockExchange.Object); c.Build().Start(); }, (c, e) => { c.GetTestLogger() .HasSingleEntryFor(RabbitMqLogEvents.BROKER_CONFIGURATION, LogLevel.Warning) .Should().BeTrue(); }); }
/// <summary> /// Initializes a new instance of the <see cref="TiVoMqttService"/> class. /// </summary> /// <param name="logger">Logging instance.</param> /// <param name="tivoClient">TiVo client.</param> /// <param name="tivoName">TiVo name.</param> /// <param name="brokerSettings">MQTT broker settings.</param> public TiVoMqttService( ILogger <TiVoMqttService> logger, IClient tivoClient, string tivoName, BrokerSettings brokerSettings) : base(logger, brokerSettings, "tivo/" + tivoName) { _log = logger; SubscribedTopics.Add(TopicRoot + "/controls/+/set"); _client = tivoClient; _client.EventReceived += TiVo_EventReceived; // TiVo client logging _client.MessageSent += (object sender, MessageSentEventArgs e) => { _log.LogInformation("TiVo Message sent: " + e.Message); }; _client.MessageReceived += (object sender, MessageReceivedEventArgs e) => { _log.LogInformation("TiVo Message received: " + e.Message); }; _client.Error += (object sender, System.IO.ErrorEventArgs e) => { var exception = e.GetException(); _log.LogError(exception, exception.Message); System.Environment.Exit(1); }; }
/// <summary> /// Registers the type mappings with the Unity container. /// </summary> /// <param name="container">The unity container to configure.</param> /// <remarks> /// There is no need to register concrete types such as controllers or /// API controllers (unless you want to change the defaults), as Unity /// allows resolving a concrete type even if it was not previously /// registered. /// </remarks> public static void RegisterTypes(IUnityContainer container) { var typeFinder = new WebAppTypeFinder(); container.RegisterInstance <ITypeFinder>(typeFinder); // Exclude FS-Dependencies if Broker-Path is not set if (!BrokerSettings.IsValid()) { typeFinder.AssemblySkipLoadingPattern += "|NVShop.Data.FS|NVShop.Data.eNVenta"; } var types = typeFinder.FindClassesOfType <IDependencyRegistrar>(); var instances = types.Select(Activator.CreateInstance) .Cast <IDependencyRegistrar>() .OrderBy(t => t.Order) .ToList(); foreach (var instance in instances) { instance.Register(container); } }
// Creates the message broker that initializes the exchanges and // determines the queues that should be created. public override void StartModule(IContainer container, ILifetimeScope scope) { _brokerSettings = GetBrokerSettings(scope); _connManager = CreateConnectionManager(); _messageBroker = scope.Resolve <IMessageBroker>(); _messageConsumers = GetQueueConsumers(scope); InitializeExchanges(_brokerSettings); _messageBroker.Initialize(new MessageBrokerState { ConnectionMgr = _connManager, SerializationMgr = CreateSerializationManager(), BrokerSettings = _brokerSettings, Exchanges = Exchanges, RpcTypes = GetRpcCommandTypes() }); _messageBroker.ConfigurePublishers(); _messageBroker.BindConsumers(_messageConsumers); SaveExchangeMetadata(scope); }