public Producer(IConnection connection, PayloadSerializerFactory serializer)
{
_connection = connection;
_serializer = serializer;
_channel = connection.CreateModel();
Serializer = serializer.GetSerializer(PayloadSerializerFactory.DefaultContentType);
}
public RpcClient(IConnection connection, PayloadSerializerFactory serviceProvider)
{
_connection = connection;
_payloadSerializer = serviceProvider;
_channel = connection.CreateModel();
Serializer = _payloadSerializer.GetSerializer(PayloadSerializerFactory.DefaultContentType);
}
private void Start <T>(string exchangeType, string exchangeName, string routingKey, string queueName, Action <Message <T> > messageReceived) where T : new()
{
lock (_channel)
{
_channel.ExchangeDeclare(exchange: exchangeName, type: exchangeType);
_channel.QueueDeclare(queue: queueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
_channel.QueueBind(queueName, exchangeName, routingKey);
_consumer = new EventingBasicConsumer(_channel);
_consumer.Received += (s, e) =>
{
try
{
var ser = _payloadSerializer.GetSerializer(e.BasicProperties.ContentType);
var msg = new Message <T>(ser.Deserialize <T>(e.Body))
{
CorrelationId = e.BasicProperties.CorrelationId,
ReplyTo = e.BasicProperties.ReplyTo
};
messageReceived(msg);
_channel.BasicAck(e.DeliveryTag, false);
}
catch (Exception)
{
_channel.BasicNack(e.DeliveryTag, false, true);
}
};
_consumerToken = _channel.BasicConsume(queueName, false, _consumer);
}
}
public RpcServer(IConnection connection, PayloadSerializerFactory payloadSerializer)
{
_connection = connection;
_payloadSerializer = payloadSerializer;
_channel = connection.CreateModel();
Serializer = _payloadSerializer.GetSerializer(PayloadSerializerFactory.DefaultContentType);
}
private void Start <T>(string exchangeType, string exchangeName, string routingKey, Action <Message <T> > messageReceived) where T : new()
{
_channel.ExchangeDeclare(exchange: exchangeName, type: exchangeType);
_queueName = _channel.QueueDeclare().QueueName;
_channel.QueueBind(_queueName, exchangeName, routingKey);
_consumer = new EventingBasicConsumer(_channel);
_consumer.Received += (s, e) =>
{
try
{
var serializer = _payloadSerializer.GetSerializer(e.BasicProperties.ContentType);
T body = serializer.Deserialize <T>(e.Body);
var message = new Message <T>(body)
{
CorrelationId = e.BasicProperties.CorrelationId,
ReplyTo = e.BasicProperties.ReplyTo,
Persistent = e.BasicProperties.Persistent
};
messageReceived(message);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
};
_consumerToken = _channel.BasicConsume(_queueName, true, _consumer);
}
public Task <Message <U> > SendCommand <T, U>(string commandQueueName, Message <T> command) where U : new()
{
var n = PublicationAddress.Parse(commandQueueName);
lock (_channel)
{
_channel.ExchangeDeclare(exchange: n.ExchangeName, n.ExchangeType, false, true, null);
var replyQueueName = _channel.QueueDeclare().QueueName;
_channel.QueueDeclare(n.ExchangeName, durable: false, exclusive: false, autoDelete: true, arguments: null);
TaskCompletionSource <Message <U> > result = new TaskCompletionSource <Message <U> >();
var corrId = Guid.NewGuid().ToString();
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (s, e) =>
{
if (e.BasicProperties.CorrelationId == corrId)
{
try
{
_channel.BasicCancel(_consumerTag);
var ser = _payloadSerializer.GetSerializer(e.BasicProperties.ContentType);
var answer = new Message <U>(ser.Deserialize <U>(e.Body));
result.SetResult(answer);
}
catch (Exception exception)
{
result.SetException(exception);
}
}
};
_consumerTag = _channel.BasicConsume(queue: replyQueueName, autoAck: true, consumer: consumer);
var props = _channel.CreateBasicProperties();
props.ContentType = Serializer.ContentType;
props.ReplyTo = replyQueueName;
props.CorrelationId = corrId;
props.Persistent = command.Persistent;
_channel.BasicPublish(exchange: "", n.ExchangeName, basicProperties: props, body: Serializer.Serialize(command.Payload));
return(result.Task);
}
}
public void Start <T, U>(string queueName, Func <Message <T>, Message <U> > commandReceived) where T : new()
{
var n = PublicationAddress.Parse(queueName);
_channel.QueueDeclare(n.ExchangeName, durable: false, exclusive: false, autoDelete: true, arguments: null);
_channel.BasicQos(0, 1, false);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (s, e) =>
{
try
{
try
{
var ser = _payloadSerializer.GetSerializer(e.BasicProperties.ContentType);
var command = new Message <T>(ser.Deserialize <T>(e.Body))
{
Persistent = e.BasicProperties.Persistent,
CorrelationId = e.BasicProperties.CorrelationId,
ReplyTo = e.BasicProperties.ReplyTo
};
var response = commandReceived(command);
var replyProps = _channel.CreateBasicProperties();
replyProps.ContentType = Serializer.ContentType;
replyProps.CorrelationId = e.BasicProperties.CorrelationId;
replyProps.Persistent = response.Persistent;
_channel.BasicPublish(exchange: "", routingKey: e.BasicProperties.ReplyTo,
basicProperties: replyProps, body: Serializer.Serialize(response.Payload));
_channel.BasicAck(deliveryTag: e.DeliveryTag, multiple: false);
}
catch (Exception)
{
_channel.BasicNack(e.DeliveryTag, false, false);
}
}
catch (Exception)
{
_channel.BasicNack(e.DeliveryTag, false, true);
}
};
_consumerToken = _channel.BasicConsume(queue: n.ExchangeName, autoAck: false, consumer: consumer);
}
private void Send <T>(string exchangeType, string exchangeName, string routingKey, string contentType, Message <T> message)
{
lock (_channel)
{
_channel.ExchangeDeclare(exchange: exchangeName, type: exchangeType);
var ser = _serializer.GetSerializer(contentType);
var body = ser.Serialize(message.Payload);
var props = _channel.CreateBasicProperties();
props.ContentType = ser.ContentType;
props.CorrelationId = message.CorrelationId;
props.ReplyTo = message.ReplyTo;
props.Persistent = message.Persistent;
_channel.BasicPublish(exchange: exchangeName, routingKey: routingKey, basicProperties: props, body: body);
}
}
