public void PublishReply <TRequestMessage, TReplyMessage>(PublicationAddress publicationAddress,
TReplyMessage replyMessage,
IBasicProperties replyProperties)
{
IModel channel = _connection.CreateModel();
if (publicationAddress.ExchangeName != string.Empty)
{
channel.ExchangeDeclare(publicationAddress.ExchangeName, publicationAddress.ExchangeType, false, true, null);
}
IConsumeInfo consumeInfo = _consumeRouteConfiguration.GetRouteInfo(typeof(TRequestMessage));
ISerializationStrategy serializationStrategy = consumeInfo.SerializationStrategy ?? _defaultSerializationStrategy;
byte[] bytes = serializationStrategy.Serialize(replyMessage);
channel.BasicPublish(publicationAddress, replyProperties, bytes);
channel.Close();
string log = string.Format("Published reply message to host: {0}, port: {1}, exchange: {2}, routingKey: {3}",
_connection.Endpoint.HostName,
_connection.Endpoint.Port,
publicationAddress.ExchangeName,
publicationAddress.RoutingKey);
Logger.Current.Write(log, TraceEventType.Information);
}
void PublishMessage <TRequestMessage, TReplyMessage>(TRequestMessage message, MessageProperties messageProperties,
Action <IMessageContext <TReplyMessage> > replyAction,
TimeSpan timeout)
{
PublishMessage(message, messageProperties, (p, pi) =>
{
IConsumeInfo replyInfo = pi.ReplyInfo;
string queueName = Guid.NewGuid().ToString();
p.ReplyTo = new PublicationAddress(replyInfo.ExchangeType, "", queueName).ToString();
p.CorrelationId = Guid.NewGuid().ToString();
ISerializationStrategy serializationStrategy = pi.SerializationStrategy ?? _defaultSerializationStrategy;
IConsumeInfo consumeInfo = CloneConsumeInfo(replyInfo);
consumeInfo.ExchangeName = "";
consumeInfo.QueueName = queueName;
consumeInfo.IsQueueExclusive = true;
new Subscription <TReplyMessage>(_connection,
_defaultDeadLetterConfiguration,
serializationStrategy,
consumeInfo,
queueName /* routing key */,
replyAction,
null,
x => { },
this,
SubscriptionType.RemoteProcedure,
timeout).Start();
});
}
public ConsumerContext(IConnection connection, IConsumeInfo consumeInfo,
ISerializationStrategy defaultSerializationStrategy, IMessagePublisher messagePublisher)
{
_consumeInfo = consumeInfo;
_defaultSerializationStrategy = defaultSerializationStrategy;
_messagePublisher = messagePublisher;
_channel = connection.CreateModel();
Logger.Current.Write(string.Format("Declaring exchange:\'{0}\' durable:{1} auto-delete:{2}",
consumeInfo.ExchangeName,
consumeInfo.IsExchangeDurable.ToString(CultureInfo.InvariantCulture),
consumeInfo.IsExchangeAutoDelete.ToString(CultureInfo.InvariantCulture)),
TraceEventType.Information);
_channel.ExchangeDeclare(consumeInfo.ExchangeName, consumeInfo.ExchangeType, consumeInfo.IsExchangeDurable,
consumeInfo.IsExchangeAutoDelete, null);
Logger.Current.Write(string.Format("Declaring queue:\'{0}\' durable:{1} auto-delete:{2}",
consumeInfo.QueueName,
consumeInfo.IsQueueDurable.ToString(CultureInfo.InvariantCulture),
consumeInfo.IsQueueAutoDelete.ToString(CultureInfo.InvariantCulture)),
TraceEventType.Information);
_channel.QueueDeclare(consumeInfo.QueueName, consumeInfo.IsQueueDurable, consumeInfo.IsQueueExclusive,
consumeInfo.IsQueueAutoDelete, null);
Logger.Current.Write(
string.Format("Binding queue \'{0}\' to exchange \'{1}\'", consumeInfo.QueueName, consumeInfo.ExchangeName),
TraceEventType.Information);
_channel.QueueBind(consumeInfo.QueueName, consumeInfo.ExchangeName, consumeInfo.DefaultRoutingKey);
}
public void SendRepy(IConsumeInfo consumed, byte[] body)
{
var eventArgs = ((RabbitMQConsumeInfo)consumed).EventArgs;
var properties = _model.CreateBasicProperties();
properties.CorrelationId = eventArgs.BasicProperties.CorrelationId;
_model.BasicPublish("", eventArgs.BasicProperties.ReplyTo, properties, body);
}
void SubscribeMessage <TMessage>(Action <IMessageContext <TMessage> > action, MessageProperties messageProperties)
{
IConsumeInfo routeInfo = _configurationModel.ConsumeRouteConfiguration.GetRouteInfo(typeof(TMessage));
var subscription = new Subscription <TMessage>(_connection, _configurationModel.DefaultDeadLetterConfiguration,
_configurationModel.DefaultSerializationStrategy,
routeInfo, messageProperties.RoutingKey, action, messageProperties.Headers, _defaultErrorCallback,
_messagePublisher, SubscriptionType.Subscription, TimeSpan.MinValue);
_subscriptions.Add(new SubscriptionKey(typeof(TMessage), messageProperties), subscription);
subscription.Start();
}
} // end RealData
public RealData(IConsumeInfo info)
{
if (null == info)
{
return;
}
// end if
HP = info.HP;
MP = info.MP;
HPR = info.HPR;
MPR = info.MPR;
XHR = info.XHR;
XMR = info.XMR;
} // end TreatData
public MessageContext(TMessage message, IConsumeInfo consumeInfo,
IModel channel, ulong deliveryTag, bool redelivered, string exchange, string routingKey,
IBasicProperties basicProperties, byte[] body, IMessagePublisher messagePublisher)
{
_consumeInfo = consumeInfo;
_channel = channel;
Id = deliveryTag;
Redelivered = redelivered;
Exchange = exchange;
RoutingKey = routingKey;
_basicProperties = basicProperties;
_body = body;
_messagePublisher = messagePublisher;
Message = message;
}
public Subscription(IConnection connection, IDeadLetterStrategy deadLetterStrategy,
ISerializationStrategy defaultSerializationStrategy, IConsumeInfo consumeInfo,
string routingKey,
Action <IMessageContext <TMessage> > callback, IDictionary exchangeArguments,
Action <IErrorContext> defaultErrorCallback, IMessagePublisher messagePublisher,
SubscriptionType subscriptionType, TimeSpan callbackTimeout)
{
_connection = connection;
_deadLetterStrategy = deadLetterStrategy;
_defaultSerializationStrategy = defaultSerializationStrategy;
_consumeInfo = consumeInfo;
_routingKey = routingKey ?? _consumeInfo.DefaultRoutingKey;
_callback = callback;
_defaultErrorCallback = defaultErrorCallback;
_messagePublisher = messagePublisher;
_subscriptionType = subscriptionType;
_callbackTimeout = callbackTimeout;
_exchangeArguments = exchangeArguments;
}
IConsumeInfo CloneConsumeInfo(IConsumeInfo consumeInfo)
{
return(new ConsumeInfo
{
ExchangeName = consumeInfo.ExchangeName,
QueueName = consumeInfo.QueueName,
DefaultRoutingKey = consumeInfo.DefaultRoutingKey,
IsQueueExclusive = consumeInfo.IsQueueExclusive,
IsAutoAcknowledge = consumeInfo.IsAutoAcknowledge,
IsQueueAutoDelete = consumeInfo.IsQueueAutoDelete,
IsExchangeAutoDelete = consumeInfo.IsExchangeAutoDelete,
IsQueueDurable = consumeInfo.IsQueueDurable,
IsExchangeDurable = consumeInfo.IsExchangeDurable,
ExchangeType = consumeInfo.ExchangeType,
SerializationStrategy = consumeInfo.SerializationStrategy,
ErrorCallback = consumeInfo.ErrorCallback,
QualityOfService = consumeInfo.QualityOfService
});
}
public ConsumerContext(IModel channel, IConsumeInfo consumeInfo)
{
_channel = channel;
_consumeInfo = consumeInfo;
}
public void Reject(IConsumeInfo consumed, bool requeue)
{
var eventArgs = ((RabbitMQConsumeInfo)consumed).EventArgs;
_model.BasicReject(eventArgs.DeliveryTag, requeue);
}
public void Ack(IConsumeInfo consumed)
{
var eventArgs = ((RabbitMQConsumeInfo)consumed).EventArgs;
_model.BasicAck(eventArgs.DeliveryTag, false);
}
