protected void CreateServer()
{
switch (_type)
{
case MQServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case MQServerType.Publisher:
_serverSocket = _context.CreatePublisherSocket(); break;
case MQServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case MQServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case MQServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case MQServerType.XPublisher:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
}
void CreateServer()
{
switch (_type)
{
case ServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case ServerType.Pub:
_serverSocket = _context.CreatePushSocket(); break;
case ServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case ServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case ServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case ServerType.XPub:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
Task.Factory.StartNew(() =>
AsyncRead(_serverSocket), TaskCreationOptions.LongRunning);
}
private void ListenForSnapshotRequest()
{
Task.Factory.StartNew((() =>
{
using (var server = socketFactory.CreateResponseSocket())
{
server.Bind(MarketDataSettings.SnapshotDataServerAddress);
while (true)
{
var message = server.ReceiveFrameString();
if (string.IsNullOrEmpty(message))
{
Thread.Sleep(100);
continue;
}
if (message.ToLower() == "quit")
{
break;
}
Console.WriteLine($"Snapshot requested for ticker(s) {message}");
var securityIds = message.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var response = primitiveQuoteService.GetQuotes(securityIds);
var responseString = JsonConvert.SerializeObject(response);
server.SendFrame(responseString);
Thread.Sleep(100);
}
}
}));
}
public void Run()
{
using (var socket = context.CreateResponseSocket())
{
socket.Options.Linger = TimeSpan.Zero;
socket.Bind(clientAddress.ZmqAddress + ":" + GlobalConstants.TcpIpPort.Heartbeat);
var timoutCounter = 0;
while (!stopRunning)
{
var request = socket.ReceiveNetworkMsg(TimeSpan.FromSeconds(1));
if (request == null)
{
timoutCounter++;
if (timoutCounter == 10)
{
Application.Current?.Dispatcher.Invoke(() => ServerVanished?.Invoke());
break;
}
}
else if (request.Type == NetworkMessageType.HeartbeatRequest)
{
timoutCounter = 0;
var heartbeatRequest = (HeartbeatRequest)request;
socket.SendNetworkMsg(new HeartbeatResponse(heartbeatRequest.SessionId));
}
}
}
}
private NetMQSocket GetInboundSocket(NetMQContext context)
{
NetMQSocket socket;
switch (Connection.Pattern)
{
case MessagePattern.FireAndForget:
socket = context.CreatePullSocket();
socket.Bind(Connection.Address);
break;
case MessagePattern.RequestResponse:
socket = context.CreateResponseSocket();
socket.Bind(Connection.Address);
break;
case MessagePattern.PublishSubscribe:
var subSocket = context.CreateSubscriberSocket();
subSocket.SubscribeToAnyTopic();
subSocket.Connect(Connection.Address);
socket = subSocket;
break;
default:
throw new Exception($"Cannot create an inbound socket for pattern {Connection.Pattern}");
}
return(socket);
}
public void SimpleReqRep(string address)
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var rep = ctx.CreateResponseSocket())
{
rep.Bind(address);
using (var req = ctx.CreateRequestSocket())
{
req.Connect(address);
req.Send("Hi");
bool more;
string requestString = rep.ReceiveString(out more);
Assert.AreEqual("Hi", requestString);
Assert.IsFalse(more);
rep.Send("Hi2");
string responseString = req.ReceiveString(out more);
Assert.AreEqual("Hi2", responseString);
Assert.IsFalse(more);
}
}
}
}
public void RunPipeline(PairSocket shim)
{
publisherSocket = context.CreatePublisherSocket();
publisherSocket.Bind("tcp://*:" + StreamingProtocol.Port);
snapshotSocket = context.CreateResponseSocket();
snapshotSocket.Bind("tcp://*:" + SnapshotProtocol.Port);
snapshotSocket.ReceiveReady += OnSnapshotReady;
shim.ReceiveReady += OnShimReady;
heartbeatTimer = new NetMQTimer(StreamingProtocol.HeartbeatInterval);
heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.SignalOK();
poller = new Poller();
poller.AddSocket(shim);
poller.AddSocket(snapshotSocket);
poller.AddTimer(heartbeatTimer);
poller.Start();
publisherSocket.Dispose();
snapshotSocket.Dispose();
}
static void Main(string[] args)
{
string connection = "inproc://HelloWorld";
using (NetMQContext ctx = NetMQContext.Create())
{
using (var server = ctx.CreateResponseSocket())
{
server.Bind(connection);
using (var client = ctx.CreateRequestSocket())
{
client.Connect(connection);
client.Send("Hello");
string fromClientMessage = server.ReceiveString();
Console.WriteLine("From Client: {0}", fromClientMessage);
server.Send("Hi Back");
string fromServerMessage = client.ReceiveString();
Console.WriteLine("From Server: {0}", fromServerMessage);
Console.ReadLine();
}
}
}
}
public void Run()
{
IsRunning = true;
using (var socket = context.CreateResponseSocket())
{
socket.Options.Linger = TimeSpan.Zero;
socket.Bind(serverAddress.ZmqAddress + ":" + GlobalConstants.TcpIpPort.Request);
while (!stopRunning)
{
var request = socket.ReceiveNetworkMsg(TimeSpan.FromSeconds(1));
if (request == null)
{
continue;
}
var typedRequest = Converter.ChangeTo(request, request.GetType()); // TODO: ist noch unschön
var responseHandler = responseHandlerFactory.GetHandler(typedRequest, socket);
responseHandler.Handle(typedRequest);
}
}
IsRunning = false;
}
private static void Main(string[] args)
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var server = ctx.CreateResponseSocket())
{
server.Bind("tcp://127.0.0.1:5556");
using (var client = ctx.CreateRequestSocket())
{
client.Connect("tcp://127.0.0.1:5556");
client.Send("Hello");
string m1 = server.ReceiveString();
Console.WriteLine("From Client: {0}", m1);
server.Send("Hi Back");
string m2 = client.ReceiveString();
Console.WriteLine("From Server: {0}", m2);
Console.ReadLine();
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NmqResponseQueue"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="port">The port.</param>
internal NmqResponseQueue(NetMQContext context, int port)
{
socket = context.CreateResponseSocket();
var address = string.Format("tcp://127.0.0.1:{0}", port);
socket.Bind(address);
}
public void Monitoring()
{
ManualResetEvent listeningEvent = new ManualResetEvent(false);
ManualResetEvent acceptedEvent = new ManualResetEvent(false);
ManualResetEvent connectedEvent = new ManualResetEvent(false);
using (NetMQContext contex = NetMQContext.Create())
{
Poller poller = new Poller();
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) => acceptedEvent.Set();
monitor.Listening += (s, a) => listeningEvent.Set();
monitor.AttachToPoller(poller);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
using (NetMQMonitor reqMonitor = new NetMQMonitor(contex, req, "inproc://req.inproc", SocketEvent.Connected))
{
reqMonitor.Connected += (s, a) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
try
{
var pollerTask = Task.Factory.StartNew(poller.Start);
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
}
finally
{
poller.Stop();
}
}
}
}
}
}
}
public Heartbeat(ILog logger, string address, NetMQContext context)
{
this.logger = logger;
this.address = address;
this.context = context;
this.server = context.CreateResponseSocket();
this.stopEvent = new ManualResetEventSlim();
}
public void Monitoring()
{
bool listening = false;
bool accepted = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) =>
{
accepted = true;
//Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Listening += (s, a) =>
{
listening = true;
Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
private void dataServer()
{
NetMQContext ctx = NetMQContext.Create();
NetMQ.Sockets.ResponseSocket dataSender = ctx.CreateResponseSocket();
dataSender.Bind("tcp://*:5565");
Debug.Log("Enter while.. ");
while (isRunning)
{
string message = dataSender.ReceiveString();
print("Got request message: " + message);
// re-run scene iteration if true
if (doGatherOnRequest)
{
gatherSceneData();
}
switch (message)
{
case "header":
print("Send Header.. ");
dataSender.Send(headerByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", headerByteData.Length));
break;
case "nodes":
print("Send Nodes.. ");
dataSender.Send(nodesByteData);
print(string.Format(".. Nodes ({0} bytes) sent ", nodesByteData.Length));
break;
case "objects":
print("Send Objects.. ");
dataSender.Send(objectsByteData);
print(string.Format(".. Objects ({0} bytes) sent ", objectsByteData.Length));
break;
case "textures":
print("Send Textures.. ");
dataSender.Send(texturesByteData);
print(string.Format(".. Textures ({0} bytes) sent ", texturesByteData.Length));
break;
default:
break;
}
}
dataSender.Unbind("tcp://127.0.0.1:5565");
dataSender.Close();
}
public void ErrorCodeTest()
{
bool eventArrived = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var req = contex.CreateRequestSocket())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor =
new NetMQMonitor(contex, req, "inproc://rep.inproc", SocketEvent.ConnectDelayed))
{
monitor.ConnectDelayed += (s, a) =>
{
eventArrived = true;
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(eventArrived);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
static void Main(string[] args)
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket response = context.CreateResponseSocket())
{
string address = GetComputerLanIP();
if (PORT_NUMBER > 0)
{
if (!string.IsNullOrEmpty(address))
{
Console.WriteLine("Binding tcp://{0}:{1}", address, PORT_NUMBER);
response.Bind(string.Format("tcp://{0}:{1}", address, PORT_NUMBER));
while (true)
{
bool hasMore = true;
string msg = response.ReceiveString(out hasMore);
if (string.IsNullOrEmpty(msg))
{
Console.WriteLine("No msg received.");
break;
}
Console.WriteLine("Msg received! {0}", msg);
response.Send(msg, false, hasMore);
Thread.Sleep(1000);
}
response.Options.Linger = TimeSpan.Zero;
}
else
{
Console.WriteLine("Wrong IP address");
}
}
else
{
Console.WriteLine("The port number should be greater than 0");
}
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
}
}
}
public void Start(string configFile)
{
config = ServiceConfig.FromXml(configFile);
log.DebugFormat("Start from {0}", configFile);
if (config.PushPull != null)
{
log.InfoFormat("Starting listening for Pull: {0}", config.PushPull.ListenAddress);
NetMQContext ctx1 = NetMQContext.Create();
InitLinks(ctx1, _push_links, config.PushPull, ZmqSocketType.Push);
puller = ctx1.CreatePullSocket();
puller.ReceiveReady += this.PullerReceiveReady;
puller.Bind(config.PushPull.ListenAddress);
this.source_pp = new CancellationTokenSource();
this.token_pp = this.source_pp.Token;
Task newTask = Task.Factory.StartNew(this.OnPull, this.token_pp);
this.tasks.Add(newTask);
}
if (config.PubSub != null)
{
log.InfoFormat("Starting listening for subscriber: {0}", config.PubSub.ListenAddress);
NetMQContext ctx2 = NetMQContext.Create();
InitLinks(ctx2, _sub_links, config.PubSub, ZmqSocketType.Sub);
foreach (var link in _sub_links)
{
link.Value.socket.ReceiveReady += SubOnReceiveReady;
}
publisher = ctx2.CreatePublisherSocket();
publisher.Bind(config.PubSub.ListenAddress);
this.source_ps = new CancellationTokenSource();
this.token_ps = this.source_ps.Token;
Task newTask = Task.Factory.StartNew(this.OnSubscribe, this.token_ps);
this.tasks.Add(newTask);
}
if (config.ReqRep != null)
{
log.InfoFormat("Starting listening for Request: {0}", config.ReqRep.ListenAddress);
NetMQContext ctx3 = NetMQContext.Create();
//InitLinks(ctx3, _req_links, config.ReqRep, ZmqSocketType.Req); delete by xsw 2014-09-17
responser = ctx3.CreateResponseSocket();
responser.ReceiveReady += this.RepReceiveReady;
responser.Bind(config.ReqRep.ListenAddress);
this.source_rr = new CancellationTokenSource();
this.token_rr = this.source_rr.Token;
Task newTask = Task.Factory.StartNew(this.OnResponse, this.token_rr);
this.tasks.Add(newTask);
}
}
public void TestKeepAlive()
{
// there is no way to test tcp keep alive without disconnect the cable, we just testing that is not crashing the system
using (NetMQContext context = NetMQContext.Create())
{
using (var responseSocket = context.CreateResponseSocket())
{
responseSocket.Options.TcpKeepalive = true;
responseSocket.Options.TcpKeepaliveIdle = TimeSpan.FromSeconds(5);
responseSocket.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(1);
responseSocket.Bind("tcp://127.0.0.1:5555");
using (var requestSocket = context.CreateRequestSocket())
{
requestSocket.Options.TcpKeepalive = true;
requestSocket.Options.TcpKeepaliveIdle = TimeSpan.FromSeconds(5);
requestSocket.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(1);
requestSocket.Connect("tcp://127.0.0.1:5555");
requestSocket.Send("1");
bool more;
string m = responseSocket.ReceiveString(out more);
Assert.IsFalse(more);
Assert.AreEqual("1", m);
responseSocket.Send("2");
string m2 = requestSocket.ReceiveString(out more);
Assert.IsFalse(more);
Assert.AreEqual("2", m2);
Assert.IsTrue(requestSocket.Options.TcpKeepalive);
Assert.AreEqual(TimeSpan.FromSeconds(5), requestSocket.Options.TcpKeepaliveIdle);
Assert.AreEqual(TimeSpan.FromSeconds(1), requestSocket.Options.TcpKeepaliveInterval);
Assert.IsTrue(responseSocket.Options.TcpKeepalive);
Assert.AreEqual(TimeSpan.FromSeconds(5), responseSocket.Options.TcpKeepaliveIdle);
Assert.AreEqual(TimeSpan.FromSeconds(1), responseSocket.Options.TcpKeepaliveInterval);
}
}
}
}
public void Start()
{
using (m_serverSocket = m_context.CreateResponseSocket())
{
foreach (var address in m_addresses)
{
m_log.InfoFormat("Listening on {0}", address);
m_serverSocket.Bind(address);
}
m_serverSocket.ReceiveReady += OnMessage;
m_poller = new Poller();
m_poller.AddSocket(m_serverSocket);
m_poller.Start();
}
}
/// <summary>
/// SimpleHelloWorldServer does the following:
/// * Creates a Response socket
/// * Waits for a "Hello" request
/// * Sends a "World" reply
/// </summary>
/// <param name="context"></param>
private void Server(NetMQContext context)
{
// create the response socket
using (var response = context.CreateResponseSocket())
{
// bind the response socket, binds make the socket the "server"
// * can be used to bind to all IP addresses
response.Bind("tcp://*:5555");
// response socket must first receive a message and only then reply
string request = response.ReceiveFrameString();
Assert.That(request == "Hello");
response.SendFrame("World");
}
}
public void SendMessageInResponeBeforeReceiving()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var rep = ctx.CreateResponseSocket())
{
rep.Bind("tcp://localhost:5001");
using (var req = ctx.CreateRequestSocket())
{
req.Connect("tcp://localhost:5001");
var ex = Assert.Throws <FiniteStateMachineException>(() => rep.Send("1"));
}
}
}
}
private void start(CancellationToken token, string address, TaskCompletionSource <bool> ready)
{
using (var socket = _context.CreateResponseSocket())
{
socket.Bind(address);
ready.SetResult(true);
while (token.IsCancellationRequested == false)
{
var bytes = socket.Receive();
var sender = Encoding.ASCII.GetString(bytes);
Console.WriteLine("[{0}] Received request from {1}", _id, sender);
Task.Delay(TimeSpan.FromSeconds(3), token).Wait(token);
var message = string.Format("{0} says {1}.", _id, DateTime.Now);
socket.Send(Encoding.ASCII.GetBytes(message));
}
}
}
public void ResponsePoll()
{
using (NetMQContext contex = NetMQContext.Create())
{
using (var rep = contex.CreateResponseSocket())
{
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
using (Poller poller = new Poller())
{
req.Connect("tcp://127.0.0.1:5002");
rep.ReceiveReady += (s, a) =>
{
bool more;
string m = a.Socket.ReceiveString(out more);
Assert.False(more);
Assert.AreEqual("Hello", m);
a.Socket.Send("World");
};
poller.AddSocket(rep);
Task pollerTask = Task.Factory.StartNew(poller.Start);
req.Send("Hello");
bool more2;
string m1 = req.ReceiveString(out more2);
Assert.IsFalse(more2);
Assert.AreEqual("World", m1);
poller.Stop();
Thread.Sleep(100);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
public void SendMoreTest()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var server = ctx.CreateResponseSocket())
{
server.Bind("tcp://127.0.0.1:5556");
using (var client = ctx.CreateRequestSocket())
{
client.Connect("tcp://127.0.0.1:5556");
//client send message
client.SendMore("A");
client.Send("Hello");
//server receive 1st part
bool more;
string m = server.ReceiveString(out more);
Assert.AreEqual("A", m);
Assert.IsTrue(more);
//server receive 2nd part
string m2 = server.ReceiveString(out more);
Assert.AreEqual("Hello", m2);
Assert.False(more);
//server send message, this time use NetMqMessage
//which will be sent as frames if the client calls
//ReceieveMessage()
var m3 = new NetMQMessage();
m3.Append("From");
m3.Append("Server");
server.SendMessage(m3);
//client receive
var m4 = client.ReceiveMessage();
Assert.AreEqual(2, m4.FrameCount);
Assert.AreEqual("From", m4[0].ConvertToString());
Assert.AreEqual("Server", m4[1].ConvertToString());
}
}
}
}
public void runClient()
{
NetMQContext context = NetMQContext.Create();
NetMQSocket client = context.CreateResponseSocket();
client.Connect("tcp://localhost:5555");
NetMQMessage message = new NetMQMessage();
NetMQMessage message2 = new NetMQMessage();
while (true)
{
message = client.ReceiveMessage(false);
message2.Append(message.Pop().ConvertToString() + "Tobi");
message2.Append(message.Pop().ConvertToInt32() + 12);
client.SendMessage(message2, false);
System.Threading.Thread.Sleep(100);
}
}
public void SendMessageInResponeBeforeReceiving()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var rep = ctx.CreateResponseSocket())
{
rep.Bind("tcp://localhost:5001");
using (var req = ctx.CreateRequestSocket())
{
req.Connect("tcp://localhost:5001");
var ex = Assert.Throws <NetMQException>(() => rep.Send("1"));
Assert.AreEqual(ErrorCode.EFSM, ex.ErrorCode);
}
}
}
}
public void Run()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var server = ctx.CreateResponseSocket())
{
server.Bind("tcp://127.0.0.1:5556");
while (true)
{
string fromClientMessage = server.ReceiveString();
Console.WriteLine("From Client: {0} running on ThreadId : {1}",
fromClientMessage, Thread.CurrentThread.ManagedThreadId);
server.Send("Hi Back");
}
}
}
}
private static void Server(NetMQContext context)
{
using (NetMQSocket serverSocket = context.CreateResponseSocket())
{
serverSocket.Bind("tcp://127.0.0.1:5555");
while (true)
{
string message1 = serverSocket.ReceiveFrameString();
Console.WriteLine("Receive message :\r\n{0}\r\n", message1);
string[] msg = message1.Split(':');
string message = msg[1];
#region 根据接收到的消息，返回不同的信息
if (message == "Hello")
{
serverSocket.SendFrame("World");
}
else if (message == "ni hao ")
{
serverSocket.SendFrame("你好！");
}
else if (message == "hi")
{
serverSocket.SendFrame("HI");
}
else
{
serverSocket.SendFrame(message);
}
#endregion
if (message == "exit")
{
break;
}
}
}
}
public void ReceiveBeforeSending()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var rep = ctx.CreateResponseSocket())
{
rep.Bind("tcp://localhost:5001");
using (var req = ctx.CreateRequestSocket())
{
req.Connect("tcp://localhost:5001");
bool more;
var ex = Assert.Throws <FiniteStateMachineException>(() => req.ReceiveString(out more));
}
}
}
}
protected override NetMQSocket CreateServerSocket(NetMQContext context)
{
return context.CreateResponseSocket();
}
