public void BuildBasicPropertiesByConfiguration() { const String contentType = "application/json"; const String contentEncoding = "UTF-8"; const String messageId = "one-id"; const Int64 timestamp = 123456789L; var collection = new HeaderCollection(new Dictionary<String, Object>(StringComparer.OrdinalIgnoreCase) { { "content_type", contentType }, { "content_encoding", contentEncoding } }); const String key = "foo"; const String value = "bar"; collection.AddHeader(key, value); var resolver = new Mock<IMessageTypeResolver>(); resolver.Setup(_ => _.Resolve<Foo>()).Returns(EmptyMessageBinding.Instance); var newId = new Mock<INewId>(); newId.Setup(_ => _.Next()).Returns(messageId); var dateTimeProvider = new Mock<IDateTimeProvider>(); dateTimeProvider.Setup(_ => _.UtcNow()).Returns(timestamp.ToDateTimeOffset()); var message = new OutboundMessage<Foo>(new Foo(), collection); var properties = message.BuildBasicProperties(resolver.Object, dateTimeProvider.Object, newId.Object); Assert.Equal(messageId, properties.MessageId); Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp); Assert.Equal(contentType, properties.ContentType); Assert.Equal(contentEncoding, properties.ContentEncoding); }
private static void Main() { const String routingKey = "routing_key"; const String endpointUrl = "amqp://*****:*****@localhost:5672/"; IMessageTypeResolver resolver = new MessageBindingResolver(typeof(Foo).Assembly); var broker = Broker.New(_ => { _.Endpoint(new Uri(endpointUrl, UriKind.Absolute)); _.ResolveMessageTypeBy(resolver); }); var exchange = broker.DeclareDirectExchange("source_exchange"); var queue = broker.DeclareQueue("my_test_queue"); broker.DeclareExchangeBinding(exchange, queue, routingKey); broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer1())); broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer2())); var connection = broker.Connect(); for (var i = 0; i < 5; i++) { var message = new OutboundMessage <Foo>(new Foo { Bar = i }); connection.PublishAsync(message, exchange, routingKey); } Console.ReadLine(); connection.Dispose(); }
protected void SendClientInfo() { var m = OutboundMessage.CreateReliable((byte)EngineMessage.InitialData, false, SequenceChannel.System); short numVars = 0; var allVars = Variable.GetEnumerable(); foreach (var v in allVars) { if (v.HasFlags(VariableFlags.Client)) { numVars++; } } m.Write(numVars); foreach (var v in allVars) { if (v.HasFlags(VariableFlags.Client)) { m.Write(v.Name); m.Write(v.Value); } } Send(m); }
public OutboundQueueWorkerTests() { _queue = new InMemoryOutboundQueue(); var services = new ServiceCollection(); services .AddSingleton <ILoggerFactory, NullLoggerFactory>() .AddSingleton(typeof(ILogger <>), typeof(NullLogger <>)) .AddSingleton <IOutboundQueueConsumer, InMemoryOutboundQueue>() .AddSilverback().WithConnectionTo <TestBroker>(options => options.AddDeferredOutboundConnector(_ => new InMemoryOutboundQueue())); var serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true }); serviceProvider.GetRequiredService <IOutboundRoutingConfiguration>() .Add <IIntegrationMessage>(TestEndpoint.GetDefault()); _broker = (TestBroker)serviceProvider.GetRequiredService <IBroker>(); _broker.Connect(); _worker = new OutboundQueueWorker(serviceProvider, _broker, new NullLogger <OutboundQueueWorker>(), new MessageLogger(), true, 100); // TODO: Test order not enforced InMemoryOutboundQueue.Clear(); _sampleOutboundMessage = new OutboundMessage <TestEventOne>( new TestEventOne { Content = "Test" }, null, TestEndpoint.GetDefault()); _sampleOutboundMessage.RawContent = new JsonMessageSerializer().Serialize(_sampleOutboundMessage.Content, _sampleOutboundMessage.Headers); }
public Result Send(int bytesSent) { try { BytesToSend -= bytesSent; TransmissionItterator += bytesSent; // Still more to send. if (BytesToSend > 0) { OutboundMessage .Skip(TransmissionItterator) .Take(Buffer.Length) .ToArray() .CopyTo(Buffer, 0); Handler.BeginSend(Buffer, 0, Buffer.Length, SocketFlags.None, SocketMonitor.Send, this); return(Result.Success); } Handler.Shutdown(SocketShutdown.Both); Handler.Close(); // Data sent. return(Result.Success); } catch (Exception e) { Handler.Shutdown(SocketShutdown.Both); Handler.Close(); return(Result.Error(e)); } }
public void BuildBasicProperties() { const String contentType = "application/xml"; const String contentEncoding = "UTF-16"; const String messageId = "one-id"; const Int64 timestamp = 123456789L; var collection = new HeaderCollection(new Dictionary <String, Object>(StringComparer.OrdinalIgnoreCase) { { "message_id", messageId }, { "timestamp", timestamp }, { "content_type", contentType }, { "content_encoding", contentEncoding } }); const String key = "foo"; const String value = "bar"; collection.AddHeader(key, value); var resolver = new Mock <IMessageTypeResolver>(); resolver.Setup(_ => _.Resolve <Foo>()).Returns(EmptyMessageBinding.Instance); var message = new OutboundMessage <Foo>(new Foo(), collection); var properties = message.BuildBasicProperties(resolver.Object, null, null); Assert.Equal(messageId, properties.MessageId); Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp); Assert.Equal(contentType, properties.ContentType); Assert.Equal(contentEncoding, properties.ContentEncoding); Assert.Equal(value, collection[key]); }
public void OBOAuth() { SymConfig symConfig = new SymConfig(); SymConfigLoader symConfigLoader = new SymConfigLoader(); symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig3.json"); SymOBOAuth oboAuth = new SymOBOAuth(symConfig); oboAuth.sessionAppAuthenticate(); SymOBOUserAuth auth = oboAuth.getUserAuth("*****@*****.**"); // auth.setSessionToken("eyJhbGciOiJSUzUxMiJ9.eyJzdWIiOiJzdGlzaGxlciIsImlzcyI6InN5bXBob255IiwiYXBwUGVybWlzc2lvbnMiOlsiQUNUX0FTX1VTRVIiLCJHRVRfQkFTSUNfQ09OVEFDVF9JTkZPIiwiR0VUX1BSRVNFTkNFIiwiTElTVF9VU0VSX1NUUkVBTVMiLCJNQU5BR0VfUk9PTVMiLCJTRU5EX01FU1NBR0VTIl0sImFwcEdyb3VwSWQiOiJhZG55LXcxNDYiLCJzZXNzaW9uSWQiOiJiNGI3N2NjMWUyYzg4ODAxMWNmNWI3MWI5YmQwYTZhNjJlNDI0MTMzMzJlMGRkNDk1NWQzYzk3ZjViNjE4MWMyNWE2MTVmYThkMjNmNjM2YmNmNDJiNTMxOGI4ZDlkNDgwMDAwMDE2NjhjZTIyOGNjMDAwMDUyYjAwMDAwMDAxOSIsInVzZXJJZCI6IjkwOTE1ODY3NzIxNzUzIn0.hSsZOBEH-OlUzOjDl_NhoxVTrlbJSEaxnmV0s5VQO92VgYaTBc0eUbcHaCYzmRtafil8dy_4_pOSMSR9VupDayklL9igT2cRHZGKvryR4_2hNDym3Xs-uYCxC83O1l9CTm2ISrSVgVabzVOznN23sZLQ6IoIj2EORS6B8eemGlGTWjZge1iav464kFosQ5glSDSecY4mTcbh4sYE3mwINlCEML5VqpEbc0Pdu1ZOesLMBHsa3KzlGuIUEjtigP4NZeYPc31G-rzxSKHWeMo3Mqwwk_0dSL6voQgw-29fly0uIGTF7wCSngk3g9n4Lv_0m4Yh5xDcyQ0h4RRxny-Sgg"); // symConfig.agentHost = "alphadyne.symphony.com"; SymOBOClient client = SymOBOClient.initOBOClient(symConfig, auth); OutboundMessage message = new OutboundMessage(); message.message = "<messageML>Hello it is mike fron NET 2</messageML>"; apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream(); stream.streamId = "IzgD3nNbpoaNJ6_To7Ds0n___pmCBYMrdA"; //stream.streamId = "AQpEsS9DJM1ZRrGF7Kb7i3___pui0wKcdA"; MessageClient messageClient = new MessageClient(client); InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false); Assert.IsTrue(resp.message != null); }
private void VerifyMessageHeaderIsPassed(Action <IOutboundMessage> setHeaderAction, Action <IInboundMessageHeaders> checkHeaderAction) { byte[] data; var serializer = new XmlMessageSerializer(); OutboundMessage.Set(setHeaderAction); var message = new PingMessage(); using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, message); data = output.ToArray(); } Trace.WriteLine(OutboundMessage.Headers.MessageType); Trace.WriteLine(Encoding.UTF8.GetString(data)); using (MemoryStream input = new MemoryStream(data)) { serializer.Deserialize(input); checkHeaderAction(CurrentMessage.Headers); } }
public void BuildBasicProperties() { const String contentType = "application/xml"; const String contentEncoding = "UTF-16"; const String messageId = "one-id"; const Int64 timestamp = 123456789L; const String replyExchangeName = "reply-queue-name"; const String replyRoutingKey = "reply-queue-name"; String correlationId = Guid.NewGuid().ToString(); var directReplyConfiguration = new DirectReplyConfiguration(replyExchangeName, replyRoutingKey); var collection = new HeaderCollection(new Dictionary<String, Object>(StringComparer.OrdinalIgnoreCase) { { "message_id", messageId }, { "timestamp", timestamp }, { "content_type", contentType }, { "content_encoding", contentEncoding }, { "correlation_id", correlationId }, { "reply_configuration", directReplyConfiguration } }); const String key = "foo"; const String value = "bar"; collection.AddHeader(key, value); var resolver = new Mock<IMessageTypeResolver>(); resolver.Setup(_ => _.Resolve<Foo>()).Returns(EmptyMessageBinding.Instance); var message = new OutboundMessage<Foo>(new Foo(), collection); var properties = message.BuildBasicProperties(resolver.Object, null, null); Assert.Equal(messageId, properties.MessageId); Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp); Assert.Equal(contentType, properties.ContentType); Assert.Equal(contentEncoding, properties.ContentEncoding); Assert.Equal(correlationId, properties.CorrelationId); Assert.Equal(directReplyConfiguration.ToString(), properties.ReplyTo); Assert.Equal(value, collection[key]); }
public void OBOLogoutTest() { SymConfig symConfig = new SymConfig(); SymConfigLoader symConfigLoader = new SymConfigLoader(); symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig3.json"); SymOBOAuth oboAuth = new SymOBOAuth(symConfig); oboAuth.sessionAppAuthenticate(); SymOBOUserAuth auth = oboAuth.getUserAuth("*****@*****.**"); SymOBOClient client = SymOBOClient.initOBOClient(symConfig, auth); OutboundMessage message = new OutboundMessage(); message.message = "<messageML>Hello Alexa</messageML>"; apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream(); stream.streamId = "IzgD3nNbpoaNJ6_To7Ds0n___pmCBYMrdA"; MessageClient messageClient = new MessageClient(client); InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false); auth.logout(); //Assert.IsTrue(resp.message != null); }
public async Task OnMessageReceived_SingleMessage_Queued() { var outboundMessage = new OutboundMessage <TestEventOne>() { Message = new TestEventOne { Content = "Test" }, Headers = { { "header1", "value1" }, { "header2", "value2" } }, Endpoint = TestEndpoint.Default }; await _connector.RelayMessage(outboundMessage); await _queue.Commit(); _queue.Length.Should().Be(1); var queued = (await _queue.Dequeue(1)).First(); queued.Message.Endpoint.Should().Be(outboundMessage.Endpoint); queued.Message.Headers.Count.Should().Be(2); ((IIntegrationMessage)queued.Message.Message).Id.Should().Be(outboundMessage.Message.Id); }
public override Task ConsumeAsync(ConsumedMessage <Request> message) { return(Task.Factory .StartNew(() => { Console.WriteLine("[{0}]received '{1}' by '{2}' with correlation id {3}", message.ConsumerTag, message.Headers.MessageId, GetType().Name, message.Headers.CorrelationId); var exchange = _broker.DeclareDirectExchange(message.Headers .ReplyConfiguration .ExchangeName); var queue = _broker.DeclareQueue(message.Headers .ReplyConfiguration .RoutingKey); _broker.DeclareExchangeBinding(exchange, queue, message.Headers.ReplyConfiguration.RoutingKey); var outboundMessage = new OutboundMessage <Response>(new Response { BarBar = message.Content.Bar * 2 }); outboundMessage.SetCorrelationId(message.Headers.CorrelationId); _connection.PublishAsync(outboundMessage, exchange, message.Headers.ReplyConfiguration.RoutingKey); })); }
public void Handle_MultipleKeyMembersMessages_KeyHeaderIsSet() { var message1 = new OutboundMessage <MultipleKeyMembersMessage>( new MultipleKeyMembersMessage { Id = Guid.NewGuid(), One = "1", Two = "2", Three = "3" }, null, new KafkaProducerEndpoint("test-endpoint")); var message2 = new OutboundMessage <MultipleKeyMembersMessage>( new MultipleKeyMembersMessage { Id = Guid.NewGuid(), One = "a", Two = "b", Three = "c" }, null, new KafkaProducerEndpoint("test-endpoint")); new KafkaPartitioningKeyBehavior().Handle(new[] { message1, message2 }, Task.FromResult); message1.Headers.Should().ContainEquivalentOf( new MessageHeader("x-kafka-partitioning-key", "One=1,Two=2")); message2.Headers.Should().ContainEquivalentOf( new MessageHeader("x-kafka-partitioning-key", "One=a,Two=b")); }
public Task <IPublishResult> PublishAsync <TMessage>(OutboundMessage <TMessage> message, Exchange exchange, String routingKey = "") where TMessage : class { return(_outboundChannel.PublishAsync(message, exchange, routingKey)); }
public async Task _newMessageFromClient(IncomingMessage inMessage) { User sender = usersOnline.FirstOrDefault(u => u.connectionId == inMessage.connectionId); User receiver = usersOnline.FirstOrDefault(u => u.userid == inMessage.receiverId); OutboundMessage outMessage = new OutboundMessage(); if (inMessage.instruction == 0) { outMessage.msgId = sender.nickName + DateTime.Now.ToString("yyyyMMddHHmmss"); outMessage.senderId = sender.userid; outMessage.time = DateTime.Now.ToString("hh:mm"); outMessage.senderNickName = sender.nickName; outMessage.senderNickColor = sender.nickColor; outMessage.receiverId = receiver.userid; outMessage.receiverNickName = receiver.nickName; outMessage.receiverNickColor = receiver.nickColor; outMessage.prvMsg = inMessage.prvMsg; outMessage.msgColor = sender.msgColor; outMessage.message = inMessage.message; if (!outMessage.prvMsg) { if (lastOutboundMessages.Count < MAXLASTOUTMSG) { lastOutboundMessages.Add(outMessage); } else { for (int i = 0; i < MAXLASTOUTMSG - 1; i++) { lastOutboundMessages[i] = lastOutboundMessages[i + 1]; } lastOutboundMessages[MAXLASTOUTMSG - 1] = outMessage; } } if (outMessage.prvMsg) { //Clients.Caller.addMessage(outMessage); await Clients.Caller.SendAsync("addMessage", outMessage); if (sender.connectionId != receiver.connectionId) { //Clients.Client(Receiver.ConnectionId).addMessage(outMessage); await Clients.Client(receiver.connectionId).SendAsync("addMessage", outMessage); } } else { //Clients.All.broadcastMessage(outMessage); await Clients.All.SendAsync("broadcastMessageReceived", outMessage); } } return; }
public void BuildBasicPropertiesByConfiguration() { const String contentType = "application/json"; const String contentEncoding = "UTF-8"; const String messageId = "one-id"; const Int64 timestamp = 123456789L; var collection = new HeaderCollection(new Dictionary <String, Object>(StringComparer.OrdinalIgnoreCase) { { "content_type", contentType }, { "content_encoding", contentEncoding } }); const String key = "foo"; const String value = "bar"; collection.AddHeader(key, value); var resolver = new Mock <IMessageTypeResolver>(); resolver.Setup(_ => _.Resolve <Foo>()).Returns(EmptyMessageBinding.Instance); var newId = new Mock <INewId>(); newId.Setup(_ => _.Next()).Returns(messageId); var dateTimeProvider = new Mock <IDateTimeProvider>(); dateTimeProvider.Setup(_ => _.UtcNow()).Returns(timestamp.ToDateTimeOffset()); var message = new OutboundMessage <Foo>(new Foo(), collection); var properties = message.BuildBasicProperties(resolver.Object, dateTimeProvider.Object, newId.Object); Assert.Equal(messageId, properties.MessageId); Assert.Equal(new AmqpTimestamp(timestamp), properties.Timestamp); Assert.Equal(contentType, properties.ContentType); Assert.Equal(contentEncoding, properties.ContentEncoding); }
public void onIMMessage(Message message) { OutboundMessage outMessage = new OutboundMessage(); outMessage.message = "Hello " + message.user.displayName + "!"; this.symBotClient.getMessagesClient().sendMessage(message.stream.streamId, outMessage, true); }
public async Task OnMessageReceived_SingleMessage_Queued() { var outboundMessage = new OutboundMessage <TestEventOne>( new TestEventOne { Content = "Test" }, new[] { new MessageHeader("header1", "value1"), new MessageHeader("header2", "value2") }, TestEndpoint.GetDefault()); outboundMessage.RawContent = new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers); await _connector.RelayMessage(outboundMessage); await _queue.Commit(); (await _queue.GetLength()).Should().Be(1); var queued = (await _queue.Dequeue(1)).First(); queued.Endpoint.Should().Be(outboundMessage.Endpoint); queued.Headers.Count().Should().Be(3); queued.Content.Should().BeEquivalentTo(new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers)); }
public override Task <IPublishResult> PublishAsync <TMessage>(OutboundMessage <TMessage> source, Exchange exchange, String routingKey) { var properties = BuildBasicProperties(source); var body = BuildBody(source, properties); var tcs = new TaskCompletionSource <Boolean>(properties); var tag = Model.NextPublishSeqNo; _confirms.TryAdd(tag, new Tuple <TaskCompletionSource <Boolean>, IMessage>(tcs, source)); try { Model.BasicPublish(exchange.Name, routingKey, false, properties, body); } catch (Exception exception) { Tuple <TaskCompletionSource <Boolean>, IMessage> tuple; _confirms.TryRemove(tag, out tuple); tcs.TrySetException(exception); } return(tcs.Task.ContinueWith(Result)); }
protected IBasicProperties BuildBasicProperties <TMessage>(OutboundMessage <TMessage> source) where TMessage : class { return(source.BuildBasicProperties(Configuration.MessageTypeResolver, DateTimeProvider, Configuration.IdGenerator)); }
public static void Publish <T>(this IServiceBus bus, T message, Action <IOutboundMessage> messageHeaderAction) where T : class { OutboundMessage.Set(messageHeaderAction); bus.Publish(message); }
public static void Send <T>(this IEndpoint endpoint, T message, Action <IOutboundMessage> messageHeaderAction) where T : class { OutboundMessage.Set(messageHeaderAction); endpoint.Send(message); }
/// <summary> /// Shows message status notification. /// </summary> public static void ShowNotification(OutboundMessage message, MessageDeliveryStatus status) { Argument.ExpectNotNull(() => message); string notificationHeader; if (message is SmsMessage) { notificationHeader = ResourcesHelper.GetString("SMS"); } else if (message is MmsMessage) { notificationHeader = ResourcesHelper.GetString("MMS"); } else { throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, "Message type {0} is not supported", message.GetType().Name)); } XmlDocument toastXml = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText01); XmlNodeList textElements = toastXml.GetElementsByTagName("text"); var builder = new StringBuilder(); builder.Append(notificationHeader); builder.Append(" "); builder.Append(ResourcesHelper.GetString("MessageSentTo")); builder.Append(" "); string phones = String.Join(", ", message.PhoneNumbers.Select(n => n.Number)); builder.Append(phones); builder.Append(" "); switch (status) { case MessageDeliveryStatus.DeliveredToNetwork: builder.Append(ResourcesHelper.GetString("SuccessfullySent")); break; case MessageDeliveryStatus.DeliveredToTerminal: builder.Append(ResourcesHelper.GetString("SuccessfullyDelivered")); break; case MessageDeliveryStatus.DeliveryImpossible: builder.Append(ResourcesHelper.GetString("NotDelivered")); break; case MessageDeliveryStatus.Error: builder.Append(ResourcesHelper.GetString("Error")); break; } textElements[0].InnerText = builder.ToString(); var toast = new ToastNotification(toastXml); ToastNotificationManager.CreateToastNotifier().Show(toast); }
public void MessageRoomTest() { SymConfig symConfig = new SymConfig(); SymConfigLoader symConfigLoader = new SymConfigLoader(); symConfig = symConfigLoader.loadFromFile("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/testConfig.json"); SymBotAuth botAuth = new SymBotAuth(symConfig); botAuth.authenticate(); SymBotClient botClient = SymBotClient.initBot(symConfig, botAuth); OutboundMessage message = new OutboundMessage(); message.message = "<messageML>Hello world!</messageML>"; FileStream fileStream = File.OpenRead("C:/Users/Michael/Documents/Visual Studio 2017/Projects/apiClientDotNet/apiClientDotNetTest/Resources/AttachmentTest.txt"); List <FileStream> attachments = new List <FileStream>(); attachments.Add(fileStream); message.attachments = attachments; apiClientDotNet.Models.Stream stream = new apiClientDotNet.Models.Stream(); stream.streamId = "fu1cJFoklnYlR9vu1AOZ5X___pzXDKPXdA"; MessageClient messageClient = new MessageClient(botClient); InboundMessage resp = messageClient.sendMessage(stream.streamId, message, false); Assert.IsTrue(resp.messageId != null); }
public void The_xml_message_serializer_should_rock_the_house() { byte[] serializedMessageData; var serializer = new XmlMessageSerializer(); OutboundMessage.Set(x => { x.SetSourceAddress("msmq://localhost/queue_name"); x.SetDestinationAddress("msmq://remotehost/queue_name"); x.SetResponseAddress("msmq://localhost/response_queue"); x.SetFaultAddress("msmq://localhost/fault_queue"); x.SetRetryCount(7); }); using (MemoryStream output = new MemoryStream()) { serializer.Serialize(output, _message); serializedMessageData = output.ToArray(); Trace.WriteLine(Encoding.UTF8.GetString(serializedMessageData)); } using (MemoryStream input = new MemoryStream(serializedMessageData)) { SerializationTestMessage receivedMessage = serializer.Deserialize(input) as SerializationTestMessage; Assert.AreEqual(_message, receivedMessage); } }
private static void Main() { const String routingKey = "routing_key"; const String endpointUrl = "amqp://*****:*****@localhost:5672/"; IMessageTypeResolver resolver = new MessageBindingResolver(typeof(Foo).Assembly); var broker = Broker.New(_ => { _.Endpoint(new Uri(endpointUrl, UriKind.Absolute)); _.ResolveMessageTypeBy(resolver); }); var exchange = broker.DeclareDirectExchange("source_exchange"); var queue = broker.DeclareQueue("my_test_queue"); broker.DeclareExchangeBinding(exchange, queue, routingKey); broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer1())); broker.SubscribeByAtLeastOnce(queue, _ => _.Consumes(new FooConsumer2())); var connection = broker.Connect(); for (var i = 0; i < 5; i++) { var message = new OutboundMessage<Foo>(new Foo { Bar = i }); connection.PublishAsync(message, exchange, routingKey); } Console.ReadLine(); connection.Dispose(); }
private void SendMessageAsync() { var task = new Task(() => { var symConfigLoader = new SymConfigLoader(); var configPathTwo = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", "testConfigPsdevTwo.json"); var symConfigTwo = symConfigLoader.loadFromFile(configPathTwo); var botAuthTwo = new SymBotRSAAuth(symConfigTwo); botAuthTwo.authenticate(); var botClientTwo = SymBotClient.initBot(symConfigTwo, botAuthTwo); // Find one BOT stream id var streamClient = botClientTwo.getStreamsClient(); var streamTypes = new List <string> { "ROOM" }; var result = streamClient.getUserStreams(streamTypes, false); // Send to that stream a messages var message = new OutboundMessage { message = "<messageML>Hello world! From .NET SDK Integration Test.</messageML>" }; var stream = new apiClientDotNet.Models.Stream { streamId = result[0].id }; var messageClient = new MessageClient(botClientTwo); messageClient.sendMessage(stream.streamId, message, false); }, TaskCreationOptions.AttachedToParent); task.Start(); }
public ActionResult DeleteConfirmed(int id) { OutboundMessage outboundMessage = db.OutboundMessages.Find(id); db.OutboundMessages.Remove(outboundMessage); db.SaveChanges(); return(RedirectToAction("Index")); }
public void ReThrows_Exception_Given_Unhandled_Exception_Is_Thrown_When_Sending_OutboundMessage() { _mockSender.Setup(s => s.SendAsync(It.IsAny <Message>())).ThrowsAsync(new DivideByZeroException()); Func <Task> sendAction = async() => await _outboundGateway.SendAsync(OutboundMessage <MyEvent> .FromEntity(MyEvent.Default)).ConfigureAwait(false); sendAction.Should().Throw <DivideByZeroException>(); }
public static void SendToAll(OutboundMessage m) { GameServer.Instance.Networking.SendToAll(m); if (LocalClient != null) { LocalClient.Send(m); } }
public async Task SendAsync <TMessage>(OutboundMessage <TMessage> outboundMessage) where TMessage : class { var message = GenerateMessage(outboundMessage); var sw = Stopwatch.StartNew(); await _sender.SendAsync(message).ConfigureAwait(false); TrackDependency(sw, nameof(SendAsync), outboundMessage.UserProperties); _logger.LogDebug(LogEventIds.OutboundGatewaySentSingle, $"Sent single message of {nameof(OutboundMessage<TMessage>)} type {typeof(TMessage).Name}"); }
public void NonDurableMessage() { var message = new OutboundMessage <Bar>(new Bar()); var properties = message.BuildBasicProperties(StubResolver <Bar>(null).Object, StubDateTimeProvider().Object, new Mock <INewId>().Object); Assert.False(properties.Persistent); }
public void DefaultContentType() { var message = new OutboundMessage <Bar>(new Bar()); var properties = message.BuildBasicProperties(StubResolver <Bar>(null).Object, StubDateTimeProvider().Object, new Mock <INewId>().Object); Assert.Equal("application/json", properties.ContentType); }
public void set(string gateway_name,int port,byte[] b_ip,string s_ip) { srv = Service.getInstance(); com1 = new Comm2IP.Comm2IP(b_ip, port, modem.AttachedTo , 115200); //modem comport try { new Thread(new ThreadStart(com1.Run)).Start(); IPModemGateway gateway = new IPModemGateway(gateway_name, s_ip, port, "Huawei", ""); gateway.setIpProtocol(ModemGateway.IPProtocols.BINARY); gateway.setProtocol(AGateway.Protocols.PDU); gateway.setInbound(true); gateway.setOutbound(true); gateway.setSimPin("0000"); srv.addGateway(gateway); // Start! (i.e. connect to all defined Gateways) srv.startService(); // Send more than one message at once. OutboundMessage[] msgArray = new OutboundMessage[contact_list.Count]; int count = 0; foreach (int number in contact_list) { msgArray[count++] = new OutboundMessage(number.ToString(), sms.Content); } srv.sendMessages(msgArray); //Console.WriteLine(msgArray[0]); //Console.WriteLine(msgArray[1]); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); Console.Read(); } finally { com1.Stop(); srv.stopService(); } }
static void Main(string[] args) { // Create new Service object - the parent of all and the main interface to you. Service srv; srv = Service.getInstance(); // *** The tricky part *** // *** Comm2IP Driver *** // Create (and start!) as many Comm2IP threads as the modems you are using. // Be careful about the mappings - use the same mapping in the Gateway definition. Comm2IP.Comm2IP com1 = new Comm2IP.Comm2IP(new byte[] { 127, 0, 0, 1 }, 12000, "com4", 115200); try { Console.WriteLine("Example: Read messages from a serial gsm modem."); Console.WriteLine(Library.getLibraryDescription()); Console.WriteLine("Version: " + Library.getLibraryVersion()); // Start the COM listening thread. new Thread(new ThreadStart(com1.Run)).Start(); // Lets set some callbacks. srv.setInboundMessageNotification(new InboundNotification()); srv.setCallNotification(new CallNotification()); srv.setGatewayStatusNotification(new GatewayStatusNotification()); // Create the Gateway representing the serial GSM modem. // Due to the Comm2IP bridge, in SMSLib for .NET all modems are considered IP modems. IPModemGateway gateway = new IPModemGateway("modem.com4", "127.0.0.1", 12000, "Huawei", "E220"); gateway.setIpProtocol(ModemGateway.IPProtocols.BINARY); // Set the modem protocol to PDU (alternative is TEXT). PDU is the default, anyway... gateway.setProtocol(AGateway.Protocols.PDU); // Do we want the Gateway to be used for Inbound messages? gateway.setInbound(true); // Do we want the Gateway to be used for Outbound messages? gateway.setOutbound(true); // Let SMSLib know which is the SIM PIN. gateway.setSimPin("0000"); // Explicit SMSC address set is required for some modems. // Below is for VODAFONE GREECE - be sure to set your own! gateway.setSmscNumber("+306942190000"); // Add the Gateway to the Service object. srv.addGateway(gateway); // Similarly, you may define as many Gateway objects, representing // various GSM modems, add them in the Service object and control all of them. // Start! (i.e. connect to all defined Gateways) srv.startService(); // Printout some general information about the modem. Console.WriteLine(); Console.WriteLine("Modem Information:"); Console.WriteLine(" Manufacturer: " + gateway.getManufacturer()); Console.WriteLine(" Model: " + gateway.getModel()); Console.WriteLine(" Serial No: " + gateway.getSerialNo()); Console.WriteLine(" SIM IMSI: " + gateway.getImsi()); Console.WriteLine(" Signal Level: " + gateway.getSignalLevel() + "dBm"); Console.WriteLine(" Battery Level: " + gateway.getBatteryLevel() + "%"); Console.WriteLine(); // Send one message. // Remember to change the recipient! OutboundMessage msg = new OutboundMessage("+3069...", "Hello from SMSLib for .NET"); srv.sendMessage(msg); Console.WriteLine(msg); // Send more than one message at once. //OutboundMessage[] msgArray = new OutboundMessage[2]; //msgArray[0] = new OutboundMessage("+306948494037", "Hello from SMSLib for .NET (#1)"); //msgArray[1] = new OutboundMessage("+306948494037", "Hello from SMSLib for .NET (#2)"); //srv.sendMessages(msgArray); //Console.WriteLine(msgArray[0]); //Console.WriteLine(msgArray[1]); Console.WriteLine("Press <ENTER> to terminate..."); Console.In.ReadLine(); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); } finally { com1.Stop(); srv.stopService(); } }
public void sendMessage(String message, String number) { OutboundMessage msg = new OutboundMessage(number, message); srv.sendMessage(msg); }
public void checkThreats(string desease,string location, InboundMessage msg) { if(desease.ToLower().Contains("dengue")) { url = "http://localhost/devfest/geocode.php?disease=" + desease + "&location="+location; WebRequest request = HttpWebRequest.Create(url); WebResponse response = request.GetResponse(); StreamReader reader = new StreamReader(response.GetResponseStream()); string urlText = reader.ReadToEnd(); if(urlText.Equals("alert")){ //Here the Alerts will be sent. For test case I am sending alert to my team member OutboundMessage msg1 = new OutboundMessage("+923025474347", "Dengue Alert!!!\n Dengue is Spreading near "+location); srv.sendMessage(msg1); Console.WriteLine("Dengue Alert!!!\n Dengue is Spreading near " + location); } } }
public void postData(AGateway gateway, InboundMessage msg, String[] mssg) { if(mssg.Length == 7) { //means complete message with login key url = "http://localhost/devfest/geocode.php?key=" + mssg[1] + "&name=" + mssg[2] + "&cnic=" + mssg[3] + "&location=" + mssg[4].Trim() + "&disease=" + mssg[5] + "&contact=" + mssg[6]; a = false; } else if(mssg.Length == 2) { //just to identify that key is correct. not used yet } else if(mssg.Length == 5) { url = "http://localhost/devfest/geocodee.php?name=" + mssg[1] + "&cnic=" + mssg[2] + "&location=" + mssg[3].Trim() + "&disease=" + mssg[4] + "&contact=" + msg.getOriginator(); a = true; //means complete message without login key } WebRequest request = HttpWebRequest.Create(url); WebResponse response = request.GetResponse(); StreamReader reader = new StreamReader(response.GetResponseStream()); string urlText = reader.ReadToEnd(); Console.WriteLine(urlText); try { // Uncomment following line if you wish to delete the message upon arrival. gateway.deleteMessage(msg); } catch(Exception e) { Console.WriteLine("Oops!!! Something gone bad..."); Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); } OutboundMessage msg1 = new OutboundMessage("+"+msg.getOriginator(), urlText); srv.sendMessage(msg1); if(a) { checkThreats(mssg[4],mssg[3].Trim(),msg); } else { checkThreats(mssg[5],mssg[4].Trim(),msg); } }