private void HandleMessage(object sender, BasicDeliverEventArgs ea)
{
var data = Encoding.UTF8.GetString(ea.Body.ToArray());
var message = new MqMessage(data, ea.BasicProperties.CorrelationId, ea.BasicProperties.Type, ea.BasicProperties.ReplyTo);
this.Received.Invoke(this, message);
}
public void CreateOrder(OrderInput input)
{
if (input.Details == null || !input.Details.Any())
{
throw new KnownException("订单错误找不到详情");
}
var header = _mapper.Map <OrderHeader>(input);
var details = _mapper.Map <List <Data.OrderDetail> >(input.Details);
details.ForEach(x => x.ParentId = header.Id);
header.Amount = details.Sum(x => x.Price * x.Quantity);
var msg = _mapper.Map <OrderCreatedEvent>(header);
msg.Details = _mapper.Map <List <Message.OrderDetail> >(details);
var dbMessage = new MqMessage()
{
Body = JsonConvert.SerializeObject(msg, new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
DateFormatString = "yyyy-MM-dd hh:mm:ss"
}),
MessageAssemblyName = typeof(OrderCreatedEvent).Assembly.GetName().Name,
MessageClassFullName = msg.GetType().FullName
};
_dbContext.Add(dbMessage);
_dbContext.Add(header);
_dbContext.AddRange(details);
_dbContext.SaveChanges();
}
public async Task GetMessageAsync_BatchWithDelete()
{
PassiveMqQueuClient client = this.Account.CreateQueueClient($"myTestQueue-{Guid.NewGuid()}");
await client.DeleteIfExists();
try
{
await client.CrateIfNotExists();
for (int i = 1; i < 10; i++)
{
await client.AddMessage(new MqCreateMessage(i.ToString()));
}
await Task.Delay(50);
List <int> results = new List <int>();
for (int i = 1; i < 10; i++)
{
MqMessage message = await client.GetMessage();
results.Add(int.Parse(message.AsString));
await Task.Delay(3);
await client.DeleteMessage(message.Id);
}
CollectionAssert.AllItemsAreUnique(results, "GetMessageAsync rerurns multiple same result.");
}
finally
{
await client.DeleteIfExists();
}
}
public async Task GetMessageAsync_CheckValues(string message, string label)
{
PassiveMqQueuClient client = this.Account.CreateQueueClient("myTestQueue");
await client.DeleteIfExists();
try
{
await client.CrateIfNotExists();
await client.AddMessage(new MqCreateMessage(message, label));
MqMessage realMessage = await client.GetMessage();
Assert.AreEqual(message, realMessage.AsString);
Assert.AreEqual(label, realMessage.Label);
Assert.AreNotEqual(Guid.Empty, realMessage.Id);
Assert.AreNotEqual(default(DateTime), realMessage.InsertionTime);
Assert.AreNotEqual(null, realMessage.NextVisibleTime);
}
finally
{
await client.DeleteIfExists();
}
}
/// <summary>
/// 消息发布
/// </summary>
/// <param name="exchange">交换器</param>
/// <param name="type">交换器类型</param>
/// <param name="queue">消息队列</param>
/// <param name="message">消息</param>
/// <param name="routingKey">路由键</param>
internal void Publish(string type, string queue, MqMessage message, string routingKey)
{
try
{
string exchange = Config.MqConfig.AppID + "_" + type.ToString().ToLower();
string sendMessage = JsonConvert.SerializeObject(message);
//信道
using (var channel = MqConnection.GetMqConnection().CreateModel())
{
//Exchange
channel.ExchangeDeclare(exchange, type, true, false, null);
//声明队列
channel.QueueDeclare(queue, true, false, false, null);
//队列绑定
channel.QueueBind(queue, exchange, routingKey, null);
IBasicProperties props = channel.CreateBasicProperties();
props.ContentType = "json";
props.DeliveryMode = 2;
//过期时间
//props.Expiration = "36000000";
//发布消息
channel.BasicPublish(exchange, routingKey, props, Encoding.UTF8.GetBytes(sendMessage));
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task Publisher_PublishAsync_CheckMatch(string topicClient, string publishTopic, bool match)
{
string message = "my test message";
string label = "myLabel";
PassiveMqQueuClient clientConsumer = this.Account.CreateQueueClient("myTestQueue");
PassiveMqPublishClient publisher = this.Account.CreatePublishClient();
try
{
await clientConsumer.DeleteIfExists();
await clientConsumer.CrateIfNotExists(topicClient);
await publisher.Publish(publishTopic, new MqCreateMessage(message, label));
MqMessage resultMessage = await clientConsumer.GetMessage();
Assert.AreEqual(match, resultMessage != null, $"Inconsistent topic client '{topicClient}', topic publish '{publishTopic}', excepted match {match}.");
if (match == true)
{
Assert.AreEqual(message, resultMessage.AsString);
Assert.AreEqual(label, resultMessage.Label);
}
}
finally
{
await clientConsumer.DeleteIfExists();
}
}
public async Task GetMessageAsync_VisibilityTime()
{
PassiveMqQueuClient client = this.Account.CreateQueueClient("myTestQueue");
await client.DeleteIfExists();
try
{
await client.CrateIfNotExists();
await client.AddMessage(new MqCreateMessage("some messagefor MOM"));
MqMessage realMessage = await client.GetMessage(TimeSpan.FromSeconds(5));
Assert.IsNotNull(realMessage);
Assert.AreEqual(1, realMessage.RetryCount);
MqMessage realNextMessage = await client.GetMessage();
Assert.IsNull(realNextMessage);
await Task.Delay(10000);
MqMessage realRentrantMessage = await client.GetMessage();
Assert.IsNotNull(realRentrantMessage);
Assert.AreEqual(2, realRentrantMessage.RetryCount);
}
finally
{
await client.DeleteIfExists();
}
}
/// <summary>
/// Gets an available cached instance of the serializer. If one is not cached, generate a new one.
/// </summary>
/// <param name="message">Message to initialize the MqReader with. Null to just reset.</param>
/// <returns>Cached serializer.</returns>
public Serializer Get(MqMessage message = null)
{
Serializer serializer;
// Try to get an existing cached serializer.
if (_cachedContainers.TryDequeue(out serializer) == false)
{
// A cached serializer does not exist. Create a new one.
var mqWriter = new MqMessageWriter(_config);
var mqReader = new MqMessageReader();
serializer = new Serializer
{
MessageWriter = mqWriter,
MessageReader = mqReader,
Stream = new MemoryStream()
};
}
else
{
serializer.Stream.SetLength(0);
serializer.MessageWriter.Clear();
}
serializer.MessageReader.Message = message;
return(serializer);
}
public EventHandlerResult Handle(MqMessage <string> msg)
{
Console.WriteLine("FACE !!!");
var model = JsonConvert.DeserializeObject <FaceDetectedEvent>(msg.Payload);
var cmd = new IdentifyFaceCmd()
{
ImageId = model.ImageId,
ImageUrl = model.ImageUrl,
X = model.X,
Y = model.Y,
Width = model.Width,
Height = model.Height
};
IBasicProperties props = _client.Model.CreateBasicProperties();
_client.Model.BasicPublish("msg_gateway", "vision.cmd.identify-face", true, props, RabbitMqMessageHelper.GetModelAsMessagePayload(cmd));
_client.AckMessage(msg.DeliveryTag);
return(new EventHandlerResult()
{
Success = true, MessageAcked = true
});
}
public async Task AddMessageAsync_Success(string messageText, string label)
{
PassiveMqQueuClient client = this.Account.CreateQueueClient("myTestQueue");
await client.DeleteIfExists();
try
{
await client.CrateIfNotExists();
MqCreateMessage sendMessage = new MqCreateMessage(messageText, label);
MqMessage createdMessage = await client.AddMessage(sendMessage);
Assert.IsNotNull(createdMessage);
Assert.AreEqual(messageText, createdMessage.AsString);
Assert.AreEqual(label, createdMessage.Label);
Assert.AreNotEqual(Guid.Empty, createdMessage.Id);
Assert.AreNotEqual(default(DateTime), createdMessage.InsertionTime);
}
finally
{
await client.DeleteIfExists();
}
}
public async Task Consume(MqMessage <QueueRequestMessage> message)
{
var processingReqDetails = await _api.Request(s => s.MakeRequestProcessing(message.Payload.Id)).GetDetailedAsync();
_reporter?.Report(processingReqDetails);
var request = JsonConvert.DeserializeObject <T>(message.Payload.Content);
var procOperator = new ProcessingOperator(message.Payload.Id, _api)
{
Reporter = _reporter
};
try
{
await _logic.ProcessAsync(request, procOperator);
}
catch (InterruptConsumingException)
{
throw;
}
catch (Exception e)
{
var completeWithErrorReqDetails = await _api.Request(s => s.CompleteWithErrorAsync(message.Payload.Id, new ProcessingError
{
TechMessage = e.Message,
TechInfo = e.ToString()
})).GetDetailedAsync();
_reporter?.Report(completeWithErrorReqDetails);
}
}
/// <summary>
/// Processes the incoming return value message from the recipient connection.
/// </summary>
/// <param name="message">Message containing the frames for the return value.</param>
private void ProcessRpcReturn(MqMessage message)
{
// Execute the processing on the worker thread.
Task.Run(() => {
// Retrieve a serialization cache to work with.
var serialization = Session.SerializationCache.Get(message);
try {
// Skip message type byte and message type.
serialization.MessageReader.Skip(2);
// Read the return Id.
var return_id = serialization.MessageReader.ReadUInt16();
RpcWaitHandle call_wait_handle;
// Try to get the outstanding wait from the return id. If it does not exist, the has already completed.
if (LocalWaitHandles.TryRemove(return_id, out call_wait_handle))
{
call_wait_handle.ReturnMessage = message;
// Release the wait event.
call_wait_handle.ReturnResetEvent.Set();
}
} finally {
Session.SerializationCache.Put(serialization);
}
});
}
public EventHandlerResult Handle(MqMessage <string> msg)
{
//channel.BasicAck(bdea.DeliveryTag, false);
return(new EventHandlerResult()
{
Success = true, MessageAcked = false
});
}
public async Task GetMessageAsync_Batch()
{
string message = "my test message";
string label = "myLabel";
PassiveMqQueuClient clientConsumer1 = this.Account.CreateQueueClient("myTestQueue1");
PassiveMqQueuClient clientConsumer2 = this.Account.CreateQueueClient("myTestQueue2");
PassiveMqQueuClient clientConsumer3 = this.Account.CreateQueueClient("myTestQueue3");
PassiveMqQueuClient clientConsumer4 = this.Account.CreateQueueClient("myTestQueue4");
PassiveMqQueuClient clientConsumerNull = this.Account.CreateQueueClient("myTestQueueNull");
PassiveMqPublishClient publisher = this.Account.CreatePublishClient();
try
{
await clientConsumer1.DeleteIfExists();
await clientConsumer1.CrateIfNotExists("/myTestConsumer/aa");
await clientConsumer2.DeleteIfExists();
await clientConsumer2.CrateIfNotExists("/myTestConsumer/aa/bb");
await clientConsumer3.DeleteIfExists();
await clientConsumer3.CrateIfNotExists("/myTestConsumer/aa/bb/cc");
await clientConsumer4.DeleteIfExists();
await clientConsumer4.CrateIfNotExists("/myTestConsumer/bb/4");
await publisher.Publish("/myTestConsumer/aa/bb/cc/75", new MqCreateMessage(message, label));
MqMessage message1 = await clientConsumer1.GetMessage();
MqMessage message2 = await clientConsumer2.GetMessage();
MqMessage message3 = await clientConsumer3.GetMessage();
MqMessage message4 = await clientConsumer4.GetMessage();
Assert.IsNotNull(message1);
Assert.IsNotNull(message2);
Assert.IsNotNull(message3);
Assert.IsNull(message4);
}
finally
{
await clientConsumer1.DeleteIfExists();
await clientConsumer2.DeleteIfExists();
await clientConsumer3.DeleteIfExists();
await clientConsumer4.DeleteIfExists();
}
}
public MqBuilder withMessage(MqMessage message)
{
if (message == null)
{
throw new ArgumentException("传入参数错误");
}
this.message = message;
return(this);
}
public async Task Consume(MqMessage <QueueRequestMessage> message)
{
await _logic.CompleteWithErrorAsync(message.Payload.Id, new ProcessingError
{
TechMessage = "The request was placed in the dead letter"
});
_log.Warning("The request was placed in the dead letter")
.AndFactIs("request-id", message.Payload.Id)
.Write();
}
public Task Consume(MqMessage <TestMqMsg> message)
{
if (Box.RejectedMsg == null)
{
Box.RejectedMsg = message;
throw new Exception("Reject");
}
Box.AckMsg = message;
return(Task.CompletedTask);
}
public async Task <IActionResult> Index()
{
var model = new MqMessage
{
Id = 1,
Message = "Message text"
};
await _rmqlClient.PushAsync <TestWorker, MqMessage>(model);
return(View());
}
public void SendHandlerMessage(byte actionId, MqMessage message)
{
var headerFrame = Session.CreateFrame(new byte[2], MqFrameType.More);
headerFrame.Write(0, Id);
headerFrame.Write(1, actionId);
var sendMessage = new MqMessage
{
headerFrame,
message
};
Session.Send(sendMessage);
}
public static MqMessage <T> Create <T>(ReadOnlyMemory <byte> binBody, IBasicProperties basicProperties)
{
var bodyStr = Encoding.UTF8.GetString(binBody.ToArray());
T payload;
if (typeof(T) == typeof(string))
{
payload = (T)(object)bodyStr;
}
else
{
try
{
payload = JsonConvert.DeserializeObject <T>(bodyStr);
}
catch (Exception e)
{
throw new JsonMessageSerializationException(bodyStr, e);
}
}
var props = basicProperties;
var msg = new MqMessage <T>(payload)
{
ReplyTo = props.ReplyTo
};
if (Guid.TryParse(props.CorrelationId, out var correlationId))
{
msg.CorrelationId = correlationId;
}
if (Guid.TryParse(props.MessageId, out var messageId))
{
msg.MessageId = messageId;
}
if (props.Headers != null)
{
msg.Headers = props.Headers
.Select(h => new MqHeader
{
Name = h.Key,
Value = h.Value.ToString()
})
.ToArray();
}
return(msg);
}
static void MqInProcessTest()
{
var config = new MqConfig
{
Ip = "127.0.0.1",
Port = 2828
};
Console.WriteLine("FrameBufferSize: {0}; SendAndReceiveBufferSize: {1}\r\n", config.FrameBufferSize,
config.SendAndReceiveBufferSize);
var smallMessage = new MqMessage
{
new MqFrame(SequentialBytes(50), MqFrameType.More, config),
new MqFrame(SequentialBytes(50), MqFrameType.More, config),
new MqFrame(SequentialBytes(50), MqFrameType.More, config),
new MqFrame(SequentialBytes(50), MqFrameType.Last, config)
};
MqInProcessPerformanceTests(1000000, 5, smallMessage, config);
var medimumMessage = new MqMessage
{
new MqFrame(SequentialBytes(500), MqFrameType.More, config),
new MqFrame(SequentialBytes(500), MqFrameType.More, config),
new MqFrame(SequentialBytes(500), MqFrameType.More, config),
new MqFrame(SequentialBytes(500), MqFrameType.Last, config)
};
MqInProcessPerformanceTests(100000, 5, medimumMessage, config);
var largeMessage = new MqMessage();
for (int i = 0; i < 20; i++)
{
largeMessage.Add(new MqFrame(SequentialBytes(3000), MqFrameType.More, config));
}
MqInProcessPerformanceTests(10000, 5, largeMessage, config);
Console.WriteLine("Performance complete");
Console.ReadLine();
}
public async Task CorrectlyHandlesOriginalExchangeAsync()
{
const string originalExchange = "original-exchange";
const string originalRoutingKey = "original-routing-key";
var msg = new MyIntegrationEvent();
var mqMessage = new MqMessage(JsonConvert.SerializeObject(msg), "Type", "1.0", "1.0", "myApp");
var args = new BasicDeliverEventArgs
{
RoutingKey = "some-key",
Exchange = "some-exchange",
BasicProperties = new FakeOptions
{
Headers = new Dictionary <string, object>
{
[RetryExtensions.ORIGINAL_EXCHANGE_HEADER] = Encoding.UTF8.GetBytes(originalExchange),
[RetryExtensions.ORIGINAL_ROUTING_KEY_HEADER] = Encoding.UTF8.GetBytes(originalRoutingKey)
},
ContentType = "application/json",
ContentEncoding = "UTF8"
},
Body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(mqMessage))
};
var subscriberSettingsDto = new SubscriberSettingsDto("MySubscriberName")
{
TracingSettings = new TracingSettingsDto
{
LogWhenMessageIncome = true
}
};
var(_, ctx) = await _subscriber.HandleMessageAsync <MyIntegrationEvent>(
args,
x => Task.FromResult <Acknowledgement>(Ack.Ok),
subscriberSettingsDto.Create(null !)
);
Assert.Multiple(() =>
{
Assert.AreEqual(originalExchange, ctx.MessageData.Exchange, "Оригинальный обменник не установлен.");
Assert.AreEqual(originalRoutingKey, ctx.MessageData.RoutingKey, "Оригинальный ключ роутинга не установлен.");
});
}
/// <summary>
/// 消息订阅
/// </summary>
/// <param name="exchange">交换器</param>
/// <param name="type">交换器类型</param>
/// <param name="queue">消息队列</param>
/// <param name="routingKey">路由键</param>
internal void Subscribe(string type, string queue, List <string> listRoutingKey)
{
try
{
string exchange = Config.MqConfig.AppID + "_" + type.ToString().ToLower();
//信道
var channel = MqConnection.GetMqConnection().CreateModel();
//Exchange
channel.ExchangeDeclare(exchange, type, true, false, null);
//声明队列
channel.QueueDeclare(queue, true, false, false, null);
//队列绑定
listRoutingKey.ForEach(routingKey =>
{
channel.QueueBind(queue, exchange, routingKey, null);
});
//消费者
var consumer = new EventingBasicConsumer(channel);
//触发事件
consumer.Received += (sender, ea) =>
{
var msg = Encoding.UTF8.GetString(ea.Body);
MqMessage message = JsonConvert.DeserializeObject <MqMessage>(msg);
MessageListening(sender, message);
//确认接收
channel.BasicAck(ea.DeliveryTag, false);
};
//程序主动应答
channel.BasicConsume(queue: queue,
autoAck: false,
consumer: consumer);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task PeekMessageAsync_Empty()
{
PassiveMqQueuClient client = this.Account.CreateQueueClient("myTestQueue");
await client.DeleteIfExists();
try
{
await client.CrateIfNotExists();
MqMessage nullMessage = await client.PeekMessage();
Assert.IsNull(nullMessage);
}
finally
{
await client.DeleteIfExists();
}
}
public async Task CorrectlyHandlesPoisonedMessageAsync(int alreadyRetriedCount, bool shouldRetryOneMoreTime)
{
var mqMessage = new MqMessage(
JsonConvert.SerializeObject(new MyIntegrationEvent()),
"Type",
"1.0",
"1.0",
"myApp"
);
var args = new BasicDeliverEventArgs
{
DeliveryTag = 123,
RoutingKey = "some-key",
Exchange = "some-exchange",
BasicProperties = new FakeOptions
{
Headers = new Dictionary <string, object>
{
[PoisonedMessageExtensions.RETRY_CNT_KEY] = alreadyRetriedCount
},
ContentType = "application/json",
ContentEncoding = "UTF8"
},
Body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(mqMessage))
};
var subscriberSettingsDto = new SubscriberSettingsDto("MySubscriberName");
var(acknowledgement, ctx) = await _subscriber.HandleMessageAsync <MyIntegrationEvent>(
args,
_ => throw new Exception("Unhandled exception!"),
subscriberSettingsDto.Create(null !)
);
Assert.Multiple(() =>
{
Assert.IsInstanceOf <Reject>(acknowledgement, "Тип Acknowledgement некорректен.");
Assert.AreEqual(args.DeliveryTag, ctx.MessageData.DeliverEventArgs?.DeliveryTag, "DeliveryTag не совпадает.");
Assert.AreEqual(shouldRetryOneMoreTime, (acknowledgement as Reject)?.Requeue, "ShouldRetryOneMoreTime не совпадает.");
});
}
public void ShouldNotDeliveryWhenDeadLetterRoutingIsWrong()
{
//Arrange
var deadLetterExchange = TestExchangeFactory.Direct.CreateWithRandomId();
var deadLetterQueue = TestQueueFactory.Default.CreateWithRandomId();
deadLetterQueue.BindToExchange(deadLetterExchange, "bar");
var queueFactory = new TestQueueFactory
{
DeadLetterExchange = deadLetterExchange.Name,
DeadLetterRoutingKey = "wrong"
};
var queue = queueFactory.CreateWithRandomId();
//Act
queue.Publish("foo");
var msg = queue.Listen <string>();
msg.Nack();
MqMessage <string> deadMsg = null;
TimeoutException timeoutException = null;
try
{
deadMsg = deadLetterQueue.ListenAutoAck <string>();
}
catch (TimeoutException e)
{
timeoutException = e;
}
if (timeoutException == null)
{
_output.WriteLine("Dead message: " + (deadMsg?.Payload ?? "[null]"));
}
//Assert
Assert.NotNull(timeoutException);
}
public void CompareMessages(MqMessage expected, MqMessage actual)
{
try
{
// Total frame count comparison.
Assert.Equal(expected.Count, actual.Count);
for (int i = 0; i < expected.Count; i++)
{
// Frame length comparison.
Assert.Equal(expected[i].DataLength, actual[i].DataLength);
Assert.Equal(expected[i].Buffer, actual[i].Buffer);
}
}
catch (Exception e)
{
LastException = e;
}
}
public override bool HandleMessage(MqMessage message)
{
if (message[0][0] != Id)
{
return(false);
}
// Read the type of message.
var message_type = (RpcCallMessageType)message[0].ReadByte(1);
switch (message_type)
{
case RpcCallMessageType.MethodCancel:
// Remotely called to cancel a rpc call on this session.
var cancellation_id = message[0].ReadUInt16(2);
RpcWaitHandle wait_handle;
if (RemoteWaitHandles.TryRemove(cancellation_id, out wait_handle))
{
wait_handle.TokenSource.Cancel();
}
break;
case RpcCallMessageType.MethodCallNoReturn:
case RpcCallMessageType.MethodCall:
ProcessRpcCall(message, message_type);
break;
case RpcCallMessageType.MethodException:
case RpcCallMessageType.MethodReturn:
ProcessRpcReturn(message);
break;
default:
// Unknown message type passed. Disconnect the connection.
Session.Close(SocketCloseReason.ProtocolError);
break;
}
return(true);
}
public bool HandleMessage(MqMessage message)
{
if (message[0][0] != Id)
{
Session.Close(SocketCloseReason.ProtocolError);
}
// Read the type of message.
var messageType = message[0].ReadByte(1);
if (Handlers.ContainsKey(messageType))
{
message.RemoveAt(0);
Handlers[messageType].Invoke(messageType, message);
return(true);
}
// Unknown message type passed. Disconnect the connection.
Session.Close(SocketCloseReason.ProtocolError);
return(false);
}
public async Task DeleteMessageAsync_FromCreated()
{
PassiveMqQueuClient client = this.Account.CreateQueueClient("myTestQueue");
await client.DeleteIfExists();
try
{
await client.CrateIfNotExists();
MqMessage message = await client.AddMessage(new MqCreateMessage("some messagefor MOM"));
await client.DeleteMessage(message);
MqMessage newMessage = await client.PeekMessage();
Assert.IsNull(newMessage);
}
finally
{
await client.DeleteIfExists();
}
}
