static void ReadFailedQueueHeader(out string queueName, BasicDeliverEventArgs deliverArgs, out string machineName)
{
byte[] headerBytes = (byte[]) deliverArgs.BasicProperties.Headers["NServiceBus.FailedQ"];
var header = Encoding.UTF8.GetString(headerBytes);
queueName = header.Split('@')[0];
machineName = header.Split('@')[1];
}
public static TransportMessage ToTransportMessage(BasicDeliverEventArgs message)
{
var properties = message.BasicProperties;
if (!properties.IsMessageIdPresent() || string.IsNullOrWhiteSpace(properties.MessageId))
{
throw new InvalidOperationException("A non empty message_id property is required when running NServiceBus on top of RabbitMq. If this is a interop message please make sure to set the message_id property before publishing the message");
}
var headers = DeserializeHeaders(message);
var result = new TransportMessage(properties.MessageId, headers)
{
Body = message.Body,
};
if (properties.IsReplyToPresent())
{
result.ReplyToAddress = Address.Parse(properties.ReplyTo);
}
if (properties.IsCorrelationIdPresent())
{
result.CorrelationId = properties.CorrelationId;
}
//When doing native interop we only require the type to be set the "fullName" of the message
if (!result.Headers.ContainsKey(Headers.EnclosedMessageTypes) && properties.IsTypePresent())
{
result.Headers[Headers.EnclosedMessageTypes] = properties.Type;
}
return result;
}
string DefaultMessageIdStrategy(BasicDeliverEventArgs message)
{
var properties = message.BasicProperties;
if (!properties.IsMessageIdPresent() || string.IsNullOrWhiteSpace(properties.MessageId))
{
throw new InvalidOperationException("A non empty message_id property is required when running NServiceBus on top of RabbitMq. If this is a interop message please make sure to set the message_id property before publishing the message");
}
return properties.MessageId;
}
static Dictionary<string, string> DeserializeHeaders(BasicDeliverEventArgs message)
{
if (message.BasicProperties.Headers == null)
{
return new Dictionary<string, string>();
}
return message.BasicProperties.Headers.Cast<DictionaryEntry>()
.ToDictionary(
kvp => (string)kvp.Key,
kvp => kvp.Value == null ? null : Encoding.UTF8.GetString((byte[])kvp.Value));
}
public TransportMessage ToTransportMessage(BasicDeliverEventArgs message)
{
var properties = message.BasicProperties;
var messageId = messageIdStrategy(message);
var headers = DeserializeHeaders(message);
var result = new TransportMessage(messageId, headers)
{
Body = message.Body ?? new byte[0],
};
if (properties.IsReplyToPresent())
{
string replyToAddressNSBHeaders;
var nativeReplyToAddress = properties.ReplyTo;
if (headers.TryGetValue(Headers.ReplyToAddress, out replyToAddressNSBHeaders))
{
if (replyToAddressNSBHeaders != nativeReplyToAddress)
{
Logger.WarnFormat("Missmatching replyto address properties found, the address specified by the NServiceBus headers '{1}' will override the native one '{0}'", nativeReplyToAddress, replyToAddressNSBHeaders);
}
}
else
{
//promote the native address
headers[Headers.ReplyToAddress] = nativeReplyToAddress;
}
}
if (properties.IsCorrelationIdPresent())
{
result.CorrelationId = properties.CorrelationId;
}
//When doing native interop we only require the type to be set the "fullName" of the message
if (!result.Headers.ContainsKey(Headers.EnclosedMessageTypes) && properties.IsTypePresent())
{
result.Headers[Headers.EnclosedMessageTypes] = properties.Type;
}
if (properties.IsDeliveryModePresent())
{
result.Recoverable = properties.DeliveryMode == 2;
}
return result;
}
public void Should_set_replyto_header_if_present_in_native_message_and_not_already_set()
{
var basicDeliverEventArgs = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
ReplyTo = "myaddress",
MessageId = "Blah",
}
};
var transportMessage = converter.ToTransportMessage(basicDeliverEventArgs);
Assert.NotNull(transportMessage);
Assert.AreEqual("myaddress", transportMessage.Headers[Headers.ReplyToAddress]);
}
public void TestCanHandleByteArrayHeader()
{
var basicDeliverEventArgs = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
MessageId = "Blah",
Headers = new Dictionary<string, object>
{
{"Foo", Encoding.UTF8.GetBytes("blah")}
}
}
};
var transportMessage = converter.ToTransportMessage(basicDeliverEventArgs);
Assert.NotNull(transportMessage);
Assert.AreEqual("blah", transportMessage.Headers["Foo"]);
}
public void Should_not_override_replyto_header_if_native_replyto_is_present()
{
var basicDeliverEventArgs = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
ReplyTo = "myaddress",
MessageId = "Blah",
Headers = new Dictionary<string, object>
{
{Headers.ReplyToAddress, Encoding.UTF8.GetBytes("nsb set address")}
}
}
};
var transportMessage = converter.ToTransportMessage(basicDeliverEventArgs);
Assert.NotNull(transportMessage);
Assert.AreEqual("nsb set address", transportMessage.Headers[Headers.ReplyToAddress]);
}
public override bool Go(BasicDeliverEventArgs ea)
{
switch (ea.RoutingKey)
{
case WsMqKeyword.GetConsoleOutLinesRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
long afterTimestamp = OperationMqBodyUtil.GetGetConsoleOutLinesMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetConsoleOutLinesMqMessage(appId, loginName, timestamp, clientId, afterTimestamp));
}
}
break;
case WsMqKeyword.ConsoleOutLinesRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
var data = OperationMqBodyUtil.GetConsoleOutLinesMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new ConsoleOutLinesMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.GetLocalMessagesRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
long afterTimestamp = OperationMqBodyUtil.GetGetLocalMessagesMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetLocalMessagesMqMessage(appId, loginName, timestamp, clientId, afterTimestamp));
}
}
break;
case WsMqKeyword.LocalMessagesRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
var data = OperationMqBodyUtil.GetLocalMessagesMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new LocalMessagesMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.GetDrivesRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetDrivesMqMessage(appId, loginName, timestamp, clientId));
}
}
break;
case WsMqKeyword.DrivesRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
var data = OperationMqBodyUtil.GetDrivesMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new DrivesMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.GetLocalIpsRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetLocalIpsMqMessage(appId, loginName, timestamp, clientId));
}
}
break;
case WsMqKeyword.LocalIpsRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
var data = OperationMqBodyUtil.GetLocalIpsMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new LocalIpsMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.GetOperationResultsRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
long afterTimestamp = OperationMqBodyUtil.GetGetOperationResultsMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetOperationResultsMqMessage(appId, loginName, timestamp, clientId, afterTimestamp));
}
}
break;
case WsMqKeyword.OperationResultsRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
var data = OperationMqBodyUtil.GetOperationResultsMqReceiveBody(ea.Body);
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new OperationResultsMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.OperationReceivedRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new OperationReceivedMqMessage(appId, loginName, timestamp, clientId));
}
}
break;
case WsMqKeyword.GetSpeedRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
List <Guid> clientIds = OperationMqBodyUtil.GetGetSpeedMqReceiveBody(ea.Body);
if (clientIds != null && clientIds.Count != 0)
{
VirtualRoot.RaiseEvent(new GetSpeedMqMessage(appId, loginName, timestamp, clientIds));
}
}
break;
case WsMqKeyword.SetVirtualMemoryRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
var data = OperationMqBodyUtil.GetSetVirtualMemoryMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new SetVirtualMemoryMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.SetLocalIpsRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
var data = OperationMqBodyUtil.GetSetLocalIpsMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new SetLocalIpsMqMessage(appId, loginName, timestamp, clientId, data));
}
}
break;
case WsMqKeyword.SwitchRadeonGpuRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
bool on = OperationMqBodyUtil.GetSwitchRadeonGpuMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new SwitchRadeonGpuMqMessage(appId, loginName, timestamp, clientId, on));
}
}
break;
case WsMqKeyword.GetSelfWorkLocalJsonRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetSelfWorkLocalJsonMqMessage(appId, loginName, timestamp, clientId));
}
}
break;
case WsMqKeyword.SelfWorkLocalJsonRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
string json = OperationMqBodyUtil.GetSelfWorkLocalJsonMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new LocalJsonMqMessage(appId, loginName, timestamp, clientId, json));
}
}
break;
case WsMqKeyword.SaveSelfWorkLocalJsonRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
WorkRequest request = OperationMqBodyUtil.GetSaveSelfWorkLocalJsonMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new SaveSelfWorkLocalJsonMqMessage(appId, loginName, timestamp, clientId, request));
}
}
break;
case WsMqKeyword.GetGpuProfilesJsonRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new GetGpuProfilesJsonMqMessage(appId, loginName, timestamp, clientId));
}
}
break;
case WsMqKeyword.GpuProfilesJsonRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
string json = OperationMqBodyUtil.GetGpuProfilesJsonMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new GpuProfilesJsonMqMessage(appId, loginName, timestamp, clientId, json));
}
}
break;
case WsMqKeyword.SaveGpuProfilesJsonRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
string json = OperationMqBodyUtil.GetSaveGpuProfilesJsonMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new SaveGpuProfilesJsonMqMessage(appId, loginName, timestamp, clientId, json));
}
}
break;
case WsMqKeyword.UpgradeNTMinerRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
string ntminerFileName = OperationMqBodyUtil.GetUpgradeNTMinerMqReceiveBody(ea.Body);
if (!string.IsNullOrEmpty(ntminerFileName))
{
VirtualRoot.RaiseEvent(new UpgradeNTMinerMqMessage(appId, loginName, timestamp, clientId, ntminerFileName));
}
}
}
break;
case WsMqKeyword.StartMineRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
Guid workId = OperationMqBodyUtil.GetStartMineMqReceiveBody(ea.Body);
VirtualRoot.RaiseEvent(new StartMineMqMessage(appId, loginName, timestamp, clientId, workId));
}
}
break;
case WsMqKeyword.StopMineRoutingKey: {
string loginName = ea.BasicProperties.ReadHeaderString(MqKeyword.LoginNameHeaderName);
DateTime timestamp = Timestamp.FromTimestamp(ea.BasicProperties.Timestamp.UnixTime);
string appId = ea.BasicProperties.AppId;
if (ea.BasicProperties.ReadHeaderGuid(WsMqKeyword.ClientIdHeaderName, out Guid clientId))
{
VirtualRoot.RaiseEvent(new StopMineMqMessage(appId, loginName, timestamp, clientId));
}
}
break;
default:
return(false);
}
return(true);
}
private Task ConsumerOnReceived(object sender, BasicDeliverEventArgs eventArgs) => _messageHandlingPipelineExecutingService.Execute(eventArgs, this);
public override void Received(object sender, BasicDeliverEventArgs e)
{
Console.WriteLine($"消费者{ServiceKey}：收到消息：{e.Body.ToString()}");
}
internal ConsumedMessage(Object content, BasicDeliverEventArgs args)
: base(args)
{
Content = content;
}
private void ConnectAndMonitor()
{
this.MonitorTask = new Task(() =>
{
var count = 0;
var subscription = new Subscription(RMQChannel, QueueName);
BasicDeliverEventArgs bdea = default(BasicDeliverEventArgs);
while (this.RMQChannel.IsOpen)
{
var gotMessage = subscription.Next(100, out bdea);
if (gotMessage)
{
var payload = new StandardPayload();
try
{
var msgText = string.Format("{0}{1}. {2} => {3}{0}", Environment.NewLine, ++count, bdea.Exchange, bdea.RoutingKey);
//var msgText = string.Format("{3}. {0}: {1} -> '{2}'", bdea.Exchange, bdea.RoutingKey, Encoding.UTF8.GetString(bdea.Body), ++count);
if (SMQActorBase.IsDebugMode)
{
Console.WriteLine(msgText);
}
var body = Encoding.UTF8.GetString(bdea.Body);
payload = JsonConvert.DeserializeObject <StandardPayload>(body, this.DefaultJsonSerializerSettings);
if (ReferenceEquals(payload, null))
{
payload = new StandardPayload()
{
ErrorMessage = "Payload missing."
}
}
;
this.OnMessageReceived(payload, bdea);
this.CheckRouting(payload, bdea);
}
catch (Exception ex)
{
payload.ErrorMessage = ex.Message;
this.Reply(payload, bdea.BasicProperties);
}
this.OnAfterMessageReceived(payload, bdea);
}
}
try
{
if (this.RMQChannel.IsOpen)
{
this.RMQChannel.Close();
}
}
catch { } // Ignore errors on closing the channel
try
{
if (this.RMQConnection.IsOpen)
{
this.RMQConnection.Close();
}
}
catch { } // Ignore errrors on closing connection
});
this.MonitorTask.Start();
}
private UserMessage GetValidMessage(BasicDeliverEventArgs args)
{
var message = _parser.ParseMessage <UserMessage>(args);
return(message);
}
public static bool HasNoErrors(this StandardPayload payloadWithPossibleError, BasicDeliverEventArgs bdea)
{
if (!String.IsNullOrEmpty(payloadWithPossibleError.ErrorMessage))
{
throw new Exception(String.Format("{0} - {1}", bdea.RoutingKey, payloadWithPossibleError.ErrorMessage));
}
else
{
return(true);
}
}
public PayloadEventArgs(BasicDeliverEventArgs bdea)
: this(default(StandardPayload), bdea)
{
}
private void Consume(object model, BasicDeliverEventArgs eventArgs)
{
vcount++;
using var scope = serviceProvider.CreateScope();
var sp = scope.ServiceProvider;
try
{
var body = eventArgs.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
if (string.IsNullOrEmpty(message))
{
rabbit.Channel.BasicAck(eventArgs.DeliveryTag, false);
}
var dto = Newtonsoft.Json.JsonConvert.DeserializeObject <LogModel>(message);
var key = dto.ClientName + "|" + dto.EnvironmentName;
if (DataHolder.ContainsKey(key))
{
DataHolder[key].Add(dto);
}
else
{
DataHolder.TryAdd(key, new ConcurrentBag <LogModel>()
{
dto
});
}
DataHolder[key] = new ConcurrentBag <LogModel>(DataHolder[key].Where(x => x.HappenTime > DateTime.Now.AddMinutes(-80))); //只留80分钟内的
if (!dto.Success && dto.HappenTime > DateTime.Now.AddMinutes(-5)) //只有未成功时需要处理，再过滤掉可能是缓存的；假设服务器间时间差不大于5分钟。
{
var svc = sp.GetService <IAlertServicecs>();
var config = svc.GetAlertConfig(dto.ClientName);
var baseTime = dto.HappenTime.AddMinutes(-config.MinutesCatchedForProcess);
var callCount = DataHolder[key].Count(x => x.HappenTime > baseTime);
var failCount = DataHolder[key].Count(x => x.HappenTime > baseTime && !x.Success);
var messageCallCount = DataHolder[key].Count(x => x.HappenTime > baseTime && x.Message == dto.Message);
var messageFailCount = DataHolder[key].Count(x => x.HappenTime > baseTime && x.Message == dto.Message && !x.Success);
var thisMessageConfig = config.AlterSettings.Where(x => x.Message == dto.Message).FirstOrDefault();
if (thisMessageConfig == null)
{
thisMessageConfig = config.AlterSettings.Where(x => x.Message == "*").FirstOrDefault();
}
if (thisMessageConfig == null)
{
thisMessageConfig = new MessageAlertDetailConfig()
{
LowestFailRate = 20, LowestFailCount = 3
}
}
;
var messageNeedAlert = (messageFailCount * 100 / messageCallCount) >= thisMessageConfig.LowestFailRate && messageFailCount >= thisMessageConfig.LowestFailCount;//暂时的规则：错误率 20%以上 且采样数至少3个
if (messageNeedAlert)
{
svc.Alert(dto.ClientName, dto.EnvironmentName, dto.Message, 1, messageCallCount, messageFailCount);
}
else
{
var zongtiConfig = config.AlterSettings.Where(x => x.Message == "**").FirstOrDefault();
if (zongtiConfig == null)
{
zongtiConfig = new MessageAlertDetailConfig()
{
LowestFailRate = 5, LowestFailCount = 5
}
}
;
var needAlert = (failCount * 100 / callCount) > zongtiConfig.LowestFailRate && failCount >= zongtiConfig.LowestFailCount;
if (needAlert)
{
svc.Alert(dto.ClientName, dto.EnvironmentName, "", 1, callCount, failCount);
}
}
}
rabbit.Channel.BasicAck(eventArgs.DeliveryTag, false);
}
catch (Exception ex)
{
var logger = sp.GetService <ILogger <AnalyzerService> >();
if (logger != null)
{
logger.LogError(ex.Message);
logger.LogWarning(ex.StackTrace);
}
else
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
rabbit.Channel.BasicReject(eventArgs.DeliveryTag, true);
}
}
private async Task Process(ConsumerInfo consumer, ConsumerChild consumerChild, BasicDeliverEventArgs ea, int count)
{
if (count > 0)
{
await Task.Delay(count * 1000);
}
try
{
await consumer.Handler.Notice(ea.Body);
if (!consumer.AutoAck)
{
try
{
consumerChild.Channel.Model.BasicAck(ea.DeliveryTag, false);
}
catch
{
consumerChild.NeedRestart = true;
}
}
}
catch (Exception exception)
{
logger.LogError(exception.InnerException ?? exception, $"An error occurred in {consumer.Exchange}-{consumer.Queue}");
if (consumer.ErrorReject)
{
consumerChild.Channel.Model.BasicReject(ea.DeliveryTag, true);
}
else
{
if (count > 3)
{
consumerChild.NeedRestart = true;
}
else
{
await Process(consumer, consumerChild, ea, count + 1);
}
}
}
}
private void Consumer_Received(object sender, BasicDeliverEventArgs e)
{
messageRecieved.ProcessMessage(Encoding.UTF8.GetString(e.Body));
channel.BasicAck(e.DeliveryTag, false);
autoResetEvent.Set();
}
private void OnMessage(object sender, BasicDeliverEventArgs basicDeliverEventArgs)
{
if (!this.model.IsOpen)
{
//Dispose ConsumerWorker
this.Dispose();
//Throw AlreadyClosedException (model is already closed)
throw new RabbitMQ.Client.Exceptions.AlreadyClosedException(this.model.CloseReason);
}
byte[] bodyBytes = basicDeliverEventArgs.Body.ToArray();
string messageBody = Encoding.UTF8.GetString(bodyBytes);
object messageObject = null;
try
{
messageObject = Newtonsoft.Json.JsonConvert.DeserializeObject(messageBody, this.expectedType);
}
catch (Exception exception)
{
var deserializationException = new DeserializationException("Unable to deserialize data.", exception)
{
SerializedDataString = messageBody,
SerializedDataBinary = bodyBytes,
QueueName = this.queueName
};
//Pass DeserializationException to RejectionHandler
this.messageRejectionHandler.OnRejection(deserializationException);
//Remove message from queue after RejectionHandler dealt with it
this.Nack(basicDeliverEventArgs.DeliveryTag, false);
}
//If message has been successfully deserialized and messageObject is populated
if (messageObject != null)
{
//Create messageFeedbackSender instance with corresponding model and deliveryTag
IMessageFeedbackSender messageFeedbackSender = new RabbitMQMessageFeedbackSender(this.model, basicDeliverEventArgs.DeliveryTag);
try
{
//Call given messageProcessingWorker's OnMessage method to proceed with message processing
this.messageProcessingWorker.OnMessage(messageObject, messageFeedbackSender);
//If message has been processed with no errors but no Acknoledgement has been given
if (!messageFeedbackSender.MessageAcknoledged)
{
//Acknoledge message
this.Ack(basicDeliverEventArgs.DeliveryTag);
}
}
catch (Exception)
{
//If something went wrong with message processing and message hasn't been acknoledged yet
if (!messageFeedbackSender.MessageAcknoledged)
{
//Negatively Acknoledge message, asking for requeue
this.Nack(basicDeliverEventArgs.DeliveryTag, true);
}
//Rethrow catched Exception
throw;
}
}
}
protected internal override Task <AggregateConsumingResult> ConsumeAsync(BasicDeliverEventArgs args)
{
return(base.ConsumeAsync(args).ContinueWith(_ => _.HandleErrorResult(_log)));
}
/// <summary>
/// Десериализовать извлеченное сообщение из очереди.
/// </summary>
/// <param name="rawMessage">Сообщение из очереди. Содержит всю информацию о доставленном сообщении от брокера AMQP.</param>
/// <returns>Десериализованный объект <see cref="TMessage"/>.</returns>
protected override TMessage DeserializeMessage(BasicDeliverEventArgs rawMessage)
{
var json = Encoding.UTF8.GetString(rawMessage.Body);
return(JsonConvert.DeserializeObject <TMessage>(json));
}
protected abstract T ExecutaTarefa(object sender, BasicDeliverEventArgs @event);
public async Task Handle(BasicDeliverEventArgs eventArgs, string matchingRoute)
{
_logger.LogInformation($"A weird example of running something async with message {eventArgs.GetMessage()} that has been received by {matchingRoute}.");
await Task.CompletedTask.ConfigureAwait(false);
}
/// <summary>
///
/// </summary>
public void Order311FromOMS_GuangZhou()
{
try
{
ConcurrentQueue <BasicDeliverEventArgs> queue1 = new ConcurrentQueue <BasicDeliverEventArgs>();
ConnectionFactory factory = new ConnectionFactory();
factory.UserName = "******";
factory.Password = "******";
factory.HostName = "127.0.0.1";
factory.Port = 5672;
factory.AutomaticRecoveryEnabled = true;
factory.TopologyRecoveryEnabled = true;
RabbitMQ.Client.IConnection conn = factory.CreateConnection();
conn.ConnectionShutdown += (o, e) => {
};
IModel channel = conn.CreateModel();
channel.ExchangeDeclare("ENT311Message_GuangZhou", "direct");
channel.QueueDeclare("ENT311Message_GuangZhou", false, false, false, null);
channel.QueueBind("ENT311Message_GuangZhou", "ENT311Message_GuangZhou", "ENT311Message_GuangZhou", null);
EventingBasicConsumer c = new EventingBasicConsumer(channel);
c.Received += (ch, ea) =>
{
queue1.Enqueue(ea);
};
string consumerTag = channel.BasicConsume("ENT311Message_GuangZhou", false, c);
Task.Factory.StartNew(() => {
BasicDeliverEventArgs bdea = null;
while (true)
{
if (queue1.TryDequeue(out bdea))
{
try
{
_ILog4netHelper.WriteLog_Info <MessageHub>(Encoding.UTF8.GetString(bdea.Body), dic.Count.ToString(), null, null);
if (dic.Keys.Contains("*****@*****.**"))
{
Clients.User("*****@*****.**").Send_Order311_GuangZhou(Encoding.UTF8.GetString(bdea.Body));
//_ILog4netHelper.WriteLog_Info<MessageHub>(re, dic.Count.ToString(), null, null);
channel.BasicAck(bdea.DeliveryTag, false);
}
else
{
channel.BasicNack(bdea.DeliveryTag, false, true);
//channel.BasicAck(bdea.DeliveryTag, true);
}
}
catch (Exception ex)
{
_ILog4netHelper.WriteLog_Info <MessageHub>(Encoding.UTF8.GetString(bdea.Body), dic.Count.ToString(), null, ex);
try
{
channel.BasicNack(bdea.DeliveryTag, false, true);
}
catch (Exception exe)
{
//Order311FromOMS_GuangZhou();
}
}
}
Thread.Sleep(100);
}
});
}
catch (Exception ex)
{
Order311FromOMS_GuangZhou();
}
}
public PayloadEventArgs(StandardPayload payload, BasicDeliverEventArgs bdea)
{
this.Payload = payload;
this.BasicDeliverEventArgs = bdea;
}
public override void Response(JObject data, BasicDeliverEventArgs ea)
{
Console.WriteLine("响应LOG记录: {0} \n{1}", ea.RoutingKey, data.ToString());
}
protected abstract void CheckRouting(StandardPayload payload, BasicDeliverEventArgs bdea);
public void TestCanHandleStringHeader()
{
var basicDeliverEventArgs = new BasicDeliverEventArgs
{
BasicProperties = new BasicProperties
{
MessageId = "Blah",
Headers = new Dictionary<string, object>
{
{"Foo", "ni"}
}
}
};
var transportMessage = converter.ToTransportMessage(basicDeliverEventArgs);
Assert.NotNull(transportMessage);
Assert.AreEqual("ni", transportMessage.Headers["Foo"]);
}
/// <summary>
///
/// </summary>
public void customrealpayController()
{
try
{
ConcurrentQueue <BasicDeliverEventArgs> queue1 = new ConcurrentQueue <BasicDeliverEventArgs>();
ConnectionFactory factory = new ConnectionFactory();
factory.UserName = "******";
factory.Password = "******";
factory.HostName = "127.0.0.1";
factory.Port = 5672;
factory.AutomaticRecoveryEnabled = true;
factory.TopologyRecoveryEnabled = true;
RabbitMQ.Client.IConnection conn = factory.CreateConnection();
conn.ConnectionShutdown += (o, e) => {
};
IModel channel = conn.CreateModel();
channel.ExchangeDeclare("customrealpayController", "direct");
channel.QueueDeclare("customrealpayController", false, false, false, null);
channel.QueueBind("customrealpayController", "customrealpayController", "customrealpayController", null);
EventingBasicConsumer c = new EventingBasicConsumer(channel);
c.Received += (ch, ea) =>
{
queue1.Enqueue(ea);
};
string consumerTag = channel.BasicConsume("customrealpayController", false, c);
Task.Factory.StartNew(() => {
BasicDeliverEventArgs bdea = null;
while (true)
{
if (queue1.TryDequeue(out bdea))
{
try
{
//Clients.User("*****@*****.**").Send(JsonConvert.DeserializeObject<payExInfo>(Encoding.UTF8.GetString(bdea.Body)));
//channel.BasicAck(bdea.DeliveryTag, false);
if (dic.Keys.Contains("*****@*****.**"))
{
Clients.User("*****@*****.**").Send(JsonConvert.DeserializeObject <payExInfo>(Encoding.UTF8.GetString(bdea.Body)));
channel.BasicAck(bdea.DeliveryTag, false);
}
else
{
channel.BasicAck(bdea.DeliveryTag, true);
}
}
catch (Exception ex)
{
channel.BasicNack(bdea.DeliveryTag, false, true);
}
}
Thread.Sleep(100);
}
});
}
catch (Exception ex)
{
customrealpayController();
}
}
private void ConsumerOnReceived(IBasicConsumer sender, BasicDeliverEventArgs args)
{
Console.WriteLine("Message received: {0}", Encoding.UTF8.GetString(args.Body));
}
public virtual void onMessage(object model, BasicDeliverEventArgs ea)
{
executor.Execute(ea.Body);
}
protected internal NonConsumableMessage(BasicDeliverEventArgs args)
: base(args)
{
}
private async Task Consumer_Received(object sender, BasicDeliverEventArgs @event) => ExecutaTarefa(sender, @event);
/// <summary>
/// Создает входящее сообщение.
/// </summary>
/// <param name="deliveryChannel">
/// The delivery Channel.
/// </param>
/// <param name="args">
/// Аргументы, с которыми получено сообщение.
/// </param>
/// <returns>
/// Входящее сообщение.
/// </returns>
public RabbitDelivery BuildDeliveryFrom(RabbitChannel deliveryChannel, BasicDeliverEventArgs args)
{
return(new RabbitDelivery(this.busContext, deliveryChannel, args, this.ReceiverOptions.IsAcceptRequired()));
}
private void OnReceived(object _, BasicDeliverEventArgs args)
{
try
{
var correlationId = args.BasicProperties.CorrelationId;
if (string.IsNullOrWhiteSpace(correlationId))
{
_log.LogError($"Received response, but {nameof(args.BasicProperties.CorrelationId)} is not set. Message is lost");
return;
}
_tasks.TryRemove(correlationId, out var taskSource);
if (taskSource == null)
{
_log.LogError("Received response, but task source is lost. The Message will be removed");
return;
}
try
{
var statusHeaderObject = args.BasicProperties.Headers[QueueHeaders.Status];
var status = 200;
if (statusHeaderObject == null)
{
_log.LogWarning($"No header {QueueHeaders.Status} in Response. Default status {status}");
}
else
{
if (!(statusHeaderObject is byte[] statusHeader))
{
_log.LogWarning(
$"Header {QueueHeaders.Status} in Response. Status must be string. Default status {status}");
}
else if (!int.TryParse(System.Text.Encoding.UTF8.GetString(statusHeader), out status))
{
_log.LogWarning(
$"Header {QueueHeaders.Status} in Response. Status is incorrect. Default status {status}");
}
}
var response = new HttpResponseMessage
{
StatusCode = (HttpStatusCode)status,
Content = new ReadOnlyMemoryContent(args.Body)
};
foreach (var header in args.BasicProperties.Headers)
{
if (!(header.Value is byte[] value))
{
_log.LogWarning($"Consume header {header.Key} value must be string. Header value {header.Key} will be lost");
continue;
}
if (QueueConsts.ContentHeaders.Contains(header.Key))
{
response.Content.Headers.Add(header.Key, System.Text.Encoding.UTF8.GetString(value));
}
else
{
response.Headers.TryAddWithoutValidation(header.Key, System.Text.Encoding.UTF8.GetString(value));
}
}
taskSource.SetResult(response);
}
protected internal virtual Task <AggregateConsumingResult> ConsumeAsync(BasicDeliverEventArgs args)
{
var message = _builder.Build(args);
return(message.ConsumeAsync(Configuration.FindSubscriptions(message)));
}
private byte[] AddMessageToQueue(byte[] body, string queueName, ulong deliveryTag = 0)
{
var consumerField = typeof(RabbitMQMessageListener).GetField("consumer", BindingFlags.NonPublic | BindingFlags.Instance);
Debug.Assert(consumerField != null, "consumerField != null");
var consumer = (QueueingBasicConsumer)consumerField.GetValue(this.componentUnderTest);
var deliveryEvent = new BasicDeliverEventArgs { Body = body, DeliveryTag = deliveryTag, RoutingKey = queueName };
consumer.Queue.Enqueue(deliveryEvent);
return body;
}
protected abstract Task <AggregateConsumingResult> ConsumeInternalAsync(BasicDeliverEventArgs args);
static Dictionary<string, string> DeserializeHeaders(BasicDeliverEventArgs message)
{
if (message.BasicProperties.Headers == null)
{
return new Dictionary<string, string>();
}
return message.BasicProperties.Headers.Cast<KeyValuePair<string, object>>()
.ToDictionary(
dictionaryEntry => dictionaryEntry.Key,
dictionaryEntry =>
{
var value = dictionaryEntry.Value;
return dictionaryEntry.Value == null ? null : ValueToString(value);
});
}
public void MessageFailed(BasicDeliverEventArgs result)
{
_channel.BasicPublish(_address.Name, "", result.BasicProperties, result.Body);
_channel.BasicAck(result.DeliveryTag, false);
}
