private void Run(object t)
{
var token = (CancellationToken)t;
while (token.IsCancellationRequested == false)
{
var deliveryArgs = _subscription.Next();
try
{
var body = SerializationMethods.FromByteArray <TRequest>(deliveryArgs.Body);
TResponse response = _processRequest(body);
// Send Response
var replyProperties = _model.CreateBasicProperties();
replyProperties.CorrelationId = deliveryArgs.BasicProperties.CorrelationId;
_model.BasicPublish("", deliveryArgs.BasicProperties.ReplyTo, replyProperties, response.ToByteArray());
// Send acknowledge that received (and processed)
_model.BasicAck(deliveryArgs.DeliveryTag, false);
}
catch (Exception ex)
{
Console.WriteLine("Exception:" + ex.Message);
}
}
}
public void Start()
{
try
{
using (var context = ZmqContext.Create())
{
using (var socket = context.CreateSocket(SocketType.PULL))
{
foreach (var bindEndPoint in _bindEndPoints)
{
socket.Bind(bindEndPoint);
}
while (true)
{
var messageFrame = socket.ReceiveFrame();
var request = SerializationMethods.FromByteArray <T>(messageFrame.Buffer);
_process(request);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void Receive(object t)
{
var token = (CancellationToken)t;
while (token.IsCancellationRequested == false)
{
try
{
var ea = _consumer.Queue.Dequeue();
var body = SerializationMethods.FromByteArray <TResponse>(ea.Body);
var success = _processRequest(body);
}
catch (EndOfStreamException ex)
{
// This comes when connection is closed (some better way to detect this?)
if (ex.Message == "SharedQueue closed")
{
return;
}
}
catch (Exception ex)
{
Console.WriteLine("Exception:" + ex.Message);
}
}
}
public void Start(U startResponse)
{
try
{
using (var context = ZmqContext.Create())
{
using (var socket = context.CreateSocket(SocketType.REQ))
{
foreach (var connectEndpoint in _bindEndPoints)
{
socket.Connect(connectEndpoint);
}
var nextResponse = startResponse;
while (true)
{
var responseFrame = new Frame(nextResponse.ToByteArray());
socket.SendFrame(responseFrame);
var messageFrame = socket.ReceiveFrame();
var request = SerializationMethods.FromByteArray <T>(messageFrame.Buffer);
var reply = _process(request);
nextResponse = reply;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void _zmqSocket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msq = e.Socket.ReceiveMessage();
var request = SerializationMethods.FromByteArray <TRequest>(msq[1].Buffer);
_action(request);
}
private async void _socket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msg = e.Socket.ReceiveMessage();
// Response socket has index 1, Dealer 2
var request = SerializationMethods.FromByteArray <TData>(msg[1].Buffer);
await DoWork(request);
}
void pullSocket_ReceiveReady(object sender, SocketEventArgs e)
{
var messageFrame = e.Socket.ReceiveFrame();
var request = SerializationMethods.FromByteArray <TRequest>(messageFrame.Buffer);
var success = _clientProcess(request);
if (success)
{
_requests.Add(request);
}
}
protected override void ExecutionMethod()
{
try
{
var msq = _zmqSocket.ReceiveMessage();
var request = SerializationMethods.FromByteArray <TRequest>(msq[1].Buffer);
_action(request);
}
catch (Exception)
{
Debugger.Break();
throw;
}
}
public void ToAndFromByteArray()
{
var dh = new DataRequest {
Method = 2
};
ProtoBufHelper.Prepare(typeof(Object), typeof(DataRequest));
var bytes = dh.ToByteArray();
Assert.IsTrue(bytes.Length > 0, "Length is zero");
var deserialized = SerializationMethods.FromByteArray <DataRequest>(bytes);
Assert.AreEqual(dh.Method, deserialized.Method, "Not serialized correctly");
}
private void repSocket_ReceiveReady(object sender, SocketEventArgs e)
{
var rcvdMsg = e.Socket.ReceiveFrame();
var response = SerializationMethods.FromByteArray <TResponse>(rcvdMsg.Buffer);
var success = _workerProcess(response);
if (success)
{
// NOTE: _requests will block other REQs from connecting
// Should use e.g. some Pirate pattern
var request = _requests.Take();
var frame = new Frame(request.ToByteArray());
e.Socket.SendFrame(frame);
}
}
private async void _socket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msg = e.Socket.ReceiveMessage();
// Response socket has index 1, Dealer 2
var request = SerializationMethods.FromByteArray <TRequest>(msg[1].Buffer);
var response = await DoWork(request);
var envelope = new NetMQFrame(Encoding.UTF8.GetBytes(response.ToString()));
var body = new NetMQFrame(response.ToByteArray());
msg.Append(envelope);
msg.Append(body);
e.Socket.SendMessage(msg);
}
public void Start(Func <T, bool> processRequest)
{
var factory = new ConnectionFactory()
{
HostName = _hostName
};
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(_queueName, true, false, false, null);
// Fair dispatch
channel.BasicQos(0, 1, false);
var consumer = new QueueingBasicConsumer(channel);
channel.BasicConsume(_queueName, false, consumer);
while (true)
{
var ea = consumer.Queue.Dequeue() as BasicDeliverEventArgs;
try
{
var body = SerializationMethods.FromByteArray <T>(ea.Body);
var success = processRequest(body);
// Send acknowledge that received (and processed)
if (success)
{
channel.BasicAck(ea.DeliveryTag, false);
}
}
catch (Exception ex)
{
Console.WriteLine("Exception:" + ex.Message);
}
}
}
}
}
public TResponse SendRequest(TRequest request)
{
using (var socket = _context.CreateRequestSocket())
{
socket.Connect(_bindEndPoint);
var envelope = new NetMQFrame(Encoding.UTF8.GetBytes(request.ToString()));
var body = new NetMQFrame(request.ToByteArray());
var msq = new NetMQMessage();
msq.Append(envelope);
msq.Append(body);
socket.SendMessage(msq);
var responseMsg = socket.ReceiveMessage();
return(SerializationMethods.FromByteArray <TResponse>(responseMsg[3].Buffer));
}
}
private void Receive(object t)
{
var token = (CancellationToken)t;
while (token.IsCancellationRequested == false)
{
try
{
var ea = _consumer.Queue.Dequeue();
var body = SerializationMethods.FromByteArray <TResponse>(ea.Body);
var success = _processRequest(body);
}
catch (Exception ex)
{
Console.WriteLine("Exception:" + ex.Message);
}
}
}
public void Start(Func <CommonRequest, bool> processRequest)
{
var factory = new ConnectionFactory()
{
HostName = _hostName
};
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
// Fanout just broadcasts messages
channel.ExchangeDeclare(_exchangeName, "fanout");
// This will create an own queue to RabbitMQ server
var queueName = channel.QueueDeclare();
channel.QueueBind(queueName, _exchangeName, "");
var consumer = new QueueingBasicConsumer(channel);
channel.BasicConsume(queueName, true, consumer);
while (true)
{
var ea = consumer.Queue.Dequeue() as BasicDeliverEventArgs;
try
{
var body = SerializationMethods.FromByteArray <CommonRequest>(ea.Body);
var success = processRequest(body);
}
catch (Exception ex)
{
Console.WriteLine("Exception:" + ex.Message);
}
}
}
}
}
public void Start()
{
try
{
using (var context = ZmqContext.Create())
{
using (var socket = context.CreateSocket(SocketType.REP))
{
foreach (var bindEndPoint in _bindEndPoints)
{
socket.Bind(bindEndPoint);
}
while (true)
{
// Wait for a message
var rcvdMsg = socket.ReceiveFrame();
var response = SerializationMethods.FromByteArray <TResponse>(rcvdMsg.Buffer);
var ok = _process(response);
if (ok)
{
// NOTE: _requests will block other REQs from connecting
// Should use e.g. some Pirate pattern
var request = _requests.Take();
var frame = new Frame(request.ToByteArray());
socket.SendFrame(frame);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
