public AckEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body , AckResult ackResult)
{
ReceivedInfo = info;
Properties = properties;
Body = body;
AckResult = ackResult;
}
public void The_default_error_exchange_name_should_be()
{
var info = new MessageReceivedInfo("consumer_tag", 0, false, "exchange", "routingKey", "queue");
var result = conventions.ErrorExchangeNamingConvention(info);
result.ShouldEqual("ErrorExchange_routingKey");
}
public void SetUp()
{
postAckCallbackWasRun = false;
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub<IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy);
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub<IBasicConsumer>();
channel = MockRepository.GenerateStub<IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
context.SetPostAckCallback(() => postAckCallbackWasRun = true);
var autoResetEvent = new AutoResetEvent(false);
((HandlerRunner) handlerRunner).SynchronisationAction = () => autoResetEvent.Set();
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public void SetUp()
{
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub<IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
var eventBus = new EventBus();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy, eventBus);
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub<IBasicConsumer>();
channel = MockRepository.GenerateStub<IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
var autoResetEvent = new AutoResetEvent(false);
eventBus.Subscribe<AckEvent>(x => autoResetEvent.Set());
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public IEnumerable<HosepipeMessage> GetMessagesFromQueue(QueueParameters parameters)
{
using (var connection = HosepipeConnection.FromParamters(parameters))
using (var channel = connection.CreateModel())
{
try
{
channel.QueueDeclarePassive(parameters.QueueName);
}
catch (OperationInterruptedException exception)
{
Console.WriteLine(exception.Message);
yield break;
}
var count = 0;
while (count++ < parameters.NumberOfMessagesToRetrieve)
{
var basicGetResult = channel.BasicGet(parameters.QueueName, noAck: parameters.Purge);
if (basicGetResult == null) break; // no more messages on the queue
var properties = new MessageProperties(basicGetResult.BasicProperties);
var info = new MessageReceivedInfo(
"hosepipe",
basicGetResult.DeliveryTag,
basicGetResult.Redelivered,
basicGetResult.Exchange,
basicGetResult.RoutingKey,
parameters.QueueName);
yield return new HosepipeMessage(errorMessageSerializer.Serialize(basicGetResult.Body), properties, info);
}
}
}
public HosepipeMessage(string body, MessageProperties properties, MessageReceivedInfo info)
{
if(body == null) throw new ArgumentNullException("body");
if(properties == null) throw new ArgumentNullException("properties");
if(info == null) throw new ArgumentNullException("info");
Body = body;
Properties = properties;
Info = info;
}
protected void StartConsumer(Action<byte[], MessageProperties, MessageReceivedInfo> handler)
{
ConsumerWasInvoked = false;
var queue = new Queue("my_queue", false);
MockBuilder.Bus.Advanced.Consume(queue, (body, properties, messageInfo) => Task.Factory.StartNew(() =>
{
DeliveredMessageBody = body;
DeliveredMessageProperties = properties;
DeliveredMessageInfo = messageInfo;
handler(body, properties, messageInfo);
ConsumerWasInvoked = true;
}, Cancellation.Token));
}
public ConsumerExecutionContext(
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler,
MessageReceivedInfo info,
MessageProperties properties,
byte[] body,
IBasicConsumer consumer)
{
Preconditions.CheckNotNull(userHandler, "userHandler");
Preconditions.CheckNotNull(info, "info");
Preconditions.CheckNotNull(properties, "properties");
Preconditions.CheckNotNull(body, "body");
Preconditions.CheckNotNull(consumer, "consumer");
UserHandler = userHandler;
Info = info;
Properties = properties;
Body = body;
Consumer = consumer;
}
public void SetUp()
{
postAckCallbackWasRun = false;
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub <IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy);
Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub <IBasicConsumer>();
channel = MockRepository.GenerateStub <IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
context.SetPostAckCallback(() => postAckCallbackWasRun = true);
var autoResetEvent = new AutoResetEvent(false);
((HandlerRunner)handlerRunner).SynchronisationAction = () => autoResetEvent.Set();
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public void ProcessMessage(byte[] body, MessageProperties properties, MessageReceivedInfo messageReceivedInfo)
{
var message = System.Text.Encoding.UTF8.GetString(body);
//Console.WriteLine(message);
JObject jo = (JObject)JsonConvert.DeserializeObject(message);
JToken a = jo["Body"];
JObject obj = (JObject)a;
var sub = JsonConvert.DeserializeObject <TraceableCodeSub>(obj.ToString());
lock (list)
{
list.Add(sub);
Console.WriteLine("加入集合成功，集合现有{0}条数据！", list.Count);
}
while (list.Count >= 100000)
{
lock (list)
{
//批量插入数据库
Console.WriteLine("成功插入数据库{0}条数据！", list.Count);
//list 清空
list.Clear();
Console.WriteLine("清空list，集合数量为{0}！", list.Count);
}
}
lock (LockingObject)
{
Monitor.PulseAll(LockingObject);
}
/* If you uncomment this dipose and comment out the one above it will work a little better...if you use the sleep you can probably process over 10000 messages before it fails
* Thread.Sleep(50);
* this._consumer.Dispose();
*/
}
private static void GetBody(byte[] body, MessageProperties properties, MessageReceivedInfo info)
{
try
{
if (body == null || body.Length <= 0)
{
Console.WriteLine("没有数据*********");
Thread.Sleep(10000);
}
string message = string.Empty;
message = Encoding.UTF8.GetString(body);
//await Task.Run(() =>
// {
// return message = Encoding.UTF8.GetString(body);
// });
Console.WriteLine(message);
}
catch (Exception e)
{
throw e;
}
}
public IEnumerable <HosepipeMessage> GetMessagesFromQueue(QueueParameters parameters)
{
using (var connection = HosepipeConnection.FromParamters(parameters))
using (var channel = connection.CreateModel())
{
try
{
channel.QueueDeclarePassive(parameters.QueueName);
}
catch (OperationInterruptedException exception)
{
Console.WriteLine(exception.Message);
yield break;
}
var count = 0;
while (count++ < parameters.NumberOfMessagesToRetrieve)
{
var basicGetResult = channel.BasicGet(parameters.QueueName, noAck: parameters.Purge);
if (basicGetResult == null)
{
break; // no more messages on the queue
}
var properties = new MessageProperties(basicGetResult.BasicProperties);
var info = new MessageReceivedInfo(
"hosepipe",
basicGetResult.DeliveryTag,
basicGetResult.Redelivered,
basicGetResult.Exchange,
basicGetResult.RoutingKey,
parameters.QueueName);
yield return(new HosepipeMessage(errorMessageSerializer.Serialize(basicGetResult.Body), properties, info));
}
}
}
public HosepipeMessage(string body, MessageProperties properties, MessageReceivedInfo info)
{
Body = body ?? throw new ArgumentNullException(nameof(body));
Properties = properties ?? throw new ArgumentNullException(nameof(properties));
Info = info ?? throw new ArgumentNullException(nameof(info));
}
private void OnUpdateEntitiesResponse <T>(EntitiesChangedResponse <T> response, MessageReceivedInfo info, TaskCompletionSource <EntitiesChangedResponse <T> > tcs) where T : EntityBase
{
//Check if we're passing on the result and its one of ours
if (_pendingRequests.ContainsKey(response.Id) && tcs != null)
{
//Remove from pending
_pendingRequests.Remove(response.Id);
//Unsubscribe from temporary queue and delete it
//Doesn't appear to be valid way to unsubscribe so just delete
var queueName = response.PrivateResponseQueue;
_busManager.DeleteQueue(_busManager.TopicExchange, queueName);
_ownedTemporaryQueues.Remove(_ownedTemporaryQueues.SingleOrDefault(q => q == queueName));
//Invoke response handler
tcs.SetResult(response);
}
}
public DeliveredMessageEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body)
{
ReceivedInfo = info;
Properties = properties;
Body = body;
}
private async Task <(bool Handled, int RedeliveryCount)> HandleRedelivery(MessageProperties properties, MessageReceivedInfo info, Func <IQueue, Task> requeue)
{
var redeliveryCount = 0;
if (properties.Headers.ContainsKey(MessageHeaders.RedeliveryCount) &&
properties.Headers[MessageHeaders.RedeliveryCount] is int msgRedeliveryCount)
{
redeliveryCount = msgRedeliveryCount;
}
if (info.Redelivered)
{
var redeliveryLimit = _messageBus.Value.RedeliveryLimit;
if (properties.Headers.ContainsKey(MessageHeaders.RedeliveryLimit) &&
properties.Headers[MessageHeaders.RedeliveryLimit] is int msgRedeliveryLimit)
{
redeliveryLimit = msgRedeliveryLimit;
}
if (redeliveryLimit.HasValue && redeliveryCount >= redeliveryLimit)
{
throw new RedeliveryLimitException();
}
properties.Headers[MessageHeaders.RedeliveryCount] = redeliveryCount + 1;
var redeliveryDelay = _messageBus.Value.RedeliveryDelay;
if (properties.Headers.ContainsKey(MessageHeaders.RedeliveryDelay) &&
properties.Headers[MessageHeaders.RedeliveryDelay] is int msgRedeliveryDelay)
{
redeliveryDelay = TimeSpan.FromMilliseconds(msgRedeliveryDelay);
}
if (redeliveryDelay.HasValue)
{
properties.Expiration = redeliveryDelay.Value.TotalMilliseconds.ToString("F0");
await requeue(await _easyNetQBus.GetDelayQueueAsync(_queue.Name));
}
else
{
await requeue(_queue);
}
return(true, redeliveryCount);
}
return(false, redeliveryCount);
}
//private void HandleMqMessage(byte[] body,MessageProperties properties,MessageReceivedInfo receivedInfo)
//{
// var message = Encoding.UTF8.GetString(body);
// _logger.LogInformation($"receive MQ message: {message}");
//}
private Task <AckStrategy> HandleMqMessage(byte[] body, MessageProperties properties, MessageReceivedInfo receivedInfo)
{
var message = Encoding.UTF8.GetString(body);
_logger.LogInformation($"receive MQ message: {message}");
return(Task.FromResult(AckStrategies.Ack));
}
private static void HandleErrorMessage(IMessage <Error> msg, MessageReceivedInfo info)
{
Console.WriteLine("catch: " + msg.Body.Message);
}
private Task MessageReceivedAsync(byte[] body, MessageProperties messageProperties, MessageReceivedInfo info) => _messageRequestProcessor.ProcessAsync(body);
protected Task ExecuteResponder(Func <byte[], Task <byte[]> > responder, byte[] message, MessageProperties properties, MessageReceivedInfo receiveInfo)
{
var tcs = new TaskCompletionSource <object>();
try
{
responder(message).ContinueWith(task =>
{
if (task.IsFaulted)
{
if (task.Exception != null)
{
OnResponderFailure(message, properties, task.Exception.InnerException.Message);
tcs.SetException(task.Exception);
}
}
else
{
OnResponderSuccess(properties, task.Result);
tcs.SetResult(null);
}
});
}
catch (Exception e)
{
OnResponderFailure(message, properties, e.Message);
tcs.SetException(e);
}
return(tcs.Task);
}
private void OnGetPagedEntitesResponse <T>(PagedEntityListResponse <T> response, MessageReceivedInfo info, Action <PagedEntityListResponse <T> > onResponse) where T : EntityBase
{
//Check if we're passing on the result and its one of ours
if (_pendingRequests.ContainsKey(response.Id) && onResponse != null)
{
//Remove from pending
_pendingRequests.Remove(response.Id);
//Unsubscribe from temporary queue and delete it
//Doesn't appear to be valid way to unsubscribe so just delete
var queueName = response.PrivateResponseQueue;
_busManager.DeleteQueue(_busManager.TopicExchange, queueName);
_ownedTemporaryQueues.Remove(_ownedTemporaryQueues.SingleOrDefault(q => q == queueName));
//Invoke action method
onResponse.Invoke(response);
}
}
private void OnAllEntitiesUpdatedResponse <T>(EntitiesChangedResponse <T> response, MessageReceivedInfo info) where T : EntityBase
{
foreach (var responseAction in _enitiesUpdatedResponseActions)
{
responseAction.Invoke(response);
}
}
/// <summary>
/// Creates ConsumedMessage
/// </summary>
/// <param name="receivedInfo">The received info</param>
/// <param name="properties">The properties</param>
/// <param name="body">The body</param>
public ConsumedMessage(MessageReceivedInfo receivedInfo, MessageProperties properties, byte[] body)
{
ReceivedInfo = receivedInfo;
Properties = properties;
Body = body;
}
private async Task ReceivedEventAndCommandHandler(byte[] bytes, MessageProperties props, MessageReceivedInfo info, IHandlerRegistry handlers)
{
string prefix = string.Format("[{0}/{1}]", info.Exchange, info.Queue);
if (props.TypePresent)
{
var deserialized = _serializationStrategy.Deserialize(props.Type, bytes);
if (deserialized != null)
{
await CallHandlers(handlers, deserialized.Item1, deserialized.Item2, null);
}
else
{
_logger.Error("{0} Message deserialization failed. Dropping message.", prefix);
}
}
else
{
_logger.Warn("{0} Message does not contain Type header. Dropping message.", prefix);
}
}
private void HandleMessageAsync(byte[] body, MessageProperties messageProperties, MessageReceivedInfo messageReceivedInfo)
{
if (body.Length == 0)
{
return;
}
var decodedBody = Encoding.UTF8.GetString(body);
messageReceived = JsonConvert.DeserializeObject <MessageReceived>(decodedBody);
}
public ExtendedMessageReceivedInfo(MessageReceivedInfo info, int redeliveryCount)
: base(info.ConsumerTag, info.DeliverTag, redeliveryCount > 0, info.Exchange, info.RoutingKey, info.Queue)
{
RedeliveryCount = redeliveryCount;
}
private async Task<AckStrategy> ProcessEventAsync(byte[] buffer, MessageProperties messageProperties, MessageReceivedInfo messageReceivedInfo)
{
var eventName = messageReceivedInfo.RoutingKey;
var eventType = EventTypes.GetOrDefault(eventName);
if (eventType == null)
{
return AckStrategies.Ack;
}
var eventData = Serializer.Deserialize(buffer, eventType);
await TriggerHandlersAsync(eventType, eventData, errorContext =>
{
var retryAttempt = 0;
if (messageProperties.Headers != null &&
messageProperties.Headers.ContainsKey(EventErrorHandlerBase.RetryAttemptKey))
{
retryAttempt = (int)messageProperties.Headers[EventErrorHandlerBase.RetryAttemptKey];
}
errorContext.EventData = eventData;
errorContext.SetProperty(EventErrorHandlerBase.HeadersKey, messageProperties);
errorContext.SetProperty(EventErrorHandlerBase.RetryAttemptKey, retryAttempt);
});
return AckStrategies.Ack;
}
public DeliveredMessageEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body)
{
ReceivedInfo = info;
Properties = properties;
Body = body;
}
private async Task HandleMessageAsync(byte[] body, MessageProperties messageProperties, MessageReceivedInfo messageReceivedInfo)
{
if (body.Length == 0)
{
return;
}
this.logger.LogInformation("Received Message");
var decodedBody = Encoding.UTF8.GetString(body);
var messageReceived = JsonConvert.DeserializeObject <MessageReceived>(decodedBody);
await PublishMessageEnriched(messageProperties, messageReceived).ConfigureAwait(false);
}
public void HandleBasicDeliver(
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
byte[] body)
{
logger.DebugWrite("HandleBasicDeliver on consumer: {0}, deliveryTag: {1}", consumerTag, deliveryTag);
if (disposed)
{
// this message's consumer has stopped, so just return
logger.InfoWrite("Consumer has stopped running. Consumer '{0}' on queue '{1}'. Ignoring message",
ConsumerTag, queue.Name);
return;
}
if (onMessage == null)
{
logger.ErrorWrite("User consumer callback, 'onMessage' has not been set for consumer '{0}'." +
"Please call InternalConsumer.StartConsuming before passing the consumer to basic.consume",
ConsumerTag);
return;
}
var messageReceivedInfo = new MessageReceivedInfo(consumerTag, deliveryTag, redelivered, exchange, routingKey, queue.Name);
var messsageProperties = new MessageProperties(properties);
var context = new ConsumerExecutionContext(onMessage, messageReceivedInfo, messsageProperties, body, this);
consumerDispatcher.QueueAction(() => handlerRunner.InvokeUserMessageHandler(context));
}
public void CheckMessageType <TMessage>(byte[] body, MessageProperties properties, MessageReceivedInfo messageReceivedInfo)
{
// Does nothing
}
/// <summary>
/// Represents a result when a message is available
/// </summary>
/// <returns></returns>
public static PullResult Available(
ulong messagesCount, MessageReceivedInfo receivedInfo, MessageProperties properties, byte[] body
)
{
return(new PullResult(true, messagesCount, receivedInfo, properties, body));
}
public async Task <long> AddLogAsync(MessageReceivedInfo info, MessageProperties prop, string message, DateTime nowDt)
{
return(await new MWLogData().InsertLogAsync(info, prop, message, nowDt));
}
public void AddLog(MessageReceivedInfo info, MessageProperties prop, string message)
{
new MWLogData().InsertLog(info, prop, message);
}
/// <inheritdoc/>
public async Task DispatchAsync(object message, MessageProperties properties, MessageReceivedInfo info)
{
Covenant.Requires <ArgumentNullException>(message != null);
Covenant.Requires <ArgumentNullException>(properties != null);
Covenant.Requires <ArgumentNullException>(info != null);
try
{
// One of the callback fields will be non-null. We'll call
// that one.
if (syncSimpleCallback != null)
{
syncSimpleCallback((TMessage)message);
}
else if (syncAdvancedCallback != null)
{
syncAdvancedCallback((TMessage)message, properties, ConsumerContext.Create(info));
}
else if (asyncSimpleCallback != null)
{
await asyncSimpleCallback((TMessage)message);
}
else if (asyncAdvancedCallback != null)
{
await asyncAdvancedCallback((TMessage)message, properties, ConsumerContext.Create(info));
}
else
{
Covenant.Assert(false);
}
}
catch (Exception e)
{
HiveBus.Log.LogError("Consumer exception.", e);
throw;
}
}
