예제 #1
0
        // stop message publisher
        public async Task <IComponentHostServiceResponse <IMessagePublisherSettings> > StopMessagePublisherAsync()
        {
            var response = new ComponentHostServiceResponse <IMessagePublisherSettings>();

            using (_logger.BeginScope("{Correlation}", HostInstanceId))
            {
                if (MessagePublisher is null)
                {
                    response.Set(MemberState.Error, "MessagePublisher not configured");
                }
                else
                {
                    try
                    {
                        await MessagePublisher.StopAsync(CancellationToken.None);

                        response.Result = _messagePublisherSettings;
                    }
                    catch (Exception e)
                    {
                        _logger.LogError(e, "{Message} {@ObjectProperties}", "Failed to Stop MessagePublisher", Component);
                        HostState = HostState.Errored;
                        response.Set(MemberState.Error, "MessagePublisher failed to Stop");
                    }
                }
            }

            return(response);
        }
예제 #2
0
		static void Main(string[] args)
		{
			int max = 50;
			CountdownEvent cd = new CountdownEvent(max);

			string endPoint = "tcp://localhost:5557";
			System.Console.WriteLine("Publishing on {0}\n", endPoint);

			const string topic = "TestTopicxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

			{
				var publisher = new MessagePublisher<IMessage>("tcp://localhost:5557",
					new ProtoBufMessageSerializer(),
					topic);

				for (int i = 0; i < max; i++)
				{
					publisher.PublishAsync(new Message1AndItIs32CharactersLongForSureDefinitionForSure()
					{
						Id = i
					});

					Thread.Sleep(TimeSpan.FromSeconds(0.5));
					System.Console.WriteLine("Published: {0}", i);
				}
			}

			System.Console.WriteLine("[finished - any key to continue]");
			System.Console.ReadKey();
		}
예제 #3
0
 static void Main(string[] args)
 {
     libs = new StorageController();
     mPub = new MessagePublisher();
     libs.GetLibrary(URL);
     libs.CreateBook();
     mPub.MainAsync().GetAwaiter().GetResult();
 }
예제 #4
0
        public void PubSub()
        {
            var pub = new MessagePublisher(9200);
            var sub = new MessageSubscriber("localhost", 9200);

            pub.Close();
            sub.Close();
        }
        public void TestMethod1()
        {
            var subscribeTask = new Task(ProcessMessagesFromQueue);

            subscribeTask.Start();

            MessagePublisher.PublishApplicationMessage("test topic", "message");
        }
        void Publish <T>()
        {
            var type = typeof(T);

            MessagePublisher.Publish(new TransportMessage {
                CorrelationId = type.FullName
            }, new[] { type });
        }
예제 #7
0
        private static (Mock <IServiceProvider> mockServiceProvider, MessagePublisher uut) BuildTestContext()
        {
            var mockServiceProvider = new Mock <IServiceProvider>();

            var uut = new MessagePublisher(mockServiceProvider.Object);

            return(mockServiceProvider, uut);
        }
 public TestQueue(ILogger <MessagePublisher> publisherLogger, ILogger <MessageConsumer> consumerLogger)
 {
     _sqs             = TestConfig.Config.GetAWSOptions("AWS_SQS").CreateServiceClient <IAmazonSQS>();
     _sns             = TestConfig.Config.GetAWSOptions("AWS_SNS").CreateServiceClient <IAmazonSimpleNotificationService>();
     _messageOptions  = TestConfig.Config.Get <MessageServiceOptions>();
     MessagePublisher = new MessagePublisher(Options.Create(_messageOptions), publisherLogger, _sns);
     MessageConsumer  = new MessageConsumer(Options.Create(_messageOptions), consumerLogger, _sqs, new NLogContext(), new List <ITypedHandler>(), _messageHistory);
 }
예제 #9
0
 private void PingAppLauncherLoop()
 {
     while (true)
     {
         MessagePublisher.PingAppLauncher();
         Task.Delay(1000).Wait();
     }
 }
예제 #10
0
 public void onPublisher(Post post)
 {
     MessagePublisher?.Invoke(this,
                              new PostMessageEventArgs {
         Post = new Post {
             Message = post.Message
         }
     });
 }
예제 #11
0
        void Publish(TransportMessage messageToSend, PublishOptions publishOptions)
        {
            if (MessagePublisher == null)
            {
                throw new InvalidOperationException("No message publisher has been registered. If you're using a transport without native support for pub/sub please enable the message driven publishing feature by calling config.EnableFeature<MessageDrivenSubscriptions>() in your configuration");
            }

            MessagePublisher.Publish(messageToSend, publishOptions);
        }
        public void OneTimeSetUp()
        {
            var hostName     = "localhost";
            var exchangeName = "";
            var queueName    = "hello";

            Consumer  = new MessageConsumer(hostName, queueName);
            Publisher = new MessagePublisher(hostName, exchangeName, queueName);
        }
예제 #13
0
        static void Main(string[] args)
        {
            users = new UserController();
            mPub  = new MessagePublisher();

            users.GetLibrary(URL);

            mPub.MainAsync().GetAwaiter().GetResult();
        }
예제 #14
0
 public RestaurantService(
     MongoDbManager mgr, IMenuService menuService, MessagePublisher publisher,
     IHubContext <RestaurantHub> restaurantHub, RestaurantConnections restaurantConnections)
 {
     _restaurants           = mgr.Restaurants;
     _menuService           = menuService;
     _publisher             = publisher;
     _restaurantHub         = restaurantHub;
     _restaurantConnections = restaurantConnections;
 }
        public void OneTimeSetUp()
        {
            var hostName     = "localhost";
            var exchangeName = "";
            var queueName    = "hello";

            AutoConsumer    = new AutoMessageConsumer(hostName, queueName);
            _publisher      = new MessagePublisher(hostName, exchangeName, queueName);
            _autoResetEvent = new AutoResetEvent(false);
        }
 public static IServiceCollection UseHangfireMessagePublisher(
     this IServiceCollection services,
     Action <IMessagePublisherConfigurator> configure)
 => services.AddSingleton <IMessagePublisher>(
     o =>
 {
     var publisher = new MessagePublisher(o.GetService <IBackgroundJobClient>());
     configure?.Invoke(publisher);
     return(publisher);
 });
예제 #17
0
        public void Monitor_publishes_devices_to_observers()
        {
            var observed = new List <Device>();
            var monitor  = new MessagePublisher <Device>();

            monitor.Subscribe(observed.Add);
            monitor.Publish(TestMessages.NewSearchResponse());

            observed.Count.Should().Be(1);
        }
예제 #18
0
        /// <summary>
        ///
        /// </summary>
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            MessagePublisher.Start();
        }
예제 #19
0
        public void MessagePublisher_SendParticipantMessage()
        {
            _mockKafkaConfigHelper.Setup(p => p.ParticipantAllocationsTopicName).Returns("payday_participant_v1");
            _mockKafkaPublisher.Setup(p => p.SendMessage(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>()));

            var objectUnderTest = new MessagePublisher(_mockLogger.Object, _mockKafkaConfigHelper.Object, _mockKafkaPublisher.Object);

            bool success = objectUnderTest.SendParticipantAllocationsMessage(TestHelper.CreateCompMessage());

            Assert.True(success);
        }
예제 #20
0
        public NotificationCollection SaveShift(Shift shift)
        {
            var result = repository.Save(shift);

            if (!result.HasErrors())
            {
                MessagePublisher.PublishApplicationMessage(MessageTopics.ShiftUpdated, shift.Id);
            }

            return(result);
        }
예제 #21
0
        public static Configuration UseMessagePublisher(this Configuration configuration, string defaultTopic)
        {
            var container          = IoCFactory.Instance.CurrentContainer;
            var messageQueueClient = IoCFactory.Resolve <IMessageQueueClient>();

            defaultTopic = Configuration.Instance.FormatAppName(defaultTopic);
            var messagePublisher = new MessagePublisher(messageQueueClient, defaultTopic);

            container.RegisterInstance <IMessagePublisher>(messagePublisher);
            return(configuration);
        }
예제 #22
0
        public void Flow_manifold_type()
        {
            var aggregator = new MessageAggregator();
            var publisher  = new MessagePublisher(aggregator);

            aggregator.Subscribe(new ManifoldHandler());
            for (var i = 0; i < trials; i++)
            {
                publisher.Publish(new SubMessage());
            }
        }
예제 #23
0
        public void Flow_single_type()
        {
            var aggregator = new MessageAggregator();
            var publisher  = new MessagePublisher(aggregator);

            aggregator.Subscribe(new DoNothingHandler());
            for (var i = 0; i < trials; i++)
            {
                publisher.Publish(new BaseMessage());
            }
        }
예제 #24
0
            public void SerializesMessage()
            {
                Mock <IMessageSerializer> mockMessageSerializer = new Mock <IMessageSerializer>();

                MessagePublisher <TestMessage> messagePublisher = new MessagePublisher <TestMessage>(Mock.Of <IMessagingEntityFactory>(), mockMessageSerializer.Object, Mock.Of <IMessagePropertyProvider <TestMessage> >(), Mock.Of <IMessageOutgoingPropertiesTable>());

                TestMessage message = new TestMessage();

                messagePublisher.PublishAsync(message);

                mockMessageSerializer.Verify(ms => ms.Serialize(It.IsAny <Stream>(), It.Is <TestMessage>(it => Object.ReferenceEquals(it, message))), Times.Once());
            }
        static async Task Main(string[] args)
        {
            var msgPublisher = new MessagePublisher();

            while (true)
            {
                await msgPublisher.PublishAsync();

                Thread.Sleep(TimeSpan.FromMilliseconds(100));
            }
            // Console.WriteLine("Hello World!");
        }
예제 #26
0
        public string SendMessage(object sendMsgObj)
        {
            var client = new MessagePublisher(new MessagePublisherOptions()
            {
                AppKey    = "123123",
                AppSecret = "sdfdsf",
                Gateway   = "http://messagequene-gateway.i200.cn:9090/mq/publish"
            });
            var result = client.SendMessage(sendMsgObj);

            return(result);
        }
예제 #27
0
        public new void OneTimeSetUp()
        {
            base.OneTimeSetUp();

            Publisher       = new MessagePublisher(HostName, ExchangeName, CreatorQueueName);
            ConsumerCreator = new AutoConsumerCreator(
                new AutoMessageConsumer(HostName, CreatorQueueName),
                Creator);

            // Subscribe
            ConsumerCreator.EntryCreated += ConsumerCreator_EntryCreated;
        }
예제 #28
0
        public new void OneTimeSetUp()
        {
            base.OneTimeSetUp();

            Publisher       = new MessagePublisher(HostName, ExchangeName, DeleterQueueName);
            ConsumerDeleter = new AutoConsumerDeleter(
                new AutoMessageConsumer(HostName, DeleterQueueName),
                Deleter);

            // Subscribe
            ConsumerDeleter.EntryDeleted += delegate { AutoResetEvent.Set(); };
        }
예제 #29
0
        public void MessagePublisher_CanSendMessage()
        {
            _configHelper.Setup(p => p.ParticipantTopicName).Returns(It.IsAny <string>());
            _producer.Setup(p => p.SendMessage(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>()));

            List <CompensationInvestment> invests = TestHelper.GenerateCompensationInvestments();
            var objectUnderTest = new MessagePublisher(_loggerMock.Object, _configHelper.Object, _producer.Object);

            objectUnderTest.SendParticipantMessages(invests);

            _configHelper.Verify(p => p.ParticipantTopicName, Times.Once());
            _producer.Verify(p => p.SendMessage(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid>()), Times.Exactly(5));
        }
예제 #30
0
        public static Configuration UseMessagePublisher(this Configuration configuration, string defaultTopic)
        {
            var builder = ObjectProviderFactory.Instance.ObjectProviderBuilder;

            builder.Register <IMessagePublisher>(provider =>
            {
                var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
                configuration.SetDefaultTopic(defaultTopic);
                defaultTopic         = configuration.FormatAppName(defaultTopic);
                var messagePublisher = new MessagePublisher(messageQueueClient, defaultTopic);
                return(messagePublisher);
            }, ServiceLifetime.Singleton);
            return(configuration);
        }
예제 #31
0
        public async Task Should_send_messages_in_batch()
        {
            var resolverMock = new Mock <IPublisherClientResolver>();
            var wrapperMock  = new Mock <ITopicClientWrapper>();

            resolverMock.Setup((_) => _.GetClient()).Returns(wrapperMock.Object);
            var publisher = new MessagePublisher(resolverMock.Object);

            await publisher.SendBatchAsync(new List <Message> {
                CreateEmptyMessage(), CreateEmptyMessage()
            });

            wrapperMock.Verify((_) => _.SendAsync(It.IsAny <BrokeredMessage>()), Times.Exactly(2));
        }
            public void SerializesMessage()
            {
                Mock<IMessageSender> mockMessageSender = new Mock<IMessageSender>();

                Mock<IMessageSerializer> mockMessageSerializer = new Mock<IMessageSerializer>();

                Mock<IMessagePropertyProvider<TestMessage>> mockMessagePropertyProvider = new Mock<IMessagePropertyProvider<TestMessage>>();
                
                MessagePublisher<TestMessage> messagePublisher = new MessagePublisher<TestMessage>(mockMessageSender.Object, mockMessageSerializer.Object, mockMessagePropertyProvider.Object);

                TestMessage message = new TestMessage();

                messagePublisher.PublishAsync(message);

                mockMessageSerializer.Verify(ms => ms.Serialize(It.IsAny<Stream>(), It.Is<TestMessage>(it => Object.ReferenceEquals(it, message))), Times.Once());
            }
            public async Task GetsMessagePropertiesFromPropertyProviderAndAppliesThemToTheBrokeredMessage()
            {
                Mock<IMessageSender> mockMessageSender = new Mock<IMessageSender>();
                BrokeredMessage brokeredMessageSent = null;

                mockMessageSender.Setup(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()))
                    .Callback<BrokeredMessage>(bm =>
                    {
                        brokeredMessageSent = bm;
                    })
                    .Returns(Task.FromResult<object>(null));

                Mock<IMessageSerializer> mockMessageSerializer = new Mock<IMessageSerializer>();

                Mock<IMessagePropertyProvider<TestMessage>> mockMessagePropertyProvider = new Mock<IMessagePropertyProvider<TestMessage>>();

                KeyValuePair<string, object>[] properties = new[]
                {
                    new KeyValuePair<string, object>("Prop1", 1),
                    new KeyValuePair<string, object>("Prop2", "two"),
                };

                mockMessagePropertyProvider.Setup(mpp => mpp.GetProperties(It.IsAny<TestMessage>()))
                    .Returns(properties);

                MessagePublisher<TestMessage> messagePublisher = new MessagePublisher<TestMessage>(mockMessageSender.Object, mockMessageSerializer.Object, mockMessagePropertyProvider.Object);

                TestMessage message = new TestMessage();

                await messagePublisher.PublishAsync(message);

                mockMessagePropertyProvider.Verify(mpp => mpp.GetProperties(It.Is<TestMessage>(it => Object.ReferenceEquals(it, message))), Times.Once);

                brokeredMessageSent.Should().NotBeNull();

                // TODO: should be able to do this cleaner
                brokeredMessageSent.Properties.Should().ContainKeys(properties.Select(kvp => kvp.Key), "Should have translated all properties provided by the property provider to the BrokeredMessage.");
                brokeredMessageSent.Properties.Should().ContainValues(properties.Select(kvp => kvp.Value), "Should have translated all properties provided by the property provider to the BrokeredMessage.");
            }
            public async Task RequestRequesterIdEndsUpAsReplyToSessionId()
            {
                Mock<IMessageSender> mockMessageSender = new Mock<IMessageSender>();

                BrokeredMessage brokeredMessageSent = null;

                mockMessageSender.Setup(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()))
                    .Callback<BrokeredMessage>(bm =>
                    {
                        brokeredMessageSent = bm;
                    })
                    .Returns(Task.FromResult<object>(null));

                Mock<IMessageSerializer> mockMessageSerializer = new Mock<IMessageSerializer>();

                Mock<IMessagePropertyProvider<TestMessage>> mockMessagePropertyProvider = new Mock<IMessagePropertyProvider<TestMessage>>();

                MessagePublisher<TestMessage> messagePublisher = new MessagePublisher<TestMessage>(mockMessageSender.Object, mockMessageSerializer.Object, mockMessagePropertyProvider.Object);

                TestRequest request = new TestRequest
                {
                    RequesterId = "TestRequesterId"
                };

                await messagePublisher.PublishAsync(request);

                mockMessageSender.Verify(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()), Times.Once());

                brokeredMessageSent.Should().NotBeNull();
                brokeredMessageSent.ReplyToSessionId.Should().Be(request.RequesterId);
            }
            public async Task SendsMessage()
            {
                Mock<IMessageSender> mockMessageSender = new Mock<IMessageSender>();

                Mock<IMessageSerializer> mockMessageSerializer = new Mock<IMessageSerializer>();

                Mock<IMessagePropertyProvider<TestMessage>> mockMessagePropertyProvider = new Mock<IMessagePropertyProvider<TestMessage>>();

                MessagePublisher<TestMessage> messagePublisher = new MessagePublisher<TestMessage>(mockMessageSender.Object, mockMessageSerializer.Object, mockMessagePropertyProvider.Object);

                TestMessage message = new TestMessage();

                await messagePublisher.PublishAsync(message);

                mockMessageSender.Verify(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()), Times.Once());
            }
            public async Task AppliesMessageTypeNamePropertyToTheBrokeredMessage()
            {
                Mock<IMessageSender> mockMessageSender = new Mock<IMessageSender>();
                BrokeredMessage brokeredMessageSent = null;

                mockMessageSender.Setup(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()))
                    .Callback<BrokeredMessage>(bm =>
                    {
                        brokeredMessageSent = bm;
                    })
                    .Returns(Task.FromResult<object>(null));

                Mock<IMessageSerializer> mockMessageSerializer = new Mock<IMessageSerializer>();

                Mock<IMessagePropertyProvider<TestMessage>> mockMessagePropertyProvider = new Mock<IMessagePropertyProvider<TestMessage>>();

                MessagePublisher<TestMessage> messagePublisher = new MessagePublisher<TestMessage>(mockMessageSender.Object, mockMessageSerializer.Object, mockMessagePropertyProvider.Object);

                TestMessage message = new TestMessage();

                await messagePublisher.PublishAsync(message);

                brokeredMessageSent.Should().NotBeNull();

                brokeredMessageSent.Properties.Should().Contain(new KeyValuePair<string,object>(MessagePropertyNames.TypeName, typeof(TestMessage).Name), "Should have applied the mesage type name property to the BrokeredMessage.");
            }
예제 #37
0
        public async Task ShouldCorrectlyPublishAndSubscribeToMulipleMultiplexedTopics()
        {
            const string brokerUri = "tcp://localhost:61616";
            const string topicName1 = "Obvs.Tests.ShouldCorrectlyPublishAndSubscribeToMulipleMultiplexedTopics1";
            const string topicName2 = "Obvs.Tests.ShouldCorrectlyPublishAndSubscribeToMulipleMultiplexedTopics2";

            IMessagePropertyProvider<IMessage> getProperties = new DefaultPropertyProvider<IMessage>();

            IConnectionFactory connectionFactory = new ConnectionFactory(brokerUri);
            var lazyConnection = new Lazy<IConnection>(() =>
            {
                var conn = connectionFactory.CreateConnection();
                conn.Start();
                return conn;
            });

            IMessagePublisher<IMessage> publisher1 = new MessagePublisher<IMessage>(
                lazyConnection,
                new ActiveMQTopic(topicName1),
                new JsonMessageSerializer(),
                getProperties,
                _testScheduler);

            IMessagePublisher<IMessage> publisher2 = new MessagePublisher<IMessage>(
                lazyConnection,
                new ActiveMQTopic(topicName2),
                new JsonMessageSerializer(),
                getProperties,
                _testScheduler);

            IMessageDeserializer<IMessage>[] deserializers =
            {
                new JsonMessageDeserializer<TestMessage>(),
                new JsonMessageDeserializer<TestMessage2>()
            };

            IMessageSource<IMessage> source = new MergedMessageSource<IMessage>(new[]
            {
                new MessageSource<IMessage>(
                    lazyConnection,
                    deserializers,
                    new ActiveMQTopic(topicName1)),

                new MessageSource<IMessage>(
                    lazyConnection,
                    deserializers,
                    new ActiveMQTopic(topicName2))
            });

            source.Messages.Subscribe(Console.WriteLine);

            await publisher1.PublishAsync(new TestMessage { Id = 1234 });
            await publisher1.PublishAsync(new TestMessage2 { Id = 4567 });
            await publisher2.PublishAsync(new TestMessage { Id = 8910 });
            await publisher2.PublishAsync(new TestMessage2 { Id = 1112 });

            Thread.Sleep(TimeSpan.FromSeconds(3));
        }