public static void SendRequest(Int32 request,ref ZmqSocket socket)
{
//ZmqSocket socket;
try
{
//socket = CreateSocket();
var message = new ZmqMessage();
message.Append(Encoding.UTF8.GetBytes(String.Format(" Hello {0}.", request)));
socket.SendMessage(message);
// TODO: add receive timeout as param
var dataResult = socket.ReceiveMessage();
Console.WriteLine(Encoding.UTF8.GetString(dataResult[0]));
Console.WriteLine(Encoding.UTF8.GetString(dataResult[1]));
}
catch (Exception ex)
{
socket.Close();
socket = CreateSocket();
Console.WriteLine(ex.ToString());
}
}
public void Start <T>() where T : IPayload
{
bool stop = false;
while (stop == false)
{
this.IsRunning = true;
string address = string.Empty;
ZmqMessage zmqmessage = null;
this.WriteLineToMonitor("Waiting for message");
byte[] messageAsBytes = null;
T message = this.ReceiveMessage <T>(this.subscriber, out zmqmessage, out address, out stop, out messageAsBytes, this.Serializer);
if (stop == true)
{
this.IsRunning = false;
}
this.WriteLineToMonitor("Received message");
if (message != null)
{
object[] parameters = new object[6];
parameters[0] = message;
parameters[1] = messageAsBytes;
parameters[2] = address;
parameters[3] = this.OutRoute;
parameters[4] = this.OutputChannel;
parameters[5] = this;
this.Workload.DynamicInvoke(parameters);
}
}
this.WriteLineToMonitor("Exiting actor");
}
public void Start()
{
if (m_Subscribes.Count > 0)
{
foreach (var item in m_Subscribes)
{
Socket.Subscribe(item);
}
}
if (m_Thread == null)
{
m_Thread = new Thread(new ThreadStart(() =>
{
while (true)
{
ZmqMessage msg = Socket.ReceiveMessage(new TimeSpan(0, 0, 1));
if (msg == null || msg.FrameCount == 0)
{
Thread.Sleep(1);
continue;
}
if (OnSUBReceived != null && msg.FrameCount > 1)
{
OnSUBReceived(Encoding.ASCII.GetString(msg[0]), FromArray(msg[1]));
}
}
}));
}
m_Thread.Start();
}
public void Start()
{
subThread = new BackgroundWorker();
subThread.DoWork += new DoWorkEventHandler(subThread_DoWork);
subThread.RunWorkerAsync();
using (var ctx = ZmqContext.Create())
{
using (var socket = ctx.CreateSocket(SocketType.PUB))
{
socket.Bind("tcp://127.0.0.1:5000");
while (true)
{
Thread.Sleep(1000);
// Create a ZmqMessage containing 3 frames
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 01")));
zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 02")));
zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 03")));
Console.WriteLine("PUB; publishing: ");
foreach (var msg in zmqMessage)
{
Console.WriteLine("\t" + Encoding.UTF8.GetString(msg));
}
socket.SendMessage(zmqMessage);
}
}
}
}
public void Socket_Send_Receive_Multipart_Test(string endpoint)
{
using (var receiver = new ZmqSocket(ZmqContext.Current, ZmqSocketType.Rep))
using (var senderContext = new ZmqContext())
using (var sender = (endpoint.StartsWith("inproc") ? ZmqContext.Current : senderContext).Socket(ZmqSocketType.Req))
{
receiver.Bind(endpoint);
sender.Connect(endpoint);
var message1 = MessageTests.GetTestData();
var message2 = MessageTests.GetTestData();
sender.Send(message1, ZmqSendReceiveFlags.SendMore);
sender.Send(message2);
using (var receivedMessage1 = new ZmqMessage())
{
receiver.Receive(receivedMessage1);
CollectionAssert.AreEqual(message1, receivedMessage1.ToArray());
Assert.IsTrue(receivedMessage1.HasMore);
}
using (var receivedMessage2 = new ZmqMessage())
{
receiver.Receive(receivedMessage2);
CollectionAssert.AreEqual(message2, receivedMessage2.ToArray());
Assert.IsFalse(receivedMessage2.HasMore);
}
}
}
public void Start()
{
subThread = new BackgroundWorker();
subThread.DoWork += new DoWorkEventHandler(subThread_DoWork);
subThread.RunWorkerAsync();
using (var ctx = ZmqContext.Create())
{
using(var socket = ctx.CreateSocket(SocketType.PUB))
{
socket.Bind("tcp://127.0.0.1:5000");
while (true)
{
Thread.Sleep(1000);
// Create a ZmqMessage containing 3 frames
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 01")));
zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 02")));
zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 03")));
Console.WriteLine("PUB; publishing: ");
foreach (var msg in zmqMessage)
Console.WriteLine("\t" + Encoding.UTF8.GetString(msg));
socket.SendMessage(zmqMessage);
}
}
}
}
/// <summary>
///向服务端发送传送文件的请求,服务端返回数据通信的端口
/// </summary>
/// <returns>服务端通信端口号</returns>
private ushort GetServerPort(string requestData)
{
Send(FTPVPORT, _encoding.GetBytes(requestData));
ZmqMessage message = _ftpSocket.ReceiveMessage(new TimeSpan(0, 1, 0));
if (message.FrameCount == 0)
{
ReStart();
throw new TimeoutException("发送超时，请检查你的网络是否有问题");
}
else
{
string responseData = _encoding.GetString(message[message.FrameCount - 1].Buffer);
string[] temp = responseData.Split(':');
if ("Success" == temp[0])
{
return(ushort.Parse(temp[1]));
}
else if ("Error" == temp[0])
{
throw new FtpException(temp[1]);
}
else
{
throw new FtpException("未知的服务器返回信息");
}
}
}
public void Start()
{
subThread = new BackgroundWorker();
subThread.DoWork += new DoWorkEventHandler(subThread_DoWork);
subThread.RunWorkerAsync();
using (var ctx = ZmqContext.Create())
{
using(var socket = ctx.CreateSocket(SocketType.PUB))
{
socket.Bind("tcp://127.0.0.1:5000");
while (true)
{
Thread.Sleep(1000);
var shoppingBasket = new ShoppingBasket()
{
StoreName = "Fruits City",
ShoppingItems = new List<ShoppingItem>() {
new ShoppingItem() { Description="Orange", Weight=0.5f},
new ShoppingItem() { Description="Apple", Weight=1.4f},
new ShoppingItem() { Description="Banana", Weight=0.75f}}
};
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(
new Frame(Encoding.UTF8.GetBytes("Shopping Basket")));
zmqMessage.Append(
JsonFrame.Serialize<ShoppingBasket>(shoppingBasket));
Console.WriteLine("PUB; publishing: ");
Console.WriteLine("\t" + Encoding.UTF8.GetString(zmqMessage[0]));
Console.WriteLine("\t" + Encoding.UTF8.GetString(zmqMessage[1]));
socket.SendMessage(zmqMessage);
}
}
}
}
private DynObject Transfer(ushort serverPort, byte[] buffer, int count)
{
//发送数据
Send(serverPort, buffer);
ZmqMessage message = _ftpSocket.ReceiveMessage(new TimeSpan(0, 1, 30));
if (message.FrameCount == 0)
{
_isWorking = false;
ReStart();
throw new TimeoutException("发送超时，请检查你的网络是否有问题,稍后重新上传");
}
else
{
//反序列化，取出服务端响应数据
byte[] respData = message[message.FrameCount - 1].Buffer;
TSerializer serializer = new TBinarySerializer();
serializer.FromBytes(respData);
DynObject fileFragment = DynSerialize.ReadDynObject(serializer);
serializer.Flush();
//105：发生异常
if ((byte)fileFragment["State"] == 105)
{
_isWorking = false;
throw new ApplicationException(fileFragment["ExcepMsg"] as string);
}
return(fileFragment);
}
}
public static T ReceiveMessageofType <T>(ZmqSocket sub)
{
string address = string.Empty;
ZmqMessage message = null;
return(ReceiveMessage <T>(sub, out message, out address));
}
//public void SendOneMessageOfType<T>(string Address, T message, ISerializer serializer, ZmqSocket publisher)
//{
// ZmqMessage zmqMessage = new ZmqMessage();
// zmqMessage.Append(new Frame(Encoding.Unicode.GetBytes(Address)));
// zmqMessage.Append(new Frame(serializer.GetBuffer(message)));
// publisher.SendMessage(zmqMessage);
//}
public static T ReceiveMessage <T>(ZmqSocket Subscriber, out ZmqMessage zmqMessage, out string address)
{
T result = default(T);
ZmqMessage zmqOut = new ZmqMessage();
bool hasMore = true;
string message = "";
address = string.Empty;
int i = 0;
while (hasMore)
{
Frame frame = Subscriber.ReceiveFrame();
if (i == 0)
{
address = Encoding.Unicode.GetString(frame.Buffer);
}
if (i == 1)
{
result = (T)JsonConvert.DeserializeObject <T>(Encoding.Unicode.GetString(frame.Buffer));
}
i++;
zmqOut.Append(new Frame(Encoding.Unicode.GetBytes(message)));
hasMore = Subscriber.ReceiveMore;
}
zmqMessage = zmqOut;
return(result);
}
public static void SendMessage(byte[] address, byte[] message, ZmqSocket socket)
{
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(address));
zmqMessage.Append(new Frame(message));
socket.SendMessage(zmqMessage);
}
private void Recevier()
{
using (ZmqSocket monitorSocket = _context.CreateSocket(SocketType.DEALER))
{
monitorSocket.Identity = BitConverter.GetBytes(_localPort);
monitorSocket.SendHighWatermark = 10000000;
_isConnected = false;
while (!_isConnected)
{
try
{
monitorSocket.Connect(_inprocHost);
_isConnected = true;
}
catch
{
Thread.Sleep(500);
}
}
while (_isRunning)
{
ZmqMessage zmqMessage = monitorSocket.ReceiveMessage();
// 执行Rpc调用任务
Action <object> dealRpcAction = DealMessage;
Task.Factory.StartNew(dealRpcAction, zmqMessage);
}
}
}
private static void SendMessage(string address, string message, ISerializer serializer, ZmqSocket socket)
{
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(serializer.Encoding.GetBytes(address)));
zmqMessage.Append(new Frame(serializer.Encoding.GetBytes(message)));
socket.SendMessage(zmqMessage);
}
public void Send(string Head, string Msg)
{
var message = new ZmqMessage();
message.Append(new Frame(Encoding.ASCII.GetBytes(Head)));
message.Append(new Frame(Encoding.ASCII.GetBytes(Msg)));
Socket.SendMessage(message);
}
public void SendMessage(byte[] address, byte[] message, ZmqSocket socket)
{
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(address));
zmqMessage.Append(new Frame(message));
socket.SendMessage(zmqMessage);
}
public static void SendOneMessageOfType <T>(string Address, T message, ISerializer serializer, ZmqSocket publisher)
{
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(serializer.GetBuffer(Address)));
zmqMessage.Append(new Frame(serializer.GetBuffer(message)));
publisher.SendMessage(zmqMessage);
}
public void Send(string Head, object Msg)
{
var message = new ZmqMessage();
message.Append(new Frame(Encoding.ASCII.GetBytes(Head)));
message.Append(new Frame(ToArray(Msg, 819200)));
Socket.SendMessage(message);
}
public void Message_Empty_Create_Dispose_Test()
{
ZmqMessage message;
using (message = new ZmqMessage())
Assert.AreEqual(0, message.Size);
Assert.ThrowsException <ObjectDisposedException>(() => message.Size);
}
private static void SendOneSimpleMessage(string address, string message, ZmqSocket publisher)
{
{
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(Encoding.Unicode.GetBytes(address)));
zmqMessage.Append(new Frame(Encoding.Unicode.GetBytes(message)));
publisher.SendMessage(zmqMessage);
}
}
public void Message_Read_Write_Test()
{
var testData = GetTestData();
using (var message = new ZmqMessage(TestMessageSize))
{
message.CopyFrom(testData);
CollectionAssert.AreEqual(testData, message.ToArray());
}
}
static void publisher_SendReady(object sender, SocketEventArgs e)
{
Thread.Sleep(2000);
Console.WriteLine("发布者：发送--P发布订阅模式UB");
var zmqMessage = new ZmqMessage();
zmqMessage.Append(Encoding.UTF8.GetBytes("发布者发布数据……"));
e.Socket.SendMessage(zmqMessage);
//throw new NotImplementedException();
}
private static async Task <ZmqMessage> LoopReceiver(ZmqSocket sub)
{
ZmqMessage zmqMessage = null;
while (zmqMessage == null)
{
zmqMessage = Helper.ReceiveMessage(sub);
//isReady = true;
}
return(zmqMessage);
}
public void SendOneMessageOfType <T>(string address, T message, ISerializer serializer, ZmqSocket socket) where T : IPayload
{
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(serializer.GetBuffer(address)));
zmqMessage.Append(new Frame(serializer.GetBuffer(message)));
////var replySignal = this.sendControlChannel.Receive(Pipe.ControlChannelEncoding);
socket.SendMessage(zmqMessage);
////this.sendControlChannel.Send("Just sent message to " + address + " Message is: " + message, Pipe.ControlChannelEncoding);
////replySignal = this.sendControlChannel.Receive(Pipe.ControlChannelEncoding);
////Actor.Writeline(replySignal);
}
public void Message_WithSize_Create_Dispose_Test()
{
ZmqMessage message;
using (message = new ZmqMessage(TestMessageSize))
{
Assert.AreEqual(TestMessageSize, message.Size);
Assert.AreNotEqual(IntPtr.Zero, message.DangerousGetData());
}
Assert.ThrowsException <ObjectDisposedException>(() => message.Size);
}
public WhenTransferringMultipartMessages()
{
SenderAction = req =>
{
SendResult1 = SendResult2 = req.SendMessage(new ZmqMessage(new[] { Messages.MultiFirst, Messages.MultiLast }));
};
ReceiverAction = rep =>
{
Message = rep.ReceiveMessage();
};
}
static void Main(string[] args)
{
using (var context = ZmqContext.Create())
{
using (var subscriber = context.CreateSocket(ZeroMQ.SocketType.SUB))
using (var syncclient = context.CreateSocket(ZeroMQ.SocketType.REQ))
{
// First, connect our subscriber socket
subscriber.Connect("tcp://172.16.73.88:5561");
subscriber.SubscribeAll();
// 0MQ is so fast, we need to wait a while…
Thread.Sleep(1);
// Second, synchronize with publisher
syncclient.Connect("tcp://172.16.73.88:5562");
// - send a synchronization request
syncclient.Send(new Frame(Encoding.UTF8.GetBytes(@"")));
// - wait for synchronization reply
syncclient.ReceiveFrame();
// Third, get our updates and report how many we got
int i = 0;
while (true)
{
//Frame frame = subscriber.ReceiveFrame();
ZmqMessage zmqMessage = subscriber.ReceiveMessage();
var s1 = Encoding.UTF8.GetString(zmqMessage[0]);
//var s=frame.ReceiveStatus;
//byte[] b = frame.Buffer;
//string text = Encoding.UTF8.GetString(b);
//string text = frame.ReadString();
//if (text == "END")
//{
// break;
//}
//frame.Position = 0;
//Console.WriteLine("Receiving {0}...", text);
Console.WriteLine("Receiving {0}...", s1);
++i;
}
Console.WriteLine("Received {0} updates.", i);
}
}
}
public WhenSendingAMultipartMessageInBlockingMode()
{
SenderAction = req =>
{
SendResult1 = req.SendFrame(Messages.MultiFirst);
SendResult2 = req.SendFrame(Messages.MultiLast);
};
ReceiverAction = rep =>
{
Message = rep.ReceiveMessage();
};
}
public void SendOneMessageInProc()
{
string expectedAddress = "XXXX";
string message = "hello its me";
int count = 0;
using (var context = ZmqContext.Create())
{
using (var forwarderDevice = new ForwarderDevice(context, "tcp://*:5555", "inproc://back", DeviceMode.Threaded))
{
forwarderDevice.Start();
while (!forwarderDevice.IsRunning)
{
}
using (var sub = Helper.GetConnectedSubscribeSocket(context, "inproc://back"))
{
using (var pub = Helper.GetConnectedPublishSocket(context, "tcp://localhost:5555"))
{
ZmqMessage zmqMessage = null;
var task = Task.Run(() =>
{
if (sub != null)
{
//while (interupt != true)
//{
zmqMessage = Helper.ReceiveMessage(sub);
//if (zmqMessage.FrameCount > 0)
//{
// interupt = true;
//}
//}
}
return(zmqMessage);
});
if (pub != null)
{
Helper.SendOneSimpleMessage(expectedAddress, message, pub);
}
task.Wait();
Assert.AreEqual(count, zmqMessage.FrameCount);
Frame frame = zmqMessage[0];
var address = Encoding.Unicode.GetString(frame.Buffer);
Assert.AreEqual(expectedAddress, address);
}
}
forwarderDevice.Stop();
}
}
}
private void Received()
{
using (ZmqSocket clientSocket = _context.CreateSocket(SocketType.REP))
{
clientSocket.Identity = BitConverter.GetBytes(_localPort);
clientSocket.SendHighWatermark = 10000;
bool isConnected = false;
while (!isConnected)
{
try
{
clientSocket.Connect(_inprocHost);
isConnected = true;
}
catch
{
Thread.Sleep(500);
}
}
try
{
while (_isRunning)
{
ZmqMessage zmqMessage = clientSocket.ReceiveMessage(new TimeSpan(0, 2, 0));
if (zmqMessage.FrameCount == 0)
{
//一分钟内没有收到任何消息，自行关闭
_isRunning = false;
continue;
}
VirtuaIP originVIP = new VirtuaIP(zmqMessage[0].Buffer);
ushort originPort = (ushort)BitConverter.ToInt16(zmqMessage[2].Buffer, 0);
byte[] respMsg = DealMessage(zmqMessage[zmqMessage.FrameCount - 1].Buffer);
//向客户端返回数据
clientSocket.SendMore(originVIP.ToBytes());
clientSocket.SendMore(BitConverter.GetBytes(originPort));
clientSocket.SendMore(BitConverter.GetBytes(_localPort));
clientSocket.Send(respMsg);
}
}
catch (ThreadInterruptedException) { }
}
//自行关闭释放资源
Dispose(false);
}
public void Send(object message, string topic = null)
{
var typeName = MessageTypeRegistry.GetTypeName(message.GetType());
var data = _serializer.Serialize(message);
if (topic == null)
topic = typeName;
var msg = new ZmqMessage();
msg.Append(new Frame(ZmqContext.DefaultEncoding.GetBytes(topic)));
msg.Append(new Frame(ZmqContext.DefaultEncoding.GetBytes(typeName)));
msg.Append(new Frame(data));
_messages.OnNext(msg);
}
private static Task RunSubscriber()
{
using (var context = ZmqContext.Create())
{
using (ZmqSocket sub = Helper.GetConnectedSubscribeSocket(context, Pipe.SubscribeAddressClient),
syncClient = context.CreateSocket(SocketType.REQ))
{
syncClient.Connect(Pipe.PubSubControlBackAddressClient);
Console.WriteLine("Send message that you are connected=>");
Console.ReadLine();
syncClient.Send("", Encoding.Unicode);
syncClient.Receive(Encoding.Unicode);
Console.WriteLine("Received acknowledgement=>");
// Console.ReadLine();
bool run = true;
string input;
while (run)
{
ZmqMessage zmqMessage = null;
while (zmqMessage == null)
{
zmqMessage = Helper.ReceiveMessage(sub);
}
//Assert.AreEqual(2, zmqMessage.FrameCount);
Frame frame = zmqMessage[0];
var address = Encoding.Unicode.GetString(frame.Buffer);
Console.WriteLine(address);
frame = zmqMessage[1];
var message = Encoding.Unicode.GetString(frame.Buffer);
Console.Write(" " + message);
Console.WriteLine();
Console.WriteLine("Received message Exit to Exit=>");
input = Console.ReadLine();
if (input == "exit")
{
break;
}
}
}
return(null);
}
}
public WhenSendingAMultipartMessageWithAnAmpleTimeout()
{
SenderAction = req =>
{
SendResult1 = req.SendFrame(Messages.MultiFirst, TimeSpan.FromMilliseconds(2000));
SendResult2 = req.SendFrame(Messages.MultiLast, TimeSpan.FromMilliseconds(2000));
};
ReceiverAction = rep =>
{
Message = new ZmqMessage(new[]
{
rep.ReceiveFrame(TimeSpan.FromMilliseconds(2000)),
rep.ReceiveFrame(TimeSpan.FromMilliseconds(2000))
});
};
}
public void Start()
{
subThread = new BackgroundWorker();
subThread.DoWork += new DoWorkEventHandler(subThread_DoWork);
subThread.RunWorkerAsync();
using (var ctx = ZmqContext.Create())
{
using (var socket = ctx.CreateSocket(SocketType.PUB))
{
socket.Bind("tcp://127.0.0.1:5000");
while (true)
{
Thread.Sleep(1000);
var shoppingBasket = new ShoppingBasket()
{
StoreName = "Fruits City",
ShoppingItems = new List <ShoppingItem>()
{
new ShoppingItem()
{
Description = "Orange", Weight = 0.5f
},
new ShoppingItem()
{
Description = "Apple", Weight = 1.4f
},
new ShoppingItem()
{
Description = "Banana", Weight = 0.75f
}
}
};
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(
new Frame(Encoding.UTF8.GetBytes("Shopping Basket")));
zmqMessage.Append(
JsonFrame.Serialize <ShoppingBasket>(shoppingBasket));
Console.WriteLine("PUB; publishing: ");
Console.WriteLine("\t" + Encoding.UTF8.GetString(zmqMessage[0]));
Console.WriteLine("\t" + Encoding.UTF8.GetString(zmqMessage[1]));
socket.SendMessage(zmqMessage);
}
}
}
}
/// <summary>
/// 向服务端发送下载文件的请求
/// </summary>
/// <param name="destVPort">目的端口</param>
/// <param name="downloadPath">要下载的文件在服务端的路径</param>
/// <returns>将要下载文件的基本信息</returns>
private DynObject RequestDownload(ushort destVPort, string downloadPath)
{
DynObject fileFragment = new DynObject("FileFragment");
fileFragment["Path"] = Path.GetDirectoryName(downloadPath);
fileFragment["FileName"] = Path.GetFileName(downloadPath);
fileFragment["Extension"] = Path.GetExtension(downloadPath);
fileFragment["State"] = (byte)100;
fileFragment["MsgID"] = -1;
fileFragment["DataLength"] = 0;
fileFragment["Data"] = null;
//序列化要发送的数据
TSerializer serializer = new TBinarySerializer();
DynSerialize.WriteDynObject(serializer, fileFragment);
byte[] buffer = serializer.ToBytes();
serializer.Flush();
Send(_serverPort, buffer);
ZmqMessage msg = _ftpSocket.ReceiveMessage(new TimeSpan(0, 1, 30));
if (msg.FrameCount == 0)
{
_isWorking = false;
ReStart();
throw new TimeoutException("发送超时，请检查你的网络是否有问题,稍后重新下载");
}
//反序列化，服务器返回的数据
serializer = new TBinarySerializer();
serializer.FromBytes(msg[msg.FrameCount - 1].Buffer);
DynObject respFragment = DynSerialize.ReadDynObject(serializer);
serializer.Flush();
//发生异常
if ((byte)respFragment["State"] == 105)
{
_isWorking = false;
throw new FtpException(respFragment["ExcepMsg"] as string);
}
return(respFragment);
}
public static void SendRequestAsync(Int32 request)
{
ZmqSocket socket;
try
{
socket = CreateSocket();
Func<ZmqSocket, Int32, Object> sendData = (s, rq) =>
{
var message = new ZmqMessage();
message.Append(Encoding.UTF8.GetBytes(String.Format(" Hello {0}.", rq)));
s.Connect(routerEndpoint);
s.SendMessage(message);
// TODO: add receive timeout as param
return s.ReceiveMessage();
};
sendData.BeginInvoke(socket, request, new AsyncCallback((ar) =>
{
AsyncResult result = (AsyncResult)ar;
var caller = result.AsyncDelegate;
var dataResult = (ZmqMessage)((Func<ZmqSocket, Int32, Object>)caller).EndInvoke(ar);
var rq = ((AsyncState)ar.AsyncState).Request;
Console.WriteLine(Encoding.UTF8.GetString(dataResult[0]));
Console.WriteLine(Encoding.UTF8.GetString(dataResult[1]));
((AsyncState)ar.AsyncState).Socket.Close();
}), new AsyncState(socket, request));
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public static void Connect()
{
using (var context = ZmqContext.Create())
{
using (ZmqSocket req = context.CreateSocket(SocketType.REQ), subscriber = context.CreateSocket(SocketType.SUB))
{
//Console.WriteLine("Aplication started");
//Console.WriteLine("Bind Request socket ")
req.Connect(_requestConnectionString);
subscriber.Connect(_subscribeConnectionString);
subscriber.SubscribeAll();
req.Send(Encoding.UTF8.GetBytes("Hello"));
var syncmsg = ZeroMQ.SendReceiveExtensions.Receive(req, Encoding.UTF8, _connectionTimeout);
//Receive(Encoding.UTF8,_connectionTimeout);
if (syncmsg != null)
_isConnected = true;
else
{
NotifyOnError("Can`t connect to data server");
}
while(_isConnected)
{
ZmqMessage msg=new ZmqMessage();
try
{
msg = subscriber.ReceiveMessage();
string msgTitle = Encoding.UTF8.GetString(msg[0]);
//object result;
switch (msgTitle)
{
case "COMMON":
NotifyOnInitialDataLoaded(Encoding.UTF8.GetString(msg[1]));
break;
case "NEWINSTRUMENT":
NotifyOnNewInstrument(JsonConvert.DeserializeObject<StaticInstrument>(Encoding.UTF8.GetString(msg[1])));
break;
case "NEWACCOUNT":
NotifyOnNewAccount(JsonConvert.DeserializeObject<Account>(Encoding.UTF8.GetString(msg[1])));
break;
case "INSTRUMENT":
NotifyOnInstrument(JsonConvert.DeserializeObject<DynamicInstrument>(Encoding.UTF8.GetString(msg[1])));
break;
case "POSITION":
NotifyOnPosition(JsonConvert.DeserializeObject<Position>(Encoding.UTF8.GetString(msg[1])));
break;
case "NEWPOSITION":
NotifyOnNewPosition(JsonConvert.DeserializeObject<Position>(Encoding.UTF8.GetString(msg[1])));
break;
case "ACCOUNT":
NotifyOnAccount(JsonConvert.DeserializeObject<Account>(Encoding.UTF8.GetString(msg[1])));
break;
default: throw new Exception("Unknown message title");
}
}
catch (SystemException e)
{
Console.Write(e.Message);
}
//Object obj = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(msg[1]));
//Console.WriteLine("Title={0} Data={1}", msgTitle, result.ToString());
}
req.Disconnect(_requestConnectionString);
subscriber.Disconnect(_subscribeConnectionString);
req.Close();
subscriber.Close();
}
context.Terminate();
context.Dispose();
}
}
public SendStatus SendMessage(string exchangeName, ZmqMessage message)
{
return this[exchangeName].SendMessage(message);
}
private static ZmqMessage GetUpdateMessage(ISolutionStrategy strategy, ProblemUpdateType updateType, IFrameable data)
{
var dataFrames = data.GetFrames(Encoding.UTF8).ToList();
List<Frame> msgFrames = new List<Frame>(dataFrames.Count + 5);
msgFrames.Add(new Frame(Encoding.UTF8.GetBytes(strategy.Signature)));
msgFrames.Add(Frame.Empty);
msgFrames.Add(new Frame(new byte[1] { (byte)updateType }));
msgFrames.Add(Frame.Empty);
msgFrames.Add(new Frame(new byte[1] { 0x7f }));
msgFrames.AddRange(dataFrames);
ZmqMessage message = new ZmqMessage(msgFrames);
return message;
}
private static void SendUpdateMessage(ISolutionStrategy strategy, ProblemUpdateType updateType, ZmqSocket socket, object data, IFormatter formatter = null)
{
formatter = formatter ?? new BinaryFormatter();
ZmqMessage message = new ZmqMessage();
message.Append(Encoding.UTF8.GetBytes(strategy.Signature));
message.AppendEmptyFrame();
message.Append(new byte[1] { (byte)updateType });
message.AppendEmptyFrame();
message.Append(new byte[1] { 0x7f });
using (MemoryStream ms = new MemoryStream())
{
formatter.Serialize(ms, data);
// TODO: Find more efficient way to write byte[] since MemoryStream.ToArray performs a copy
// whereas MemoryStream.GetBuffer() returns all allocated bytes whether they are empty or not
message.Append(ms.ToArray());
}
socket.SendMessage(message);
}
private static void VerifyMessage(ZmqMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
}
static void pubSocket_SendReady(object sender, SocketEventArgs e)
{
var zmqMessage = new ZmqMessage();
if (nbSubscribersConnected < 2)
{
zmqMessage.Append(Encoding.UTF8.GetBytes("Sync"));
zmqMessage.Append(Encoding.UTF8.GetBytes(Pipe.PubSubControlFrontAddressClient));
Thread.Sleep(200);
Console.WriteLine("Publishing: Sync");
}
else
{
zmqMessage.Append(Encoding.UTF8.GetBytes("Data"));
var data = "MYDATA"; //BuildDataToPublish();
if (!string.IsNullOrEmpty(data))
{
zmqMessage.Append(Encoding.UTF8.GetBytes(data));
Thread.Sleep(200);
Console.WriteLine("Publishing (Data): " + data);
}
}
e.Socket.SendMessage(zmqMessage);
}
/// <summary>
/// Receive all parts of a multi-part message from a remote socket in blocking mode
/// and append them to a given message.
/// </summary>
/// <param name="socket">A <see cref="ZmqSocket"/> object.</param>
/// <param name="message">The <see cref="ZmqMessage"/> to which message-parts will be appended.</param>
/// <returns>The supplied <see cref="ZmqMessage"/> with newly received <see cref="Frame"/> objects appended.</returns>
/// <exception cref="ArgumentNullException"><paramref name="message"/> is null.</exception>
/// <exception cref="ZmqSocketException">An error occurred receiving data from a remote endpoint.</exception>
/// <exception cref="ObjectDisposedException">The <see cref="ZmqSocket"/> has been closed.</exception>
/// <exception cref="NotSupportedException">The current socket type does not support Receive operations.</exception>
public static ZmqMessage ReceiveMessage(this ZmqSocket socket, ZmqMessage message)
{
return ReceiveMessage(socket, message, TimeSpan.MaxValue);
}
public void RouterTest()
{
Task server = Task.Factory.StartNew(() =>
{
Console.WriteLine("Router starting");
using (var context = ZmqContext.Create())
using (var socket = context.CreateSocket(SocketType.ROUTER))
{
socket.Linger = new TimeSpan(250 * TimeSpan.TicksPerMillisecond);
socket.Bind("tcp://127.0.0.1:5555");
socket.ReceiveReady += (sender, args) =>
{
var message =
args.Socket.ReceiveMessage();
byte[] address = message[0];
var response = new List<byte[]>()
{
address,
"".ToBytes(),
"Hello world".ToBytes()
};
args.Socket.SendAll(response);
};
var poller = new Poller(new[] { socket });
poller.Poll();
}
}, Canceller.Token, TaskCreationOptions.LongRunning,
TaskScheduler.Default);
server.Wait(500);
using (var context = ZmqContext.Create())
using (var socket = context.CreateSocket(SocketType.REQ))
{
socket.Linger = new TimeSpan(250 * TimeSpan.TicksPerMillisecond);
socket.Connect("tcp://127.0.0.1:5555");
var msg = new ZmqMessage();
socket.ReceiveReady += (sender, args) =>
{
msg = args.Socket.ReceiveMessage();
};
socket.Send(" ", Encoding.UTF8);
var poller = new Poller(new[] { socket });
poller.Poll(new TimeSpan(500 * TimeSpan.TicksPerMillisecond));
string response = "";
byte[] tmp = new byte[0];
if (msg.FrameCount > 0)
tmp = (byte[])msg.Unwrap();
response = tmp.ToUnicodeString();
Assert.AreEqual("Hello world", response);
}
}
private static void worker_ReceiveReady(Object sender, SocketEventArgs e)
{
var responseMsg = new ZmqMessage();
ZmqMessage message = e.Socket.ReceiveMessage(responseMsg);
Console.WriteLine("[worker] Received {0} bytes {1} frames", message.TotalSize, message.FrameCount);
responseMsg.Append(Encoding.UTF8.GetBytes(". Received!"));
//Thread.Sleep(300);
Console.WriteLine("[worker-responce] Sent {0} bytes {1} frames", responseMsg.TotalSize, responseMsg.FrameCount);
e.Socket.SendMessage(responseMsg);
}
/// <summary>
/// Receive all parts of a multi-part message from a remote socket in non-blocking mode.
/// </summary>
/// <remarks>
/// The <paramref name="frameTimeout"/> will be used for each underlying Receive operation. If the timeout
/// elapses before the last message is received, an incomplete message will be returned.
/// </remarks>
/// <param name="socket">A <see cref="ZmqSocket"/> object.</param>
/// <param name="message">The <see cref="ZmqMessage"/> to which message-parts will be appended.</param>
/// <param name="frameTimeout">A <see cref="TimeSpan"/> specifying the receive timeout for each frame.</param>
/// <returns>A <see cref="ZmqMessage"/> containing newly received <see cref="Frame"/> objects.</returns>
/// <exception cref="ZmqSocketException">An error occurred receiving data from a remote endpoint.</exception>
/// <exception cref="ObjectDisposedException">The <see cref="ZmqSocket"/> has been closed.</exception>
/// <exception cref="NotSupportedException">The current socket type does not support Receive operations.</exception>
public static ZmqMessage ReceiveMessage(this ZmqSocket socket, ZmqMessage message, TimeSpan frameTimeout)
{
VerifySocket(socket);
VerifyMessage(message);
Frame frame;
do
{
frame = socket.ReceiveFrame(frameTimeout);
if (frame.ReceiveStatus == ReceiveStatus.Received)
{
message.AppendShallowCopy(frame);
}
}
while (frame.ReceiveStatus == ReceiveStatus.Received && frame.HasMore);
return message;
}
/// <summary>
/// Queue a multi-part message to be sent by the socket in blocking mode.
/// </summary>
/// <param name="socket">A <see cref="ZmqSocket"/> object.</param>
/// <param name="message">A <see cref="ZmqMessage"/> that contains the message parts to be sent.</param>
/// <returns>A <see cref="SendStatus"/> describing the outcome of the send operation.</returns>
/// <exception cref="ArgumentNullException"><paramref name="message"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="message"/> is incomplete.</exception>
/// <exception cref="ZmqSocketException">An error occurred sending data to a remote endpoint.</exception>
/// <exception cref="ObjectDisposedException">The <see cref="ZmqSocket"/> has been closed.</exception>
/// <exception cref="NotSupportedException">The current socket type does not support Send operations.</exception>
public static SendStatus SendMessage(this ZmqSocket socket, ZmqMessage message)
{
VerifySocket(socket);
VerifyMessage(message);
if (message.IsEmpty)
{
return SendStatus.Sent;
}
if (!message.IsComplete)
{
throw new ArgumentException("Unable to send an incomplete message. Ensure HasMore on the last Frame is set to 'false'.", "message");
}
foreach (Frame frame in message)
{
socket.SendFrame(frame);
}
return socket.SendStatus;
}
private static void router_SendReady(Object sender, SocketEventArgs e)
{
var Msg = new ZmqMessage();
Msg.Append(Encoding.UTF8.GetBytes(String.Format(" Hi {0}.", mesageNum)));
mesageNum++;
e.Socket.SendMessage(Msg);
}
public ZmqMessage ReceiveMessage(string exchangeName, ZmqMessage message, TimeSpan frameTimeout)
{
return this[exchangeName].ReceiveMessage(message, frameTimeout);
}
static void pubSocket_SendReady(object sender, SocketEventArgs e)
{
var zmqMessage = new ZmqMessage();
if (nbSubscribersConnected < options.nbExpectedSubscribers)
{
zmqMessage.Append(Encoding.UTF8.GetBytes("Sync"));
zmqMessage.Append(Encoding.UTF8.GetBytes(options.repEndpoint));
Thread.Sleep(options.delay);
Console.WriteLine("Publishing: Sync");
}
else
{
zmqMessage.Append(Encoding.UTF8.GetBytes("Data"));
var data = BuildDataToPublish();
if (!string.IsNullOrEmpty(data))
{
zmqMessage.Append(Encoding.UTF8.GetBytes(data));
Thread.Sleep(options.delay);
Console.WriteLine("Publishing (Data): " + data);
}
}
e.Socket.SendMessage(zmqMessage);
}
public ZmqMessage ReceiveMessage(string exchangeName, ZmqMessage message)
{
return this[exchangeName].ReceiveMessage(message);
}
private static void SendUpdateMessage(ISolutionStrategy strategy, ProblemUpdateType updateType, ZmqSocket socket, IBinaryConvertible data)
{
ZmqMessage message = new ZmqMessage();
message.Append(Encoding.UTF8.GetBytes(strategy.Signature));
message.AppendEmptyFrame();
message.Append(new byte[1] { (byte)updateType });
message.AppendEmptyFrame();
message.Append(new byte[1] { 0x7f });
message.Append(data.GetBytes());
socket.SendMessage(message);
}
protected abstract OpStatus SendCore(ZmqMessage Message);
private static void RunWeatherWithFrames(ZmqContext context, string Address, string message)
{
string input = string.Empty;
using (ZmqSocket publisher = context.CreateSocket(SocketType.PUB))
{
publisher.Connect("tcp://localhost:5556");
while (input != "exit")
{
interrupted = false;
Address = "11111 ";
message = "Hi johnny was here";
var randomizer = new Random(DateTime.Now.Millisecond);
Console.Write("sending");
int i = 0;
while (!interrupted)
{
++i;
// Get values that will fool the boss
int zipcode = randomizer.Next(0, 100000);
int temperature = randomizer.Next(-80, 135);
int relativeHumidity = randomizer.Next(10, 60);
string update = "xx " + temperature.ToString() + " " + relativeHumidity.ToString();
if (i > 1000000)
{
Console.Write(".");
i = 0;
}
ZmqMessage zmqMessage = new ZmqMessage();
zmqMessage.Append(new Frame(Encoding.Unicode.GetBytes(zipcode.ToString())));
zmqMessage.Append(new Frame(Encoding.Unicode.GetBytes(update)));
publisher.SendMessage(zmqMessage);
}
Console.WriteLine("=>");
input = Console.ReadLine();
}
}
}
