private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_thr <connect-to> <message-size> <message-count>");
return 1;
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
using (var push = new PushSocket())
{
push.Connect(connectTo);
for (int i = 0; i != messageCount; i++)
{
var msg = new Msg();
msg.InitPool(messageSize);
push.Send(ref msg, more: false);
msg.Close();
}
}
return 0;
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_thr <connect-to> <message-size> <message-count>");
return(1);
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
using (var push = new PushSocket())
{
push.Connect(connectTo);
for (int i = 0; i != messageCount; i++)
{
var msg = new Msg();
msg.InitPool(messageSize);
push.Send(ref msg, more: false);
msg.Close();
}
}
return(0);
}
public override void Publisher()
{
AsyncIO.ForceDotNet.Force();
sender = new PushSocket();
sender.Connect("tcp://" + IP + ":" + Port);
Debug.Log("Connect ObjectSender to: " + "tcp://" + IP + ":" + Port);
while (IsRunning)
{
Thread.Sleep(50);
if (sendMessageQueue.Count > 3)
{
sendMessageQueue.RemoveRange(0, sendMessageQueue.Count - 3);
}
if (sendMessageQueue.Count > 0)
{
// Debug.Log("Send: " + sendMessageQueue[0]);
try
{
sender.SendFrame(sendMessageQueue[0], false); // true not wait
sendMessageQueue.RemoveAt(0);
}
catch { }
}
}
// disconnectClose();
}
static void Main(string[] args)
{
bool started = false;
while (true)
{
if (started)
{
Console.WriteLine("Please Press Enter to Stop...");
Console.ReadLine();
using (var server = new PushSocket())
{
server.Connect("tcp://127.0.0.1:5489");
server.SendFrame("false");
started = false;
}
}
else
{
Console.WriteLine("Please Press Enter to Start...");
Console.ReadLine();
using (var send = new PushSocket())
{
send.Connect("tcp://127.0.0.1:5488");
send.SendFrame("true");
started = true;
}
}
}
}
public void Start(string serverIpAddress, int serverPort)
{
string serverAddress = string.Format("tcp://{0}:{1}", serverIpAddress, serverPort);
pushSocket = new PushSocket();
pushSocket.Connect(serverAddress);
}
public void Start()
{
if (!ServerSpecified)
{
return;
}
if (context == null)
{
context = NetMQContext.Create();
subscriber = context.CreateSubscriberSocket();
subscriber.Connect("tcp://127.0.0.1:5252");
subscriber.Subscribe(String.Empty);
sender = context.CreatePushSocket();
sender.Connect("tcp://127.0.0.1:5253");
// Start listening..
Task.Run(() =>
{
while (!tokenSource.IsCancellationRequested)
{
var message = subscriber.ReceiveString();
var eventObject = Serialization.DeserializeEnvelope <ContractMarker>(message);
eventReceivedSubject.OnNext(eventObject);
}
});
}
}
public NetMQWorker(int id, string pushAddress, string pullAddress, NetMQContext context) : base(id)
{
_pullSocket = context.CreatePullSocket();
_pushSocket = context.CreatePushSocket();
_pushSocket.Connect(pushAddress);
_pullSocket.Bind(pullAddress+id);
}
public ZeroNotificationEnqueue(ZeroConfiguration configuration)
{
_poller = new NetMQPoller();
_client = new PushSocket();
_client.Connect(configuration.ZeroMqAddress);
_poller.RunAsync();
}
private void CreateRemoteNode()
{
if (NodeAddressNumber >= RemoteAddressesList.Count)
{
throw new Exception("Node number is not correct, ");
}
NodeAddress = RemoteAddressesList[this.NodeAddressNumber];
if (NodeAddressNumber == 0)
{
MainNode = true;
}
WorkingRemoteServersCount = RemoteAddressesList.Count;
RemoteAddressesList.RemoveAt(NodeAddressNumber);
NodePort = NodeAddress.Split(new[] { ":" }, StringSplitOptions.None)[1];
foreach (var remoteServer in RemoteAddressesList)
{
var remotePushSocket = new PushSocket();
RemoteServerSockets[remoteServer] = remotePushSocket;
remotePushSocket.Connect("tcp://" + remoteServer);
}
}
public void Start(string serverIpAddress, int serverPort)
{
ctx = NetMQContext.Create();
pushSocket = ctx.CreatePushSocket();
string serverAddress = string.Format("tcp://{0}:{1}", serverIpAddress, serverPort);
pushSocket.Connect(serverAddress);
}
public ZeroNotificationEnqueue()
{
_context = NetMQContext.Create();
_poller = new Poller();
_client = _context.CreatePushSocket();
_client.Connect(QueueAddress);
_scheduler = new NetMQScheduler(_context, _poller);
Task.Factory.StartNew(_poller.PollTillCancelled, TaskCreationOptions.LongRunning);
}
private void createSSocket()
{
clientS = context.CreatePushSocket();
string[] srAddrs = cfg.ServerR.Split(',');
foreach (string addr in srAddrs)
{
clientS.Connect(addr);
}
}
public void Start(string serverIpAddress, int serverPort)
{
ctx = NetMQContext.Create();
pushSocket = ctx.CreatePushSocket();
string serverAddress = string.Format("tcp://{0}:{1}", serverIpAddress, serverPort);
pushSocket.Connect(serverAddress);
}
public Sender(string addr)
{
StringNullOrEmptyException.Assert(addr, nameof(addr));
_socket = new PushSocket();
_socket.Options.SendTimeout = TimeSpan.FromMilliseconds(100);
_socket.Options.ReconnectInterval = TimeSpan.FromMilliseconds(150);
_socket.Connect(addr.ToLower());
}
public override bool Start()
{
_pullSocket.Bind(GameServerAddress + "out");
_pushSocket.Connect(GameServerAddress + "in");
_receThread2GameServer = new Thread(ReceiveGameServer);
_cancelToken = new CancellationTokenSource();
_receThread2GameServer.Start();
return(base.Start());
}
public void EmptyMessage()
{
using (var pullSocket = new PullSocket())
using (var pushSocket = new PushSocket())
{
var port = pullSocket.BindRandomPort("tcp://127.0.0.1");
pushSocket.Connect("tcp://127.0.0.1:" + port);
pushSocket.SendFrame(new byte[300]);
Assert.AreEqual(300, pullSocket.ReceiveFrameString().Length);
}
}
protected override void Run()
{
ForceDotNet.Force();
using var socket = new PushSocket();
socket.Connect("tcp://localhost:5556");
while (Running)
{
if (fromEventLoop.TryDequeue(out byte[] img))
{
socket.TrySendFrame(img);
}
}
}
public void SimplePushPull()
{
using (var pullSocket = new PullSocket())
using (var pushSocket = new PushSocket())
{
var port = pullSocket.BindRandomPort("tcp://127.0.0.1");
pushSocket.Connect("tcp://127.0.0.1:" + port);
pushSocket.SendFrame("hello");
Assert.AreEqual("hello", pullSocket.ReceiveFrameString());
}
}
/// <summary>
/// 三经典模式：推拉模式(管道模式)
/// 一个消息只能被消费一次
/// </summary>
static void PushPull()
{
using (var pullSocket = new PullSocket())
using (var pushSocket = new PushSocket())
{
var port = pullSocket.BindRandomPort($"{address}");
pushSocket.Connect($"{address}:" + port);
pushSocket.SendMoreFrame("hello").SendFrame("hello world");
var s = pullSocket.ReceiveFrameString();
s += pullSocket.ReceiveFrameString();
Console.WriteLine(s);//hellohello world
}
}
private void ExecuteComThreadTransmitControlMessages()
{
PushSocket pushSocket = null;
try
{
pushSocket = new PushSocket();
pushSocket.Options.SendHighWatermark = 10;
pushSocket.Connect(this.Config.GetConnectionStringCore4Transmit());
var watch = Stopwatch.StartNew();
while (!IsDisposed)
{
NetMq.Messages.BaseMessage baseMessage = null;
if (Queue.TryDequeue(out baseMessage))
{
var buffer = baseMessage.Buffer;
if (pushSocket.TrySendFrame(TimeSpan.FromMilliseconds(100), buffer, false))
{
this.Log($"{baseMessage.MessageType} was transfered to {pushSocket.Options.LastEndpoint}", 0);
}
else
{
this.Log("Error sending message");
}
}
else
{
Thread.Sleep(10);
}
if (watch.ElapsedMilliseconds > 999)
{
watch.Restart();
SendStateMessage();
}
}
}
catch (Exception exp)
{
LastException = exp;
}
finally
{
pushSocket?.Dispose();
}
}
// implements AirXRCameraRigManager.PredictionEventHandler
void AirXRCameraRigManager.PredictionEventHandler.OnStartPrediction(AirXRCameraRig cameraRig, string profileReportEndpoint, string motionOutputEndpoint)
{
if (bypassPrediction || _zmqReportEndpoint != null)
{
return;
}
string endpoint = convertZmqEndpoint(profileReportEndpoint);
if (string.IsNullOrEmpty(endpoint) == false)
{
_zmqReportEndpoint = new PushSocket();
_zmqReportEndpoint.Connect(endpoint);
}
predictedMotionProvider.Connect(convertZmqEndpoint(motionOutputEndpoint));
}
private static async Task CreatePushSocket()
{
var poller = new NetMQPoller();
push = new PushSocket();
push.BindRandomPort("tcp://127.0.0.1");
NetMQMonitor monitor = new NetMQMonitor(push, "inproc://req.inproc", SocketEvents.All);
monitor.Connected += Monitor_Connected;
monitor.EventReceived += Monitor_EventReceived;
//monitor.AttachToPoller(poller);
queue.ReceiveReady += Queue_ReceiveReady;;
push.Connect(address);
poller.Add(push);
poller.Add(queue);
poller.RunAsync();
await monitor.StartAsync();
}
public bool Send(string message, string serverPushAddress, int serverPushPort)
{
try
{
using (var producer = new PushSocket())
{
producer.Connect(serverPushAddress + ":" + serverPushPort);
producer.SendFrame(message);
System.Threading.Thread.Sleep(2000);
producer.Disconnect(serverPushAddress + ":" + serverPushPort);
}
return(true);
}
catch
{
return(false);
}
}
public void Client(NodeDto connectingNode,
DhtProtocolCommandDto protocolCommandDto)
{
var cleanAddress = connectingNode.IpAddress.Replace("127.0.0.1", "localhost");
var address = $"tcp://{cleanAddress}:{connectingNode.Port}";
// client = _clients.FirstOrDefault(socket => socket.Options.LastEndpoint.Equals(address));
// if (client == null)
// {
// client = new RequestSocket();
// _clients.Add(client);
// }
try
{
client.Connect(address);
client.TrySendFrame(protocolCommandDto.ToString());
client?.Disconnect(address);
// client.TryReceiveSignal(out bool signal);
}
catch (NetMQException e)
{
Log.Logger.Error(e, e.Message);
Log.Debug(e.ErrorCode.ToString());
Log.Debug(e.StackTrace);
Log.Debug(e.Message);
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.Message);
Console.WriteLine(e.InnerException);
Console.WriteLine(address);
}
catch (Exception exception)
{
Log.Logger.Error(exception, exception.Message);
Log.Debug(exception.Message);
}
finally
{
// _clients.Remove(client);
// client?.Disconnect(address);
// client?.Dispose();
}
}
public void Open()
{
Logger = new NLogLoggingService("roynet");
Logger.Trace("************************");
Logger.Trace("game server is starting");
List <CommandBase> commands = new List <CommandBase>()
{
new LoginCommand(),
new LogoutCommand()
};
//加载模块
OnServerStartup(_modules);
foreach (RoyNetModule module in _modules)
{
module.Configure(commands);
Logger.Trace("load module:{0}", module.Name);
}
//初始化Command
MethodInfo methodSerializer = typeof(ProtoBuf.Serializer).GetMethod("Deserialize");
foreach (CommandBase command in commands)
{
RegisterCommand(methodSerializer, command);
Logger.Trace("load command:{0}", command.Name);
}
_pullSocket.Bind(Address + "in");
_pushSocket.Connect(Address + "out");
_mainThread.Start();
_sendThread.Start();
_receThread.Start();
IsRunning = true;
Logger.Trace("game server start successful");
foreach (RoyNetModule module in _modules)
{
module.Startup();
}
}
// Overide the run thread
protected override void Run()
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (PushSocket client = new PushSocket())
{
string addr = "tcp://localhost:" + port;
client.Connect(addr);
while (Running)
{
if (newDataFlag)
{
//Debug.Log("ZMQPusher-> Data Sent through ZMQ.");
client.SendFrame(sendData);
newDataFlag = false;
}
}
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
public void CloseSendingSockets()
{
Console.WriteLine("FINISHED SENDING DATA");
var selfSocket = new PushSocket();
selfSocket.Connect("tcp://" + RemoteServGr.NodeAddress);
var msg = new Message
{
MsgType = MessageType.EndingProgram,
SendingServer = RemoteServGr.NodeAddress
};
var msgJson = JsonConvert.SerializeObject(msg);
selfSocket.SendFrame(msgJson);
foreach (var socket in RemoteServGr.RemoteServerSockets)
{
socket.Value.Close();
}
selfSocket.Close();
}
public int FanInClientService()
{
if (ModFanInClients != null)
{
foreach (Point p in ModFanInClients)
{
if (FanInClintRM.ContainsKey(p.name))
{
Logging.logger.Warn("The fanin clisnt is exist " + p.name);
}
else
{
FaninClientRun rr = new FaninClientRun();
PushSocket r = new PushSocket();
string e = "tcp://" + p.ip + ":" + p.port;
try
{
r.Connect(e);
rr.name = p.name;
rr.point = p;
rr.pushsock = r;
rr.Running = true;
rr.Working = false;
}
catch (Exception err)
{
Logging.logger.Error(ModName + " connect pull socket failed " + e + " " + err.Message);
throw (err);
}
FanInClintRM.Add(p.name, rr);
}
}
}
return(0);
}
void StartClient()
{
Debug.Log("Client is On!!");
using (var pushSocket = new PushSocket())
using (var subscriberSocket = new SubscriberSocket())
{
pushSocket.Connect("tcp://localhost:20002");
subscriberSocket.Connect("tcp://localhost:20001");
subscriberSocket.Subscribe("topicA");
Thread.Sleep(TimeSpan.FromSeconds(2));
Debug.Log("Send !!");
pushSocket.SendFrame("Hello Server First!");
while (true)
{
string str = subscriberSocket.ReceiveFrameString();
Debug.Log("[Client] Get! :: " + str);
pushSocket.SendFrame("Hello Server!");
Debug.Log("[Client] Send Hello Server!");
}
}
}
public void Start()
{
using (_producer = new PushSocket())
{
_producer.Connect(_routerEndpoint);
while (!_cancel.IsCancellationRequested)
{
var message = new Message()
{
Id = Guid.NewGuid(),
Payload = DateTime.Now.Ticks
};
Produced.Add(message);
var messageBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
_producer.SendFrame(messageBytes);
Thread.Sleep(100);
}
}
}
public void Run()
{
Console.WriteLine("[CLIENT {0}] Starting", m_id);
var rnd = new Random(m_id);
// each request shall have an unique id in order to recognize an reply for a request
var messageId = new byte[5];
// create clientId for messages
var clientId = new[] { m_id };
// a flag to signal that an answer has arrived
bool messageAnswered = false;
// we use a poller because we have a socket and a timer to monitor
using (var clientPoller = new NetMQPoller())
using (var client = new RequestSocket())
using (var monitor = new PushSocket())
{
client.Connect(m_localFrontendAddress);
monitor.Connect(m_monitorAddress);
client.Options.Identity = new[] { m_id };
var timer = new NetMQTimer((int)TimeSpan.FromSeconds(10).TotalMilliseconds);
// use as flag to indicate exit
var exit = false;
// every 10 s check if message has been received, if not then send error message and ext
// and restart timer otherwise
timer.Elapsed += (s, e) =>
{
if (messageAnswered)
{
e.Timer.Enable = true;
}
else
{
var msg = string.Format("[CLIENT {0}] ERR - EXIT - lost message {1}", m_id, messageId);
// send an error message
monitor.SendFrame(msg);
// if poller is started than stop it
if (clientPoller.IsRunning)
{
clientPoller.Stop();
}
// mark the required exit
exit = true;
}
};
// process arriving answers
client.ReceiveReady += (s, e) =>
{
// mark the arrival of an answer
messageAnswered = true;
// worker is supposed to answer with our request id
var reply = e.Socket.ReceiveMultipartMessage();
if (reply.FrameCount == 0)
{
// something went wrong
monitor.SendFrame(string.Format("[CLIENT {0}] Received an empty message!", m_id));
// mark the exit flag to ensure the exit
exit = true;
}
else
{
var sb = new StringBuilder();
// create success message
foreach (var frame in reply)
{
sb.Append("[" + frame.ConvertToString() + "]");
}
// send the success message
monitor.SendFrame(string.Format("[CLIENT {0}] Received answer {1}",
m_id,
sb.ToString()));
}
};
// add socket & timer to poller
clientPoller.Add(client);
clientPoller.Add(timer);
// start poller in another thread to allow the continued processing
clientPoller.RunAsync();
// if true the message has been answered
// the 0th message is always answered
messageAnswered = true;
while (!exit)
{
// simulate sporadic activity by randomly delaying
Thread.Sleep((int)TimeSpan.FromSeconds(rnd.Next(5)).TotalMilliseconds);
// only send next message if the previous one has been replied to
if (messageAnswered)
{
// generate random 5 byte as identity for for the message
rnd.NextBytes(messageId);
messageAnswered = false;
// create message [client adr][empty][message id] and send it
var msg = new NetMQMessage();
msg.Push(messageId);
msg.Push(NetMQFrame.Empty);
msg.Push(clientId);
client.SendMultipartMessage(msg);
}
}
// stop poller if needed
if (clientPoller.IsRunning)
{
clientPoller.Stop();
}
}
}
public static void Execute()
{
Console.WriteLine("Executing PushPull test");
_clientData = new byte[DataSize];
_serverData = new byte[DataSize];
var r = new Random();
r.NextBytes(_clientData);
r.NextBytes(_serverData);
var clientThread = new Thread(
() =>
{
var req = new PushSocket();
req.Connect(InprocAddress);
var revreq = new PullSocket();
revreq.Bind(InprocAddressReverse);
byte[] streamOutput = new byte[BufferSize];
while (true)
{
var sw = Stopwatch.StartNew();
for (int i = 0; i < Iter; i++)
{
var result = req.SendImmediate(_clientData);
Trace.Assert(result);
int read = 0;
using (var stream = revreq.ReceiveStream())
while (stream.Length != stream.Position)
{
read += stream.Read(streamOutput, 0, streamOutput.Length);
}
Trace.Assert(read == _serverData.Length);
}
sw.Stop();
var secondsPerSend = sw.Elapsed.TotalSeconds / (double)Iter;
Console.WriteLine("PushPull Time {0} us, {1} per second, {2} mb/s ",
(int)(secondsPerSend * 1000d * 1000d),
(int)(1d / secondsPerSend),
(int)(DataSize * 2d / (1024d * 1024d * secondsPerSend)));
}
});
clientThread.Start();
{
var rep = new PullSocket();
rep.Bind(InprocAddress);
var revrep = new PushSocket();
revrep.Connect(InprocAddressReverse);
byte[] streamOutput = new byte[BufferSize];
var sw = Stopwatch.StartNew();
while (sw.Elapsed.TotalSeconds < 10)
{
int read = 0;
using (var stream = rep.ReceiveStream())
while (stream.Length != stream.Position)
{
read += stream.Read(streamOutput, 0, streamOutput.Length);
}
revrep.SendImmediate(_serverData);
}
clientThread.Abort();
}
}
public void Run()
{
Console.WriteLine("[CLIENT {0}] Starting", m_id);
var rnd = new Random(m_id);
// each request shall have an unique id in order to recognize an reply for a request
var messageId = new byte[5];
// create clientId for messages
var clientId = new[] { m_id };
// a flag to signal that an answer has arrived
bool messageAnswered = false;
// we use a poller because we have a socket and a timer to monitor
using (var clientPoller = new NetMQPoller())
using (var client = new RequestSocket())
using (var monitor = new PushSocket())
{
client.Connect(m_localFrontendAddress);
monitor.Connect(m_monitorAddress);
client.Options.Identity = new[] { m_id };
var timer = new NetMQTimer((int)TimeSpan.FromSeconds(10).TotalMilliseconds);
// use as flag to indicate exit
var exit = false;
// every 10 s check if message has been received, if not then send error message and ext
// and restart timer otherwise
timer.Elapsed += (s, e) =>
{
if (messageAnswered)
{
e.Timer.Enable = true;
}
else
{
var msg = string.Format("[CLIENT {0}] ERR - EXIT - lost message {1}", m_id, messageId);
// send an error message
monitor.SendFrame(msg);
// if poller is started than stop it
if (clientPoller.IsRunning)
clientPoller.Stop();
// mark the required exit
exit = true;
}
};
// process arriving answers
client.ReceiveReady += (s, e) =>
{
// mark the arrival of an answer
messageAnswered = true;
// worker is supposed to answer with our request id
var reply = e.Socket.ReceiveMultipartMessage();
if (reply.FrameCount == 0)
{
// something went wrong
monitor.SendFrame(string.Format("[CLIENT {0}] Received an empty message!", m_id));
// mark the exit flag to ensure the exit
exit = true;
}
else
{
var sb = new StringBuilder();
// create success message
foreach (var frame in reply)
sb.Append("[" + frame.ConvertToString() + "]");
// send the success message
monitor.SendFrame(string.Format("[CLIENT {0}] Received answer {1}",
m_id,
sb.ToString()));
}
};
// add socket & timer to poller
clientPoller.Add(client);
clientPoller.Add(timer);
// start poller in another thread to allow the continued processing
clientPoller.RunAsync();
// if true the message has been answered
// the 0th message is always answered
messageAnswered = true;
while (!exit)
{
// simulate sporadic activity by randomly delaying
Thread.Sleep((int)TimeSpan.FromSeconds(rnd.Next(5)).TotalMilliseconds);
// only send next message if the previous one has been replied to
if (messageAnswered)
{
// generate random 5 byte as identity for for the message
rnd.NextBytes(messageId);
messageAnswered = false;
// create message [client adr][empty][message id] and send it
var msg = new NetMQMessage();
msg.Push(messageId);
msg.Push(NetMQFrame.Empty);
msg.Push(clientId);
client.SendMultipartMessage(msg);
}
}
// stop poller if needed
if (clientPoller.IsRunning)
clientPoller.Stop();
}
}
/// <summary>
/// create a socket client to push message
/// </summary>
/// <param name="ip">socket server ip</param>
/// <param name="port">socket server port</param>
public MessagePusher(string ip, int port)
{
_pusher = new PushSocket();
_pusher.Connect($"tcp://{ip}:{port}");
}
