public void Should_not_overwrite_correlation_id()
{
var autoResetEvent = new AutoResetEvent(false);
const string expectedCorrelationId = "abc_foo";
var actualCorrelationId = "";
var queue = EasyNetQ.Topology.Queue.DeclareDurable("myqueue");
var exchange = EasyNetQ.Topology.Exchange.DeclareDirect("myexchange");
queue.BindTo(exchange, "#");
bus.Subscribe <MyMessage>(queue, (message, info) => Task.Factory.StartNew(() =>
{
actualCorrelationId = message.Properties.CorrelationId;
autoResetEvent.Set();
}));
var messageToSend = new Message <MyMessage>(new MyMessage());
messageToSend.Properties.CorrelationId = expectedCorrelationId;
using (var channel = bus.OpenPublishChannel())
{
channel.Publish(exchange, "abc", messageToSend);
}
autoResetEvent.WaitOne(1000);
actualCorrelationId.ShouldEqual(expectedCorrelationId);
}
public RabbitPublishChannel(RabbitBus bus, Action <IChannelConfiguration> configure, IConventions conventions)
{
Preconditions.CheckNotNull(conventions, "conventions");
this.bus = bus;
this.conventions = conventions;
advancedBus = bus.Advanced;
advancedPublishChannel = advancedBus.OpenPublishChannel(configure);
}
static void Main(string[] args)
{
string rabbitMQBrokerHost = "localhost";
string virtualHost = "machine";
string username = "******";
string password = "******";
string connectionString = string.Format(
"host={0};virtualHost={1};username={2};password={3}",
rabbitMQBrokerHost, virtualHost, username, password);
using (IAdvancedBus bus = RabbitHutch.CreateBus(connectionString).Advanced)
{
IExchange exchange = bus.ExchangeDeclare("machine", EasyNetQ.Topology.ExchangeType.Fanout);
IAdvancedPublishChannel boxPublishChannel = bus.OpenPublishChannel();
MachineInfo machineInfo = new MachineInfo();
var jobDataMap = new JobDataMap();
jobDataMap.Add("username", username);
jobDataMap.Add("IAdvancedBus", bus);
jobDataMap.Add("IExchange", exchange);
jobDataMap.Add("IAdvancedPublishChannel", boxPublishChannel);
jobDataMap.Add("MachineInfo", machineInfo);
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
// computer a time that is on the next round minute
DateTimeOffset runTime = DateBuilder.EvenMinuteDate(DateTimeOffset.UtcNow);
IJobDetail job = JobBuilder.Create <MachineMonitorJob>()
.UsingJobData(jobDataMap)
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartNow()
.WithSimpleSchedule(
x => x.WithInterval(TimeSpan.FromMilliseconds(1000)).RepeatForever())
.Build();
// Tell quartz to schedule the job using our trigger
sched.ScheduleJob(job, trigger);
// Start up the scheduler (nothing can actually run until the
// scheduler has been started)
sched.Start();
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
sched.Shutdown(true);
}
}
/// <summary>
/// Publishes Login messages to the MQ Exchange
/// </summary>
private void PublishMessages(Message <Login> loginMessage, string routingKey)
{
try
{
using (var channel = _advancedBus.OpenPublishChannel())
{
// Publish Messages to respective Queues
channel.Publish(_exchange, routingKey, loginMessage);
if (Logger.IsDebugEnabled)
{
Logger.Debug("Login request published", _type.FullName, "PublishMessages");
}
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "PublishMessages");
}
}
public void PublishToAnExchange()
{
var exchange = new Exchange("my_exchange");
using (var channel = advancedBus.OpenPublishChannel())
{
var body = Encoding.UTF8.GetBytes("Hello World!");
channel.Publish(exchange, "routing_key", new MessageProperties(), body);
}
Thread.Sleep(500);
}
public void RespondAsync <TRequest, TResponse>(Func <TRequest, Task <TResponse> > responder, IDictionary <string, object> arguments)
{
if (responder == null)
{
throw new ArgumentNullException("responder");
}
var requestTypeName = serializeType(typeof(TRequest));
var exchange = Exchange.DeclareDirect(RpcExchange);
var queue = Queue.DeclareDurable(requestTypeName, arguments);
queue.BindTo(exchange, requestTypeName);
advancedBus.Subscribe <TRequest>(queue, (requestMessage, messageRecievedInfo) =>
{
var tcs = new TaskCompletionSource <object>();
responder(requestMessage.Body).ContinueWith(task =>
{
if (task.IsFaulted)
{
Console.WriteLine("task faulted");
if (task.Exception != null)
{
tcs.SetException(task.Exception);
}
}
else
{
// check we're connected
while (!advancedBus.IsConnected)
{
Thread.Sleep(100);
}
var responseMessage = new Message <TResponse>(task.Result);
responseMessage.Properties.CorrelationId = requestMessage.Properties.CorrelationId;
using (var channel = advancedBus.OpenPublishChannel())
{
channel.Publish(Exchange.GetDefault(), requestMessage.Properties.ReplyTo, responseMessage);
}
tcs.SetResult(null);
}
});
return(tcs.Task);
});
}
public virtual void RespondAsync <TRequest, TResponse>(Func <TRequest, Task <TResponse> > responder)
where TRequest : class
where TResponse : class
{
Preconditions.CheckNotNull(responder, "responder");
var routingKey = conventions.RpcRoutingKeyNamingConvention(typeof(TRequest));
var exchange = advancedBus.ExchangeDeclare(conventions.RpcExchangeNamingConvention(), ExchangeType.Direct);
var queue = advancedBus.QueueDeclare(routingKey);
advancedBus.Bind(exchange, queue, routingKey);
advancedBus.Consume <TRequest>(queue, (requestMessage, messageRecievedInfo) =>
{
var tcs = new TaskCompletionSource <object>();
responder(requestMessage.Body).ContinueWith(task =>
{
if (task.IsFaulted)
{
Console.WriteLine("task faulted");
if (task.Exception != null)
{
tcs.SetException(task.Exception);
}
}
else
{
// check we're connected
while (!advancedBus.IsConnected)
{
Thread.Sleep(100);
}
var responseMessage = new Message <TResponse>(task.Result);
responseMessage.Properties.CorrelationId = requestMessage.Properties.CorrelationId;
using (var channel = advancedBus.OpenPublishChannel())
{
channel.Publish(new Exchange(""), requestMessage.Properties.ReplyTo, responseMessage, configuration => {});
}
tcs.SetResult(null);
}
});
return(tcs.Task);
});
}
public BoxViewModel(IAdvancedBus bus)
{
Box = new Box
{
Name = "player-1",
};
_bus = bus;
// create a direct exchange
_exchange = _bus.ExchangeDeclare("box", EasyNetQ.Topology.ExchangeType.Fanout);
//_queue = _bus.QueueDeclare("update." + Box.Name, durable: true, exclusive: false, autoDelete: false);
//_bus.Bind(_exchange, _queue, "update");
_boxPublishChannel = _bus.OpenPublishChannel();
}
public void Should_be_able_to_do_a_simple_publish_and_subscribe()
{
const string routingKey = "advanced_test_routing_key";
var autoResetEvent = new AutoResetEvent(false);
var exchange = Exchange.DeclareDirect("advanced_test_exchange");
var queue = Queue.DeclareDurable("advanced_test_queue");
queue.BindTo(exchange, routingKey);
advancedBus.Subscribe <MyMessage>(queue, (msg, messageReceivedInfo) =>
Task.Factory.StartNew(() =>
{
Console.WriteLine("Got Message: {0}", msg.Body.Text);
Console.WriteLine("ConsumerTag: {0}", messageReceivedInfo.ConsumerTag);
Console.WriteLine("DeliverTag: {0}", messageReceivedInfo.DeliverTag);
Console.WriteLine("Redelivered: {0}", messageReceivedInfo.Redelivered);
Console.WriteLine("Exchange: {0}", messageReceivedInfo.Exchange);
Console.WriteLine("RoutingKey: {0}", messageReceivedInfo.RoutingKey);
autoResetEvent.Set();
}));
var myMessage = new MyMessage {
Text = "Hello from the publisher"
};
var message = new Message <MyMessage>(myMessage);
message.Properties.AppId = "my_app_id";
message.Properties.ReplyTo = "my_reply_queue";
using (var channel = advancedBus.OpenPublishChannel())
{
channel.Publish(exchange, routingKey, message);
}
// give the test time to complete
autoResetEvent.WaitOne(1000);
}
public RabbitPublishChannel(RabbitBus bus)
{
this.bus = bus;
advancedBus = bus.Advanced;
advancedPublishChannel = advancedBus.OpenPublishChannel();
}
public RabbitPublishChannel(RabbitBus bus, Action <IChannelConfiguration> configure)
{
this.bus = bus;
advancedBus = bus.Advanced;
advancedPublishChannel = advancedBus.OpenPublishChannel(configure);
}
