public virtual void HandleMessage(IBasicConsumer consumer, BasicDeliverEventArgs eventArg)
{
var completionTask = _jobFactory(eventArg);
completionTask.ContinueWith(task =>
{
try
{
if (task.IsFaulted)
{
HandleError(consumer, eventArg, task.Exception);
}
}
catch (Exception ex)
{
_watcher.Error(ex);
}
finally
{
// Broadcast msgs
AfterHandlingMessage(consumer, eventArg);
//NOTE: Only this way, the new event to interupt other consumers will override previous resume event
if (HandlingComplete != null)
{
// Release pool + DoAck
HandlingComplete(eventArg);
}
}
});
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
byte[] body)
{
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
body);
}
catch (Exception e)
{
var details = new Dictionary<string, object>()
{
{"consumer", consumer},
{"context", "HandleBasicDeliver"}
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
});
}
private static void rate_limit_notify(IBasicConsumer consumer,
BasicDeliverEventArgs eargs) {
string[] EMAIL_RECIPS = new string[] {"*****@*****.**"};
IBasicProperties msg_props = eargs.BasicProperties;
String msg_body = Encoding.ASCII.GetString(eargs.Body);
//#/(ascdn.4) Decode our message from JSON
msg_body = JsonConvert.DeserializeObject
<string>(msg_body);
//#/(ascdn.5) Transmit e-mail to SMTP server
send_mail(EMAIL_RECIPS,
"RATE LIMIT ALERT!",
msg_body);
Console.WriteLine("Sent alert via e-mail! Alert Text: " +
msg_body + " Recipients: " +
string.Join(",", EMAIL_RECIPS));
//#/(ascdn.6) Acknowledge the message
consumer.Model.BasicAck(eargs.DeliveryTag,
false);
}
/// <summary>Start a Basic content-class consumer.</summary>
public static string BasicConsume(this IModel model, string queue,
bool autoAck,
string consumerTag,
IBasicConsumer consumer)
{
return model.BasicConsume(queue, autoAck, consumerTag, false, false, null, consumer);
}
/// <summary>Start a Basic content-class consumer.</summary>
public static string BasicConsume(this IModel model, string queue,
bool autoAck,
string consumerTag,
IDictionary<string, object> arguments,
IBasicConsumer consumer)
{
return model.BasicConsume(queue, autoAck, consumerTag, false, false, arguments, consumer);
}
public SubscriberBase(IModel model, string queue, IBasicConsumer consumer, SubscriberConfigurator configurator)
{
_model = model;
_queue = queue;
_consumer = consumer;
_configurator = configurator;
}
private void ConsumerOnReceived(IBasicConsumer sender, BasicDeliverEventArgs args)
{
var millisecondsTimeout = m_rnd.Next(1, 10) * 1000;
Console.WriteLine("Message received: {0}, sleeping for {1} seconds", Encoding.UTF8.GetString(args.Body), millisecondsTimeout/1000);
Thread.Sleep(millisecondsTimeout);
sender.Model.BasicAck(args.DeliveryTag, false);
}
/// <summary>Start a Basic content-class consumer.</summary>
public static string BasicConsume(this IModel model,
IBasicConsumer consumer,
string queue,
bool autoAck = false,
string consumerTag = "",
bool noLocal = false,
bool exclusive = false,
IDictionary<string, object> arguments = null)
{
return model.BasicConsume(queue, autoAck, consumerTag, noLocal, exclusive, arguments, consumer);
}
private static void ConsumerOnReceived(IBasicConsumer sender, BasicDeliverEventArgs args)
{
var n = int.Parse(Encoding.UTF8.GetString(args.Body));
Console.WriteLine("Received computation request for n = {0}, correlation id {1}", n, args.BasicProperties.CorrelationId);
var fib = Fibonacci(n);
var properties = sender.Model.CreateBasicProperties();
properties.CorrelationId = args.BasicProperties.CorrelationId;
sender.Model.BasicPublish("", args.BasicProperties.ReplyTo, properties, Encoding.UTF8.GetBytes(fib.ToString()));
sender.Model.BasicAck(args.DeliveryTag, false);
}
//
// CALLBACK THING:
//
private void my_callback(IBasicConsumer consumer,
BasicDeliverEventArgs eargs)
{
IBasicProperties msg_props = eargs.BasicProperties;
String msg_body_str = Encoding.ASCII.GetString(eargs.Body);
BsonDocument msg_body_bson = BsonDocument.Parse(msg_body_str);
// insert bson object to mongodb
mongodb_collection.Insert(msg_body_bson);
//
message_counter++;
if (true) //if (message_counter % report_each_N_messages == 0)
{
// Console.WriteLine("\nrecevied another " + report_each_N_messages + " messages: message_counter=" + message_counter + "\n\n" + msg_body_bson.ToString());
Console.Write("\rmessage_counter: " + message_counter + " ");
}
}
protected void TestExceptionHandlingWith(IBasicConsumer consumer, FailingOp fn)
{
Object o = new Object();
bool notified = false;
string q = Model.QueueDeclare();
Model.CallbackException += (m, evt) => {
notified = true;
Monitor.PulseAll(o);
};
string tag = Model.BasicConsume(q, true, consumer);
fn(Model, q, consumer, tag);
WaitOn(o);
Assert.IsTrue(notified);
}
public void HandleBasicCancelOk(IBasicConsumer consumer, string consumerTag)
{
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicCancelOk(consumerTag);
}
catch (Exception e)
{
var details = new Dictionary<string, object>()
{
{"consumer", consumer},
{"context", "HandleBasicCancelOk"}
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
});
}
public BasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
ReadOnlyMemory <byte> body,
byte[] rentedBytes) : base(consumer)
{
_consumerTag = consumerTag;
_deliveryTag = deliveryTag;
_redelivered = redelivered;
_exchange = exchange;
_routingKey = routingKey;
_basicProperties = basicProperties;
_body = body;
_rentedBytes = rentedBytes;
}
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 HandleBasicCancelOk(IBasicConsumer consumer, string consumerTag)
{
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicCancelOk(consumerTag);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicCancelOk" }
};
model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
});
}
public ConsumerExecutionContext(
Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessageHandler,
MessageReceivedInfo info,
MessageProperties properties,
byte[] body,
IBasicConsumer consumer)
{
Preconditions.CheckNotNull(onMessageHandler, "userHandler");
Preconditions.CheckNotNull(info, "info");
Preconditions.CheckNotNull(properties, "properties");
Preconditions.CheckNotNull(body, "body");
Preconditions.CheckNotNull(consumer, "consumer");
OnMessageHandler = onMessageHandler;
Info = info;
Properties = properties;
Body = body;
Consumer = consumer;
}
public BasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
IMemoryOwner <byte> body,
int bodyLength) : base(consumer)
{
_consumerTag = consumerTag;
_deliveryTag = deliveryTag;
_redelivered = redelivered;
_exchange = exchange;
_routingKey = routingKey;
_basicProperties = basicProperties;
_body = body;
_bodyLength = bodyLength;
}
private void _consumer_Received(IBasicConsumer sender, BasicDeliverEventArgs args)
{
var payload = JObject.Parse(Encoding.UTF8.GetString(args.Body));
string token = null;
IBasicProperties props = args.BasicProperties;
uint expiry = 0;
if (payload == null ||
!props.IsHeadersPresent() ||
string.IsNullOrWhiteSpace((token = props.GetStringHeader("device-token"))) ||
!uint.TryParse(props.GetStringHeader("expiry"), out expiry))
{
// the message is too incomplete to handle
this.Model.BasicNack(args.DeliveryTag, false, false);
return;
}
_queue.Enqueue(new NotificationEventArgs(this, token, expiry, payload, args.DeliveryTag));
_wait.Set();
}
public string BasicConsume(string queue,
bool noAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary <string, object> arguments,
IBasicConsumer consumer)
{
var result = m_delegate.BasicConsume(queue, noAck, consumerTag, noLocal,
exclusive, arguments, consumer);
RecordedConsumer rc = new RecordedConsumer(this, queue).
WithConsumerTag(result).
WithConsumer(consumer).
WithExclusive(exclusive).
WithAutoAck(noAck).
WithArguments(arguments);
m_connection.RecordConsumer(result, rc);
return(result);
}
public void CallbackIsCalledWithProperMessage(string exchangeName, string topic, string eventType)
{
// Arrange
var connectionMock = new Mock <IConnection>();
var contextMock = new Mock <IBusContext <IConnection> >();
var modelMock = new Mock <IModel>();
contextMock.SetupGet(e => e.Connection).Returns(connectionMock.Object);
connectionMock.Setup(e => e.CreateModel()).Returns(modelMock.Object);
IBasicConsumer consumer = null;
// Retrieve consumer from callback
var receiver = new RabbitMqMessageReceiver(contextMock.Object, "test.queue", new string[0]);
modelMock.Setup(
e => e.BasicConsume("test.queue", true, It.IsAny <string>(), false, false, null, It.IsAny <IBasicConsumer>()))
.Callback <string, bool, string, bool, bool, IDictionary <string, object>, IBasicConsumer>(
(a, b, c, d, e, f, givenConsumer) => consumer = givenConsumer);
EventMessage eventMessage = null;
receiver.StartReceivingMessages();
receiver.StartHandlingMessages(e => eventMessage = e);
Guid guid = Guid.NewGuid();
IBasicProperties properties = new BasicProperties
{
CorrelationId = guid.ToString(),
Type = eventType
};
// Act
Thread.Sleep(WaitTime);
consumer.HandleBasicDeliver(It.IsAny <string>(), 0, false, exchangeName, topic, properties, new byte[0]);
// Assert
Assert.AreEqual(topic, eventMessage.Topic);
Assert.AreEqual(eventType, eventMessage.EventType);
Assert.AreEqual(guid, eventMessage.CorrelationId);
}
private void onMessage(IBasicConsumer sender,
BasicDeliverEventArgs args)
{
var body = args.Body;
var message = Encoding.UTF8.GetString(body);
// Debug.Log (message);
if (this.eventHandlers.ContainsKey(args.RoutingKey))
{
// var body = args.Body;
// var message = Encoding.UTF8.GetString(body);
// Debug.Log (message);
switch (args.RoutingKey)
{
case EventType.Speech:
SpeechMessage spMsg = JsonUtility.FromJson <SpeechMessage>(message);
this.eventHandlers[args.RoutingKey](spMsg);
break;
case EventType.Hotword:
HotwordMessage hwMsg = JsonUtility.FromJson <HotwordMessage>(message);
this.eventHandlers[args.RoutingKey](hwMsg);
break;
case EventType.MidAirTokens:
MidAirTokenMessage midAirTokenMessage =
JsonUtility.FromJson <MidAirTokenMessage>(message);
this.eventHandlers[args.RoutingKey](midAirTokenMessage);
break;
default:
break;
}
}
// if(this.eventHandlers.ContainsKey(args.RoutingKey)) {
// this.eventHandlers[args.RoutingKey](sender, args);
// }
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
ReadOnlySpan <byte> body)
{
byte[] memoryCopyArray = ArrayPool <byte> .Shared.Rent(body.Length);
Memory <byte> memoryCopy = new Memory <byte>(memoryCopyArray, 0, body.Length);
body.CopyTo(memoryCopy.Span);
UnlessShuttingDown(() =>
{
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
memoryCopy);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
_model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
ArrayPool <byte> .Shared.Return(memoryCopyArray);
}
});
}
protected void TestExceptionHandlingWith(IBasicConsumer consumer,
Action <IModel, string, IBasicConsumer, string> action)
{
object o = new object();
bool notified = false;
string q = _model.QueueDeclare();
_model.CallbackException += (m, evt) =>
{
notified = true;
Monitor.PulseAll(o);
};
string tag = _model.BasicConsume(q, true, consumer);
action(_model, q, consumer, tag);
WaitOn(o);
Assert.IsTrue(notified);
}
protected override async Task Execute(ModelBase model, IBasicConsumer consumer)
{
try
{
await consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
body).ConfigureAwait(false);
}
catch (Exception e)
{
var details = new Dictionary <string, object>()
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
await model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
}
public IHandlerRegistry Register <TMessage, THandler>()
where THandler : IMessageHandler <TMessage>
{
try
{
IModel channel = connection.CreateModel();
channel.ExchangeDeclare(typeof(TMessage).FullName, "fanout");
QueueDeclareOk queueName = channel.QueueDeclare(
typeof(TMessage).FullName + "." + serviceProvider.GetService <IHostEnvironment>().ApplicationName,
true,
false,
false,
null);
channel.QueueBind(
queueName,
typeof(TMessage).FullName,
string.Empty);
IBasicConsumer consumer = GetConsumer <TMessage, THandler>(channel);
channel.BasicConsume(
queueName,
true,
consumer);
consumers.Add(consumer);
}
catch (Exception e)
{
logger.LogError(e, e.Message);
throw;
}
return(this);
}
public void HandleBasicDeliver(IBasicConsumer consumer,
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties basicProperties,
ReadOnlyMemory <byte> body,
byte[] rentedArray)
{
UnlessShuttingDown(() =>
{
var bodyData = new BodyData(body, rentedArray);
try
{
consumer.HandleBasicDeliver(consumerTag,
deliveryTag,
redelivered,
exchange,
routingKey,
basicProperties,
in bodyData);
}
catch (Exception e)
{
var details = new Dictionary <string, object>
{
{ "consumer", consumer },
{ "context", "HandleBasicDeliver" }
};
_model.OnCallbackException(CallbackExceptionEventArgs.Build(e, details));
}
finally
{
bodyData.ReturnPayload();
}
});
}
Task ClientContext.BasicConsume(ReceiveSettings receiveSettings, IBasicConsumer consumer)
{
string queueUrl;
lock (_lock)
{
if (!_queueUrls.TryGetValue(receiveSettings.EntityName, out queueUrl))
{
throw new ArgumentException($"The queue was unknown: {receiveSettings.EntityName}", nameof(receiveSettings));
}
}
return(Task.Factory.StartNew(async() =>
{
while (!CancellationToken.IsCancellationRequested)
{
List <Message> messages = await PollMessages(queueUrl, receiveSettings).ConfigureAwait(false);
await Task.WhenAll(messages.Select(consumer.HandleMessage)).ConfigureAwait(false);
}
}, CancellationToken, TaskCreationOptions.None, _taskScheduler));
}
public void AddEventListenerShouldAddHandleToConsumerReceived()
{
// Arrange
IBasicConsumer basicConsumer = null;
var modelMock = new Mock <IModel>();
var model = modelMock.Object;
var connectionMock = new Mock <IConnection>();
var connection = connectionMock.Object;
var eventListenerMock = new Mock <IEventListener>();
connectionMock.Setup(mock => mock.CreateModel()).Returns(model);
modelMock.Setup(mock => mock.QueueDeclare(string.Empty, false, true, true, null))
.Returns(new QueueDeclareOk("TestQueue", 0, 1));
modelMock.Setup(mock =>
mock.BasicConsume("TestQueue", false, It.IsAny <string>(), false, false, null,
It.IsAny <IBasicConsumer>()))
.Callback((
string queue,
bool autoAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary <string, object> arguments,
IBasicConsumer consumer) =>
{
basicConsumer = consumer;
});
using var eventBus = new EventBus(connection, "TestExchange");
// Act
eventBus.AddEventListener(eventListenerMock.Object, "#");
basicConsumer.HandleBasicDeliver("", ulong.MaxValue, false, "TestExchange", "#",
new BasicProperties(), It.IsAny <byte[]>());
// Assert
eventListenerMock.Verify(mock => mock.Handle(It.IsAny <object>(), It.IsAny <BasicDeliverEventArgs>()));
}
private void NotifyConsumerOfMessage(string consumerTag, IBasicConsumer consumer, RabbitMessage message)
{
Interlocked.Increment(ref _lastDeliveryTag);
var deliveryTag = Convert.ToUInt64(_lastDeliveryTag);
const bool redelivered = false;
var exchange = message.Exchange;
var routingKey = message.RoutingKey;
var basicProperties = message.BasicProperties ?? CreateBasicProperties();
var body = message.Body;
Func <ulong, RabbitMessage, RabbitMessage> updateFunction = (key, existingMessage) => existingMessage;
WorkingMessages.AddOrUpdate(deliveryTag, message, updateFunction);
if (consumer is IAsyncBasicConsumer asyncConsumer)
{
Task.Run(() => asyncConsumer.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, basicProperties, body)).GetAwaiter().GetResult();
}
else
{
consumer.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, basicProperties, body);
}
}
public async void RabbitModelConsumerTest()
{
// Arrange
byte[] messageBody = { 0xBE, 0xBE };
var modelMock = new Mock <IModel>();
IBasicConsumer mockConsumer = null;
modelMock.Setup(m => m.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(),
It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <EventingBasicConsumer>()))
.Returns("consumerTag")
.Callback <string, bool, string, bool, bool, IDictionary <string, object>, IBasicConsumer>(
(queue, autoAck, consumerTag, noLocal, exclusive, arguments, consumer) =>
{
mockConsumer = consumer;
});
var messageConsumerActorRef = CreateTestProbe("MessageConsumer");
var requestModelConsumer = Mock.Of <IRequestModelConsumer>(rmc => rmc.MessageConsumer == messageConsumerActorRef);
var rabbitModelConsumer = Sys.ActorOf(RabbitModelConsumer.CreateProps(modelMock.Object, requestModelConsumer));
// Act
var started = await rabbitModelConsumer.Ask <bool>("start");
EventingBasicConsumer x = (EventingBasicConsumer)mockConsumer;
x.HandleBasicDeliver("", 1, false, "", "", null, messageBody);
// Assert
Assert.IsTrue(started);
messageConsumerActorRef.ExpectMsg <IConsumedMessage>(
consumedMessage => consumedMessage.Message == messageBody);
}
public Task BasicConsume(string queueUrl, ReceiveSettings receiveSettings, IBasicConsumer consumer)
{
return(Task.Factory.StartNew(async() =>
{
while (!CancellationToken.IsCancellationRequested)
{
var request = new ReceiveMessageRequest(queueUrl)
{
MaxNumberOfMessages = receiveSettings.PrefetchCount,
WaitTimeSeconds = receiveSettings.WaitTimeSeconds,
AttributeNames = new List <string> {
"All"
},
MessageAttributeNames = new List <string> {
"All"
}
};
var response = await _amazonSqs.ReceiveMessageAsync(request, CancellationToken).ConfigureAwait(false);
await Task.WhenAll(response.Messages.Select(consumer.HandleMessage)).ConfigureAwait(false);
}
}, CancellationToken, TaskCreationOptions.None, _taskScheduler));
}
public static Task <string> CancelAsync(this IBasicConsumer consumer, CancellationToken token = default(CancellationToken))
{
var eventConsumer = consumer as EventingBasicConsumer;
if (eventConsumer == null)
{
throw new NotSupportedException("Can only cancellation EventBasicConsumer");
}
var cancelTcs = new TaskCompletionSource <string>();
token.Register(() => cancelTcs.TrySetCanceled());
var tag = eventConsumer.ConsumerTag;
consumer.ConsumerCancelled += (sender, args) =>
{
if (args.ConsumerTag != tag)
{
return;
}
cancelTcs.TrySetResult(args.ConsumerTag);
};
consumer.Model.BasicCancel(eventConsumer.ConsumerTag);
return(cancelTcs.Task);
}
public string BasicConsume(string queue, bool noAck, string consumerTag, bool noLocal, bool exclusive, IDictionary<string, object> arguments,
IBasicConsumer consumer)
{
throw new NotImplementedException();
}
public string BasicConsume(string queue, bool noAck, string consumerTag, IBasicConsumer consumer)
{
throw new NotImplementedException();
}
Task<string> ModelContext.BasicConsume(string queue, bool noAck, IBasicConsumer consumer)
{
return Task.Factory.StartNew(() => _model.BasicConsume(queue, noAck, consumer),
_participant.StoppedToken, TaskCreationOptions.None, _taskScheduler);
}
Task <string> ModelContext.BasicConsume(string queue, bool noAck, IBasicConsumer consumer)
{
return(_context.BasicConsume(queue, noAck, consumer));
}
public SubscriptionInfo(IBasicConsumer consumer, MessageCallback callback)
{
Consumer = consumer;
Callback = callback;
}
internal protected override void DoAck(BasicDeliverEventArgs basicDeliverEventArgs, IBasicConsumer subscriptionInfo)
{
if (IsDisposed)
{
return;
}
_subscription.Ack(basicDeliverEventArgs.ConsumerTag, basicDeliverEventArgs.DeliveryTag);
}
public string BasicConsume(string queue,
bool noAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary<string, object> arguments,
IBasicConsumer consumer)
{
var result = m_delegate.BasicConsume(queue, noAck, consumerTag, noLocal,
exclusive, arguments, consumer);
RecordedConsumer rc = new RecordedConsumer(this, queue).
WithConsumerTag(result).
WithConsumer(consumer).
WithExclusive(exclusive).
WithAutoAck(noAck).
WithArguments(arguments);
m_connection.RecordConsumer(result, rc);
return result;
}
public string BasicConsume(string queue, bool noAck, string consumerTag, IBasicConsumer consumer)
{
if (!connection.Queues.ContainsKey(queue))
{
throw new InMemoryClientException(string.Format("Queue '{0}' does not exist", queue));
}
connection.Queues[queue].AddConsumer(noAck, consumerTag, consumer);
return "";
}
public void BasicConsume(string queue, bool noAck, IBasicConsumer consumer)
{
InSingleProcessMemoryBus.BasicConsume(queue, noAck, consumer);
}
public string BasicConsume(string queue,
bool autoAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary<string, object> arguments,
IBasicConsumer consumer)
{
var k = new BasicConsumerRpcContinuation { m_consumer = consumer };
Enqueue(k);
// Non-nowait. We have an unconventional means of getting
// the RPC response, but a response is still expected.
_Private_BasicConsume(queue, consumerTag, noLocal, autoAck, exclusive,
/*nowait:*/ false, arguments);
k.GetReply(this.ContinuationTimeout);
string actualConsumerTag = k.m_consumerTag;
return actualConsumerTag;
}
public string BasicConsume(string queue, bool noAck, IDictionary filter, IBasicConsumer consumer)
{
throw new NotImplementedException();
}
public string BasicConsume(string queue,
bool noAck,
IBasicConsumer consumer)
{
return(BasicConsume(queue, noAck, "", consumer));
}
private void HandleEvent(IBasicConsumer sender, BasicDeliverEventArgs args)
{
var elementBody = Encoding.Unicode.GetString(args.Body);
var element = XElement.Parse(elementBody);
DecodeAndRouteEvent(element);
}
public void DoAckForTest(BasicDeliverEventArgs basicDeliverEventArgs, IBasicConsumer subscriptionInfo)
{
DoAck(basicDeliverEventArgs, subscriptionInfo);
}
public ModelShutdown(IBasicConsumer consumer, ShutdownEventArgs reason) : base(consumer)
{
this.reason = reason;
}
protected abstract string Subscribe(IBasicConsumer consumer);
internal protected override void DoAck(BasicDeliverEventArgs basicDeliverEventArgs, IBasicConsumer subscriptionInfo)
{
base.DoAck(basicDeliverEventArgs, subscriptionInfo);
WaitHandler.Set();
}
protected Work(IBasicConsumer consumer)
{
asyncConsumer = (IAsyncBasicConsumer)consumer;
}
public BasicCancelOk(IBasicConsumer consumer, string consumerTag) : base(consumer)
{
this.consumerTag = consumerTag;
}
/// <summary>Start a Basic content-class consumer.</summary>
public static string BasicConsume(this IModel model, string queue, bool autoAck, IBasicConsumer consumer)
{
return(model.BasicConsume(queue, autoAck, "", false, false, null, consumer));
}
async Task <string> ModelContext.BasicConsume(string queue, bool noAck, IBasicConsumer consumer)
{
return(await Task.Factory.StartNew(() => _model.BasicConsume(queue, noAck, consumer),
_tokenSource.Token, TaskCreationOptions.HideScheduler, _taskScheduler).ConfigureAwait(false));
}
protected void TestExceptionHandlingWith(IBasicConsumer consumer, FailingOp fn)
{
Object o = new Object();
bool notified = false;
string q = Model.QueueDeclare();
Model.CallbackException += (m, evt) => {
notified = true;
Monitor.PulseAll(o);
};
string tag = Model.BasicConsume(q, true, consumer);
fn(Model, q, consumer, tag);
WaitOn(o);
Assert.IsTrue(notified);
}
Task <string> ModelContext.BasicConsume(string queue, bool noAck, bool exclusive, IDictionary <string, object> arguments, IBasicConsumer consumer)
{
return(_context.BasicConsume(queue, noAck, exclusive, arguments, consumer));
}
public string BasicConsume(string queue,
bool noAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary<string, object> arguments,
IBasicConsumer consumer)
{
ModelShutdown += new ModelShutdownEventHandler(consumer.HandleModelShutdown);
BasicConsumerRpcContinuation k = new BasicConsumerRpcContinuation();
k.m_consumer = consumer;
Enqueue(k);
// Non-nowait. We have an unconventional means of getting
// the RPC response, but a response is still expected.
_Private_BasicConsume(queue, consumerTag, noLocal, noAck, exclusive,
/*nowait:*/ false, arguments);
k.GetReply();
string actualConsumerTag = k.m_consumerTag;
return actualConsumerTag;
}
public string BasicConsume(string queue,
bool noAck,
string consumerTag,
IDictionary<string, object> arguments,
IBasicConsumer consumer)
{
return BasicConsume(queue, noAck, consumerTag, false, false, arguments, consumer);
}
public string BasicConsume(string queue,
bool noAck,
string consumerTag,
IBasicConsumer consumer)
{
return BasicConsume(queue, noAck, consumerTag, null, consumer);
}
public string BasicConsume(string queue,
bool noAck,
IBasicConsumer consumer)
{
return BasicConsume(queue, noAck, "", consumer);
}
private void ConsumerReceived(IBasicConsumer sender, BasicDeliverEventArgs args)
{
var serializer = new BinarySerializer<string>();
var message = serializer.DeSerialize(args.Body);
OnMessageReceived(message);
}
