private static void ClientRoutine(object clientId)
{
try
{
using (NetMQContext context = NetMQContext.Create())
{
using (RequestSocket req = context.CreateRequestSocket())
{
req.Connect("tcp://localhost:5555");
byte[] message = Encoding.Unicode.GetBytes(string.Format("{0} Hello", clientId));
Console.WriteLine("Client {0} sent \"{0} Hello\"", clientId);
req.Send(message, message.Length);
bool hasMore;
byte[] response = req.Receive(false, out hasMore);
Console.WriteLine("Client {0} received \"{1}\"", clientId, Encoding.Unicode.GetString(response));
}
}
}
catch (Exception exc)
{
Console.WriteLine("Exception on ClientRoutine: {0}", exc.Message);
}
}
public TextResponse Request(TextRequest request)
{
_socket.Send(Encoding.UTF8.GetBytes(request.Text));
var bs = _socket.Receive();
var s = Encoding.UTF8.GetString(bs);
return(new TextResponse(s));
}
private static void Main()
{
Console.Title = "NetMQ LazyPirate Client";
using (var context = NetMQContext.Create())
{
RequestSocket client = CreateServerSocket(context);
while (s_retriesLeft > 0)
{
s_sequence++;
Console.WriteLine("C: Sending ({0})", s_sequence);
client.Send(Encoding.Unicode.GetBytes(s_sequence.ToString()));
s_expectReply = true;
while (s_expectReply)
{
bool result = client.Poll(TimeSpan.FromMilliseconds(RequestTimeout));
if (result)
{
continue;
}
s_retriesLeft--;
if (s_retriesLeft == 0)
{
Console.WriteLine("C: Server seems to be offline, abandoning");
break;
}
Console.WriteLine("C: No response from server, retrying...");
TerminateClient(client);
client = CreateServerSocket(context);
client.Send(Encoding.Unicode.GetBytes(s_sequence.ToString()));
}
}
TerminateClient(client);
}
}
protected void Request(String data)
{
interaction.Send(Encoding.UTF8.GetBytes(data));
String reply = Response();
if (reply != acknowledged)
{
throw new Exception("Cannot register: " + reply);
}
}
public void Connect(Config config, string addr)
{
req.Connect(String.Format("ws://{0}:{1}", addr, config.CacherCmdPort));
sub.Connect(String.Format("ws://{0}:{1}", addr, config.CacherDatPort));
this.config = config;
Params.Clear();
req.Send(PackOne(0, 0));
// this is blocking, we won't return until server has responded
var data = req.Receive();
UnpackToMap(data, config.Params, ref Params);
// use key 0 to signal everything has changed
// Alternatively, a event could be emitted for each key but the
// consideration is it could overload whatever handler for being
// called too many times. It is conceivable the handle simply will
// update for all params each time a event is received.
Changed(this, 0);
}
static void Main(string[] args)
{
using (NetMQContext context = NetMQContext.Create())
{
RequestSocket client = CreateServerSocket(context);
while (_retriesLeft > 0)
{
_sequence++;
Console.WriteLine("C: Sending ({0})", _sequence);
client.Send(Encoding.Unicode.GetBytes(_sequence.ToString()));
_expectReply = true;
while (_expectReply)
{
bool result = client.Poll(TimeSpan.FromMilliseconds(REQUEST_TIMEOUT));
if (!result)
{
_retriesLeft--;
if (_retriesLeft == 0)
{
Console.WriteLine("C: Server seems to be offline, abandoning");
break;
}
else
{
Console.WriteLine("C: No response from server, retrying...");
client.Disconnect(SERVER_ENDPOINT);
client.Close();
client.Dispose();
client = CreateServerSocket(context);
client.Send(Encoding.Unicode.GetBytes(_sequence.ToString()));
}
}
}
}
}
}
private static void Node1(string url)
{
using (var s = new RequestSocket())
{
s.Connect(url);
const string sendText = "Hello, World!";
Console.WriteLine("NODE1: SENDING \"" + sendText + "\"");
s.Send(Encoding.UTF8.GetBytes(sendText));
Console.WriteLine("NODE1: RECEIVED: \"" + Encoding.UTF8.GetString(s.Receive()) + "\"");
}
}
public byte[] GetSnapshot(string topic)
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (RequestSocket socket = ctx.CreateRequestSocket())
{
socket.Connect(Address);
socket.Send(topic);
NetMQMessage message = socket.ReceiveMessage();
return(message.Last.ToByteArray());
}
}
}
public static void Request()
{
using (var s = new RequestSocket())
{
s.Connect(MessageQueueConstants.Address);
Debug.WriteLine("Request: Sending request");
s.Send(Encoding.UTF8.GetBytes(MessageQueueConstants.RequestPayload));
Debug.WriteLine("Request: Receiving reply");
var replyPayload = s.Receive();
Assert.IsTrue(BitConverter.ToInt32(replyPayload, 0) == MessageQueueConstants.ReplyPayload);
}
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_lat remote_lat <connect-to> <message-size> <roundtrip-count>");
return(1);
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int roundtripCount = int.Parse(args[2]);
using (var req = new RequestSocket())
{
req.Connect(connectTo);
var msg = new Msg();
msg.InitPool(messageSize);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i != roundtripCount; i++)
{
req.Send(ref msg, more: false);
req.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: {0} Expected: {1}", msg.Size, messageSize);
return(-1);
}
}
stopWatch.Stop();
msg.Close();
double elapsedMicroseconds = stopWatch.ElapsedTicks * 1000000L / Stopwatch.Frequency;
double latency = elapsedMicroseconds / (roundtripCount * 2);
Console.WriteLine("message size: {0} [B]", messageSize);
Console.WriteLine("roundtrip count: {0}", roundtripCount);
Console.WriteLine("average latency: {0:0.000} [µs]", latency);
}
return(0);
}
private void Connect()
{
// getting the snapshot
using (RequestSocket requestSocket = context.CreateRequestSocket())
{
requestSocket.Connect(string.Format("tcp://{0}:{1}", address, SnapshotProtocol.Port));
requestSocket.Send(SnapshotProtocol.GetTradessCommand);
string json;
requestSocket.Options.ReceiveTimeout = SnapshotProtocol.RequestTimeout;
try
{
json = requestSocket.ReceiveString();
}
catch (AgainException ex)
{
// Fail to receive trades, we call on error and don't try to do anything with subscriber
// calling on error from poller thread block the application
Task.Run(() => subject.OnError(new Exception("No response from server")));
return;
}
while (json != SnapshotProtocol.EndOfTickers)
{
PublishTicker(json);
json = requestSocket.ReceiveString();
}
}
subscriberSocket = context.CreateSubscriberSocket();
subscriberSocket.Subscribe(StreamingProtocol.TradesTopic);
subscriberSocket.Subscribe(StreamingProtocol.HeartbeatTopic);
subscriberSocket.Connect(string.Format("tcp://{0}:{1}", address, StreamingProtocol.Port));
subscriberSocket.ReceiveReady += OnSubscriberReady;
poller.AddSocket(subscriberSocket);
// reset timeout timer
timeoutTimer.Enable = false;
timeoutTimer.Enable = true;
}
public static void WorkerTask(object portNumber)
{
var randomizer = new Random(DateTime.Now.Millisecond);
using (NetMQContext context = NetMQContext.Create())
{
using (RequestSocket worker = context.CreateRequestSocket())
{
// We use a string identity for ease here
string id = ZHelpers.SetID(worker, Encoding.Unicode);
string cnn = string.Format("tcp://localhost:{0}", portNumber);
worker.Connect(cnn);
Console.WriteLine("[W] ID {0} connect to {1}", id, cnn);
int total = 0;
bool end = false;
while (!end)
{
// Tell the router we're ready for work
string msg = "Ready";
worker.Send(msg);
//Console.WriteLine("[W] Message sent: {0}", msg);
// Get workload from router, until finished
string workload = worker.ReceiveString();
//Console.WriteLine("[W] Workload received: {0}", workload);
if (workload.Equals("END"))
{
end = true;
}
else
{
total++;
Thread.Sleep(randomizer.Next(1, 1000)); // Simulate 'work'
}
}
Console.WriteLine("ID ({0}) processed: {1} tasks", Encoding.Unicode.GetString(worker.Options.Identity), total);
}
}
}
public ReactiveClient()
{
var context = NetMQContext.Create();
reqSocket = context.CreateRequestSocket();
reqSocket.Connect("tcp://127.0.0.1:3334");
reqSocket.Send("GetMarket");
var data = reqSocket.Receive();
var mess = Encoding.UTF8.GetString(data);
Console.WriteLine(mess);
subSocket = context.CreateSubscriberSocket();
subSocket.Connect("tcp://127.0.0.1:3333");
subSocket.Subscribe("");
var thread = new Thread(ReceiveThread);
thread.Start();
}
public static void Execute(string[] args)
{
const string socketAddress = "tcp://127.0.0.1:5088";
if (args[1] == "client")
{
using (var req = new RequestSocket())
{
req.Connect(socketAddress);
req.Send(Encoding.UTF8.GetBytes("hello from client"));
Console.WriteLine("Message from SERVER: " + Encoding.UTF8.GetString(req.Receive()));
Console.WriteLine("CLIENT finished");
}
}
else if (args[1] == "server")
{
using (var rep = new ReplySocket())
{
rep.Bind(socketAddress);
var listener = new NanomsgListener();
listener.AddSocket(rep);
listener.ReceivedMessage += socketId =>
{
Console.WriteLine("Message from CLIENT: " + Encoding.UTF8.GetString(rep.Receive()));
rep.Send(Encoding.UTF8.GetBytes("hello from server"));
Console.WriteLine("SERVER Finished");
Environment.Exit(0);
};
listener.Listen(null);
}
}
else
{
Console.WriteLine("Unknown argument: " + args[1]);
}
}
public static void host_comm()
{
if (_hostCommInstantiated)
{
return;
}
_hostCommInstantiated = true;
var reqAddress = "tcp://" + HostAndClientInput.hostIp + ":5560";
var req = new RequestSocket();
req.Connect(reqAddress);
while (true)
{
var msg = new Msg();
msg.InitGC(Encoding.ASCII.GetBytes("{\"ID\":0}"), Encoding.ASCII.GetBytes("{\"ID\":0}").Length);
req.Send(ref msg, false);
var recvStr = req.ReceiveFrameString();
HostAndClientInput.receivedGoObjectPoses = JsonConvert.DeserializeObject <ConcurrentDictionary <string, ConcurrentDictionary <string, float> > >(recvStr);
}
}
public void Upload()
{
try
{
// PublishSocket PubClient = new PublishSocket();
//// PubClient.Bind("tcp://" + Global.Instance.LanIp + ":" + "8001");
// PubClient.Bind("tcp://"+"192.168.168.36"+ ":" + "8001");
// // label1.Text = "Come";
// string sp = "upload";
// // Console.WriteLine(sp.Length);
// var intBytes = BitConverter.GetBytes(Global.Instance.ClientId);
// var buff = intBytes.Concat(Encoding.ASCII.GetBytes(sp)).ToArray();
// Thread.Sleep(10000);
// PubClient.Send(buff);
// PubClient.Dispose();
// Console.WriteLine(sp);
_requestSocket = new RequestSocket();
_requestSocket.Connect("tcp://" + Global.Instance.NNFConIp + ":" + "8222");
// _requestSocket.Connect("tcp://" + "192.168.168.36" + ":" + "8222");
string sp = "upload";
var intBytes = BitConverter.GetBytes(Global.Instance.ClientId);
var buff = intBytes.Concat(Encoding.ASCII.GetBytes(sp)).ToArray();
_requestSocket.Send(buff);
// _requestSocket.Dispose();
}
catch (Exception es)
{
}
}
public string SendRequest(string request)
{
_reqSocket.Send(request);
byte[] receiveBuffer;
try
{
receiveBuffer = _reqSocket.Receive();
if (receiveBuffer == null) // NetMQ > 3.3.0.11
{
throw TimeoutException;
}
return(Encoding.UTF8.GetString(receiveBuffer));
}
catch (TerminatingException)
{
Dispose();
throw;
}
catch (AgainException) // NetMQ = 3.3.0.11
{
throw TimeoutException;
}
}
public void Send(string data)
{
_socket.Send(string.Format("{0},{1}", Id, data));
_socket.Receive(); //ack
}
public OCForm()
{
sc = WindowsFormsSynchronizationContext.Current as WindowsFormsSynchronizationContext;
InitializeComponent();
flowLayoutPanelSysmenu.MouseDown += MoveWindow;
flowLayoutPanelSysmenu.DoubleClick += ResizeWindow;
toolStripLeftPanel.MouseDown += MoveWindow;
toolStripLeftPanel.DoubleClick += ResizeWindow;
RegisterSysCommandBehavior();
RegisterOwnerDraw();
LoadLeftPanel();
//Random randomGen = new Random();
//KnownColor[] names = (KnownColor[])Enum.GetValues(typeof(KnownColor));
lvConversations.Items.AddRange(new ListViewItem[] {
new ListViewItem("1")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "姓名1", LastUpdate = DateTime.Now, PeekMessage = "Message1", IsMute = true
}
},
new ListViewItem("2")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name2", LastUpdate = DateTime.Now, PeekMessage = "\ue136", IsMute = true
}
},
new ListViewItem("3")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name3", LastUpdate = DateTime.Now, PeekMessage = "消息～3", IsMute = true
}
},
new ListViewItem("1")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "姓名1", LastUpdate = DateTime.Now, PeekMessage = "Message1", IsMute = true
}
},
new ListViewItem("2")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name2", LastUpdate = DateTime.Now, PeekMessage = "\ue137", IsMute = true
}
},
new ListViewItem("3")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name3", LastUpdate = DateTime.Now, PeekMessage = "消息～3", IsMute = true
}
},
new ListViewItem("1")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "姓名1", LastUpdate = DateTime.Now, PeekMessage = "Message1", IsMute = true
}
},
new ListViewItem("2")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name2", LastUpdate = DateTime.Now, PeekMessage = "Message2", IsMute = true
}
},
new ListViewItem("3")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name3", LastUpdate = DateTime.Now, PeekMessage = "消息～3", IsMute = true
}
},
new ListViewItem("1")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "姓名1", LastUpdate = DateTime.Now, PeekMessage = "\ue138", IsMute = true
}
},
new ListViewItem("2")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name2", LastUpdate = DateTime.Now, PeekMessage = "Message2", IsMute = true
}
},
new ListViewItem("3")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name3", LastUpdate = DateTime.Now, PeekMessage = "消息～3", IsMute = true
}
},
new ListViewItem("1")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "姓名1", LastUpdate = DateTime.Now, PeekMessage = "Message1", IsMute = true
}
},
new ListViewItem("2")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name2", LastUpdate = DateTime.Now, PeekMessage = "\ue139", IsMute = true
}
},
new ListViewItem("3")
{
Tag = new ConversationShortcut()
{
Icon = Guid.NewGuid(), DisplayName = "Name3", LastUpdate = DateTime.Now, PeekMessage = "消息～3", IsMute = true
}
},
});
for (int i = 0; i < lvConversations.Items.Count; i++)
{
var shortcut = lvConversations.Items[i].Tag as ConversationShortcut;
var chatUI = GetChatUI(shortcut.Icon);
chatrooms.AddOrUpdate(shortcut.Icon.ToString(), chatUI, (key, value) => chatUI);
//chatUI.BackColor = Color.FromKnownColor(names[randomGen.Next(names.Length)]);
}
/*chatUI.AddMessage(Guid.Empty, "你好,祝你生日快乐!");
* chatUI.AddMessage(Guid.Empty, "你是？", false);
* chatUI.AddMessage(Guid.Empty, "我是你的小号啊");
* chatUI.AddMessage(Guid.Empty, ":-( 伐开熏 ...", false);
*/
Messaging.Message message = null;
ThreadPool.QueueUserWorkItem(state => {
//Get Message From 0MQ
//Handle
bool working = true;
while (working)
{
sendEvent.WaitOne();
//Validate Message;
if (message != null)
{
Guid guid = message.From; string Guid = guid.ToString();
ChatUI ui = null;
if (chatrooms.ContainsKey(Guid))
{
ui = chatrooms[Guid];
}
else
{
ui = new ChatUI(guid); chatrooms.TryAdd(Guid, ui);
}
}
}
});
ThreadPool.QueueUserWorkItem(state => {
using (SubscriberSocket subscriber = new SubscriberSocket()) {
subscriber.Bind($"tcp://localhost:12555");
//Handle Subscriber
subscriber.SubscribeToAnyTopic();
Msg msg = new Msg(); msg.InitEmpty();
while (true)
{
subscriber.TryReceive(ref msg, TimeSpan.MaxValue);
using (MemoryStream ms = new MemoryStream(msg.Data)) {
BinaryFormatter bf = new BinaryFormatter();
Messaging.Message groupMessage = bf.Deserialize(ms) as Messaging.Message;
if (groupMessage == null)
{
continue;
}
if (!groupMessage.MessageType.HasFlag(Messaging.MessageType.MT_GROUP_FLAG))
{
continue;
}
Guid from = groupMessage.From;
}
}
}
});
ThreadPool.QueueUserWorkItem(state => {
new FakeServer().Init();
});
cmdSend.Click += (sender, @event) => {
if (ActiveChatUI == null)
{
return;
}
Guid TO = ActiveChatUI.Target; string to = TO.ToString();
if (!members.ContainsKey(to))
{
return;
}
using (var client = new RequestSocket()) {
Messaging.Membership membership = members[to];
client.Connect($">tcp://0x{membership.LastLoginIP:X}:12553");
string ____ = "-------------------";
byte[] data = Encoding.UTF8.GetBytes(____);
Messaging.Message m = new Messaging.Message(1, from, TO, Guid.Empty,
TimeSpan.FromMinutes(1D), false, new Guid(),
Messaging.MessageType.MT_PLAINTEXT, data.Length, data);
using (MemoryStream ms = new MemoryStream()) {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, m); data = ms.ToArray();
msg.Put(data, 0, data.Length);
}
client.Send(ref msg, false);
//Clear Input
sendEvent.Set();
}
};
lvConversations.Click += (sender, @event) => {
if (lvConversations.SelectedIndices.Count == 0)
{
return;
}
int selectedIndex = lvConversations.SelectedIndices[0];
var shortcut = lvConversations.Items[selectedIndex].Tag as ConversationShortcut;
if (shortcut == null)
{
return;
}
ChatUI chatUI = GetChatUI(shortcut.Icon);
for (int i = 0; i < splitContainerChat.Panel1.Controls.Count; i++)
{
splitContainerChat.Panel1.Controls[i].Visible = (chatUI == splitContainerChat.Panel1.Controls[i]);
}
ActiveChatUI = chatUI;
lblInfo.Text = shortcut.DisplayName;
};
lblInfo.Click += (sender, @event) => {
Msg m = new Msg();// m.InitEmpty();
Messaging.Message _message = MessageFactory.CreateMemberInfoMessage(new Guid(), new Guid(), new Guid());
byte[] b = SerializerUtil <Messaging.Message> .Serialize(_message);
m.InitPool(b.Length); m.Put(b, 0, b.Length);
using (var client = new RequestSocket()) {
client.Connect("tcp://localhost:12553");
client.Send(ref m, false);
Msg mm = new Msg(); mm.InitEmpty();
client.Receive(ref mm);
var reply = SerializerUtil <Messaging.Message> .Deserialize(mm.Data);
var response = SerializerUtil <MemberInfoResponse> .Deserialize(reply.Content);
var membership = response.Membership;
MessageBox.Show($"{membership.ID}\n{membership.Name}\n{membership.NickName}\n0x{membership.LastLoginIP :X08}");
}
};
}
//private void timerforchecklogin_Elapsed(object o ,)
//{
//}
//public int Publisher(MessageType msgType, byte[] buffer)
//{
// //var buf=BitConverter.GetBytes((byte)msgType);
// //publisher.Send(buf).Concat(buffer).ToArray());
// //publisher.Send(Encoding.ASCII.GetBytes(msgType));
// //publisher.Send(buffer);
// PubNNF.SendMore(msgType.ToString(), Encoding.Unicode);
// return (int)PubNNF.Send(buffer);
// // return 1;
//}
public void Publisher(MessageType _conversationenum, byte[] data)
{
_requestSocket.Send(BitConverter.GetBytes((short)_conversationenum).Concat(BitConverter.GetBytes(Global.Instance.ClientId)).Concat(data).ToArray());
}
