public async Task Should_Not_Throw_Exception_When_Queue_Name_Is_Long() { using (var subscriber = ZyRabbitFactory.CreateTestClient()) using (var publisher = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var msgTcs = new TaskCompletionSource <BasicMessage>(); var message = new BasicMessage { Prop = "I'm delivered to queue with truncated name" }; var queueName = string.Empty; while (queueName.Length < 254) { queueName = queueName + "this_is_part_of_a_long_queue_name"; } await subscriber.SubscribeAsync <BasicMessage>(msg => { msgTcs.TrySetResult(msg); return(Task.FromResult(0)); }, ctx => ctx .UseSubscribeConfiguration(cfg => cfg .FromDeclaredQueue(q => q.WithName(queueName).WithAutoDelete()) ) ); /* Test */ await publisher.PublishAsync(message); await msgTcs.Task; /* Assert */ Assert.Equal(message.Prop, msgTcs.Task.Result.Prop); } }
public async Task Should_Be_Able_To_Return_Nack_Without_Requeue() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var firstSubscriber = ZyRabbitFactory.CreateTestClient()) using (var secondSubscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var firstTsc = new TaskCompletionSource <BasicMessage>(); var secondTsc = new TaskCompletionSource <BasicMessage>(); await firstSubscriber.SubscribeAsync <BasicMessage>(async received => { firstTsc.TrySetResult(received); return(new Nack(requeue: false)); }); await secondSubscriber.SubscribeAsync <BasicMessage>(async received => { secondTsc.TrySetResult(received); return(new Nack(requeue: false)); }); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message); Task.WaitAll(new [] { firstTsc.Task, secondTsc.Task }, TimeSpan.FromMilliseconds(200)); /* Assert */ Assert.Equal(message.Prop, firstTsc.Task.Result.Prop); Assert.False(secondTsc.Task.IsCompleted); } }
private void buttonSendLog_Click(object sender, EventArgs e) { byte[] buffer = new byte[350000]; BasicMessage message = new BasicMessage(buffer); this.client.SendAsync(message); }
public async Task Should_Honor_Task_Cancellation() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var subscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var message = new BasicMessage { Prop = Guid.NewGuid().ToString() }; var receivedTcs = new TaskCompletionSource <BasicMessage>(); var sendCts = new CancellationTokenSource(); await subscriber.SubscribeAsync <BasicMessage>(received => { if (received.Prop == message.Prop) { receivedTcs.TrySetResult(received); } return(Task.FromResult(true)); }); /* Test */ sendCts.CancelAfter(TimeSpan.FromTicks(400)); var publishTask = publisher.PublishAsync(new BasicMessage(), token: sendCts.Token); receivedTcs.Task.Wait(100); /* Assert */ Assert.False(receivedTcs.Task.IsCompleted, "Message was sent, even though execution was cancelled."); Assert.True(publishTask.IsCanceled, "The publish task should be cancelled."); } }
public async Task Should_Be_Able_To_Return_Retry_From_Subscriber_With_Context() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var firstSubscriber = ZyRabbitFactory.CreateTestClient(p => p.UseRetryLater())) using (var secondSubscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var firstTsc = new TaskCompletionSource <DateTime>(); var secondTsc = new TaskCompletionSource <DateTime>(); await firstSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) => { firstTsc.TrySetResult(DateTime.Now); return(Retry.In(TimeSpan.FromSeconds(1))); }); await secondSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) => { secondTsc.TrySetResult(DateTime.Now); return(new Ack()); }); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message); Task.WaitAll(firstTsc.Task, secondTsc.Task); /* Assert */ Assert.Equal(1, (secondTsc.Task.Result - firstTsc.Task.Result).Seconds); } }
public bool Process(BasicMessage message) { Console.WriteLine(message.Body); // return true if you want to ack immediately. False if you want to handle the ack (e.g. dispatch to a thread - and ack later). return(true); }
public void TryReadMessageTestOneLongMessage() { // Create a message to write as received in buffer byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2]; AbstractMessage messageToWrite = new BasicMessage(Guid.NewGuid(), fakeBody); // Prepare the received buffer SocketStateObject state = new SocketStateObject(); int offset = messageToWrite.Header.Write(state.buffer, 0); // Call the TryRead AbstractMessage message = new BasicMessage(); int byteRead = SocketStateObject.BufferSize; AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead); Assert.IsNull(actual); Assert.IsNotNull(state.message); Assert.IsNull(state.pendingBuffer); byteRead = SocketStateObject.BufferSize; actual = AbstractMessage.TryReadMessage(message, state, byteRead); Assert.IsNull(actual); Assert.IsNotNull(state.message); Assert.IsNull(state.pendingBuffer); byteRead = messageToWrite.Header.HeaderLength; actual = AbstractMessage.TryReadMessage(message, state, byteRead); Assert.IsNotNull(actual); Assert.AreEqual(actual.MessageLength, messageToWrite.MessageLength); Assert.IsNull(state.message); Assert.IsNull(state.pendingBuffer); }
private void Send(ClientInfo client, ContainerMessage message) { try { string mc = message.Content; if (mc.Length > 20) { mc = mc.Substring(0, 20) + "..."; } RaiseNewTextEvent(string.Format("Sending message [{0} -> {1}: {2} # {3}]", message.Sender, message.Receiver, message.Info, mc)); string s = ContainerMessage.Serialize(message); byte[] buffer = ASCIIEncoding.Unicode.GetBytes(s); BasicMessage m = new BasicMessage(_serverGuid, buffer); client.TcpSocketClientHandler.SendAsync(m); } catch (SocketException se) { // "An existing connection was forcibly closed by the remote host" RaiseNewTextEvent("Container " + _containerNames[client] + " is disconnected."); _containerNames.Remove(client); client.TcpSocketClientHandler.Close(); RaiseNewTextEvent("Exception in Server.Send: " + se.Message + "."); } catch (Exception ex) { RaiseNewTextEvent("Exception in Server.Send: " + ex.Message + "."); } }
private void NextMessage(BasicMessage message) { foreach (var item in observers) { item.OnNext(message); } }
public async Task OnPostSendMessageAsync(string connectionId, string text) { var context = new DefaultAgentContext { Wallet = await _walletService.GetWalletAsync(_walletOptions.WalletConfiguration, _walletOptions.WalletCredentials) }; var sentTime = DateTime.UtcNow; var messageRecord = new BasicMessageRecord { Id = Guid.NewGuid().ToString(), Direction = MessageDirection.Outgoing, Text = text, SentTime = sentTime, ConnectionId = connectionId }; var message = new BasicMessage { Content = text, SentTime = sentTime.ToString("s", CultureInfo.InvariantCulture) }; var connection = await _connectionService.GetAsync(context, connectionId); // Save the outgoing message to the local wallet for chat history purposes await _recordService.AddAsync(context.Wallet, messageRecord); // Send an agent message using the secure connection await _messageService.SendAsync(context.Wallet, message, connection); }
/// <summary> /// Quickly and easily send a basic message without the need to build up a message object /// or instantiate a SocketLabsClient. /// </summary> /// <param name="serverId">Your SocketLabs ServerId number.</param> /// <param name="apiKey">Your SocketLabs Injection API key.</param> /// <param name="toAddress">The To address for your message recipient.</param> /// <param name="fromAddress">The From address to be used for your message.</param> /// <param name="subject">The subject for your message.</param> /// <param name="htmlContent">The Html content for your message.</param> /// <param name="textContent">The plain text content for your message.</param> /// <remarks>The message must contain either htmlContent, textContent, or both to be valid.</remarks> /// <returns>A <c>SendResponse</c> of an SocketLabsClient send request.</returns> /// <example> /// This sample shows you how to send a message using QuickSend /// <code> /// var response = SocketLabsClient.QuickSend(000000, "apiKey", /// "*****@*****.**", /// "*****@*****.**", /// "Lorem Ipsum", /// "<html>Lorem Ipsum</html>", /// "Lorem Ipsum" /// ); /// </code> /// </example> public static SendResponse QuickSend( int serverId, string apiKey, string toAddress, string fromAddress, string subject, string htmlContent, string textContent) { var client = new SocketLabsClient(serverId, apiKey); var email = new BasicMessage { Subject = subject, To = { new EmailAddress(toAddress) }, From = new EmailAddress(fromAddress), HtmlBody = htmlContent, PlainTextBody = textContent }; return(client.Send(email)); }
public async Task Should_Honor_Exchange_Name_Configuration() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var subscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var receivedTcs = new TaskCompletionSource <BasicMessage>(); await subscriber.SubscribeAsync <BasicMessage>(received => { receivedTcs.TrySetResult(received); return(Task.FromResult(true)); }, ctx => ctx .UseSubscribeConfiguration(cfg => cfg .OnDeclaredExchange(e => e .WithName("custom_exchange") )) ); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange("custom_exchange"))); await receivedTcs.Task; /* Assert */ Assert.Equal(message.Prop, receivedTcs.Task.Result.Prop); } }
public async Task Should_Be_Able_To_Publish_With_Custom_Header() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var subscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var receivedTcs = new TaskCompletionSource <BasicDeliverEventArgs>(); await subscriber.SubscribeAsync <BasicMessage, BasicDeliverEventArgs>((received, args) => { receivedTcs.TrySetResult(args); return(Task.FromResult(true)); }, ctx => ctx.UseMessageContext(c => c.GetDeliveryEventArgs())); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message, ctx => ctx .UsePublishConfiguration(cfg => cfg .WithProperties(props => props.Headers.Add("foo", "bar")))); await receivedTcs.Task; /* Assert */ Assert.True(receivedTcs.Task.Result.BasicProperties.Headers.ContainsKey("foo")); } }
public async Task Should_Consume_Message_Already_In_Queue() { using (var subscriber = ZyRabbitFactory.CreateTestClient()) using (var publisher = ZyRabbitFactory.CreateTestClient()) { var msgTcs = new TaskCompletionSource <BasicMessage>(); var msg = new BasicMessage { Prop = Guid.NewGuid().ToString() }; await subscriber.DeclareQueueAsync <BasicMessage>(); await subscriber.DeclareExchangeAsync <BasicMessage>(); await subscriber.BindQueueAsync <BasicMessage>(); await publisher.PublishAsync(msg); await subscriber.SubscribeAsync <BasicMessage>(message => { msgTcs.TrySetResult(message); return(Task.FromResult(true)); }); await msgTcs.Task; Assert.Equal(msg.Prop, msgTcs.Task.Result.Prop); } }
public SendResponse RunExample() { var client = new SocketLabsClient(ExampleConfig.ServerId, ExampleConfig.ApiKey); var message = new BasicMessage(); message.To.Add("*****@*****.**"); message.To.Add("*****@*****.**", "Recipient #2"); message.Subject = "Sending Basic Complex Example"; message.HtmlBody = "<body><p><strong>Lorem Ipsum</strong></p><br /><img src=\"cid:Bus\" /></body>"; message.PlainTextBody = "Lorem Ipsum"; message.CharSet = "utf-8"; message.From.Email = "*****@*****.**"; message.ReplyTo.Email = "*****@*****.**"; message.MailingId = "MyMailingId"; message.MessageId = "MyMsgId"; message.CustomHeaders.Add("x-mycustomheader", "I am a message header"); var attachment = message.Attachments.Add("bus.png", MimeType.PNG, @".\examples\img\bus.png"); attachment.ContentId = "Bus"; return(client.Send(message)); }
public void InequalByOthersNullArgs() { var msg = new BasicMessage("test", 1); var msg2 = new BasicMessage("test", null); Assert.False(msg.Equals(msg2)); }
private void UnselectObject(BasicMessage m = null) { _gizmo.Clear(); _selectedObject.Select(false); _editionSceneObject.Reset(); Messenger.Notify(EditorEvent.SceneObjectUnSelected); }
public void InequalByType() { var msg = new BasicMessage("test", 1); var msg2 = new BasicMessage("tot", 1); Assert.False(msg.Equals(msg2)); }
public async Task Invoke(BasicMessage basicMessage) { using var scope = scopeFactory.CreateScope(); var middlewares = LoadMiddlewares(scope); var middlewareInvoker = new MiddlewareInvoker(middlewares); await middlewareInvoker.Invoke(new MiddlewareContext(basicMessage)); }
public void InequalByParameterAmount() { var msg = new BasicMessage("test", 1); var msg2 = new BasicMessage("test", 1, 2); Assert.False(msg.Equals(msg2)); }
public void TryReadMessageTestTwoCompleteMessage() { // Create a message to write as received in buffer byte[] fakeBody = new byte[10]; AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody); // Prepare the received buffer SocketStateObject state = new SocketStateObject(); int offset = messageToWrite1.Header.Write(state.buffer, 0); offset += fakeBody.Length; fakeBody = new byte[15]; AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody); offset = messageToWrite2.Header.Write(state.buffer, offset); offset += fakeBody.Length; // Call the TryRead AbstractMessage message = new BasicMessage(); int byteRead = offset; AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead); Assert.IsNotNull(actual); Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength); Assert.IsNull(state.message); Assert.IsNotNull(state.pendingBuffer); actual = AbstractMessage.TryReadMessage(message, state, 0); Assert.IsNotNull(actual); Assert.AreEqual(actual.MessageLength, messageToWrite2.MessageLength); Assert.IsNull(state.message); Assert.IsNull(state.pendingBuffer); }
public async Task Should_Be_Able_To_Ack_Messages_And_Then_Full_List() { using (var client = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var message = new BasicMessage { Prop = "Get me, get it?" }; var conventions = new NamingConventions(); var exchangeName = conventions.ExchangeNamingConvention(message.GetType()); TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null); TestChannel.ExchangeDeclare(conventions.ExchangeNamingConvention(message.GetType()), ExchangeType.Topic); TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), exchangeName, conventions.RoutingKeyConvention(message.GetType()) + ".#"); await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName))); await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName))); await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName))); /* Test */ var ackable = await client.GetManyAsync <BasicMessage>(3); ackable.Content[1].Ack(); ackable.Ack(); TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType())); TestChannel.ExchangeDelete(exchangeName); /* Assert */ Assert.True(true); } }
public async Task Should_Be_Able_To_Return_Reject_With_Requeue_From_Subscriber_With_Context() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var firstSubscriber = ZyRabbitFactory.CreateTestClient()) using (var secondSubscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var firstTsc = new TaskCompletionSource <BasicMessage>(); var secondTsc = new TaskCompletionSource <BasicMessage>(); await firstSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) => { firstTsc.TrySetResult(received); return(new Reject()); }); await secondSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) => { secondTsc.TrySetResult(received); return(new Ack()); }); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message); Task.WaitAll(firstTsc.Task, secondTsc.Task); /* Assert */ Assert.Equal(message.Prop, firstTsc.Task.Result.Prop); Assert.Equal(message.Prop, secondTsc.Task.Result.Prop); } }
public async Task Should_Be_Able_To_Get_Message_When_Batch_Size_Is_Smaller_Than_Queue_Length() { using (var client = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var message = new BasicMessage { Prop = "Get me, get it?" }; var conventions = new NamingConventions(); var exchangeName = conventions.ExchangeNamingConvention(message.GetType()); TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null); TestChannel.ExchangeDeclare(conventions.ExchangeNamingConvention(message.GetType()), ExchangeType.Topic); TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), conventions.ExchangeNamingConvention(message.GetType()), conventions.RoutingKeyConvention(message.GetType()) + ".#"); await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName))); await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName))); await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName))); /* Test */ var ackable = await client.GetManyAsync <BasicMessage>(2); TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType())); TestChannel.ExchangeDelete(exchangeName); /* Assert */ Assert.NotNull(ackable); Assert.Equal(ackable.Content.Count, 2); } }
public async Task Should_Be_Able_To_Return_Ack_From_Subscriber_With_Context() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var subscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var receivedTcs = new TaskCompletionSource <BasicMessage>(); await subscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) => { receivedTcs.TrySetResult(received); return(new Ack()); }); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message); await receivedTcs.Task; /* Assert */ Assert.Equal(message.Prop, receivedTcs.Task.Result.Prop); } }
/// <summary> /// 按钮点击事件-查询出入信息 /// </summary> /// <param name="sender">事件源</param> /// <param name="e">事件参数</param> private void QueryBtn_Click(object sender, RoutedEventArgs e) { if (!string.IsNullOrEmpty(moldNR)) { ConditionServiceClient conditionclient = new ConditionServiceClient(); BasicMessage msg = new BasicMessage(); if (!conditionclient.MoldExist(moldNR)) { msg.Result = false; msg.MsgContent.Add("模具"); } if (applicantNRTB.Text.Length != 0 && !conditionclient.EmpExist(applicantNRTB.Text)) { msg.Result = false; msg.MsgContent.Add("员工"); } if (msg.Result == false) { MessageBox.Show(msg.MsgText + " 不存在,请重新输入"); return; } MoldPartInfoServiceClient client = new MoldPartInfoServiceClient(); DateTime?startDT = null; DateTime?endDT = null; startDT = startDateDP.Text.Length == 0 ? startDT : DateTime.Parse(startDateDP.Text); endDT = endDateDP.Text.Length == 0 ? endDT : DateTime.Parse(endDateDP.Text); List <StorageRecord> storageRecord = client.GetMoldApplyRecords(moldNR, applicantNRTB.Text, startDT, endDT); MoldInOutInfoDG.ItemsSource = storageRecord; } }
public SendResponse RunExample() { var message = new BasicMessage(); message.Subject = "Sending A Test Message"; message.HtmlBody = "<html>This is the Html Body of my message.</html>"; message.PlainTextBody = "This is the Plain Text Body of my message."; message.From.Email = "*****@*****.**"; message.ReplyTo.Email = "*****@*****.**"; message.To.Add("!@#$!@#$!@#$@#!$"); message.To.Add("failure.com"); message.To.Add("ImMissingSomething"); message.To.Add("Fail@@!.Me"); message.To.Add("this@works"); message.To.Add("*****@*****.**"); using (var client = new SocketLabsClient(ExampleConfig.ServerId, ExampleConfig.ApiKey) { EndpointUrl = ExampleConfig.TargetApi }) { try { var response = client.Send(message); return(response); } catch (Exception e) { Console.WriteLine(e); throw; } } }
public void AddDifferentFilteredMessages() { IFilteredMessageReceiver receiver = new FilteredMessageReceiver(); receiver.ChangeMessageFilter(typeof(IErrorMessage)); receiver.ChangeErrorFilter(2); var s = "This is a message"; var t = "And another..."; var b = "...blah..."; var u = "...and another..."; IMessage basic0 = new BasicMessage(s); IMessage basic1 = new ErrorMessage(t, 2); IMessage basic2 = new BasicMessage(u); IMessage basic3 = new ErrorMessage(b, 1); var temp = new List <IMessage>(); temp.Add(basic0); temp.Add(basic1); temp.Add(basic2); temp.Add(basic3); receiver.ReceiveAll(temp); var filteredMessages = receiver.GetAllMessages(); Assert.AreEqual(1, receiver.GetAllMessages().Count); Assert.AreNotEqual(s, receiver.GetAllMessages()[0].GetMessage()); Assert.AreEqual(t, receiver.GetAllMessages()[0].GetMessage()); Assert.AreNotEqual(b, receiver.GetAllMessages()[0].GetMessage()); Assert.AreEqual(2, ((ErrorMessage)receiver.GetAllMessages()[0]).GetErrorLevel()); Assert.AreNotEqual(u, receiver.GetAllMessages()[0].GetMessage()); }
public async Task Should_Be_Able_To_Subscribe_Without_Any_Additional_Config() { /* Setup */ using (var publisher = TestClientFactory.CreateNormal()) using (var subscriber = TestClientFactory.CreateNormal()) { var message = new BasicMessage { Prop = "Hello, world!" }; var recievedTcs = new TaskCompletionSource <BasicMessage>(); subscriber.SubscribeAsync <BasicMessage>((msg, info) => { if (msg.Prop == message.Prop) { recievedTcs.SetResult(msg); } return(Task.FromResult(true)); }); /* Test */ publisher.PublishAsync(message); await recievedTcs.Task; /* Assert */ Assert.Equal(expected: message.Prop, actual: recievedTcs.Task.Result.Prop); } }
public async Task Should_Work_Without_Any_Additional_Configuration() { using (var publisher = ZyRabbitFactory.CreateTestClient()) using (var subscriber = ZyRabbitFactory.CreateTestClient()) { /* Setup */ var receivedTcs = new TaskCompletionSource <BasicMessage>(); await subscriber.SubscribeAsync <BasicMessage>(received => { receivedTcs.TrySetResult(received); return(Task.FromResult(true)); }); var message = new BasicMessage { Prop = "Hello, world!" }; /* Test */ await publisher.PublishAsync(message); await receivedTcs.Task; /* Assert */ Assert.Equal(message.Prop, receivedTcs.Task.Result.Prop); } }