private void HeartBeatTimer_Elapsed(object sender, NetMQTimerEventArgs e)
{
//check for last heartbeat from server, set to throw on new send if exceeds certain threshold
if (null != _session && null != _session.Crypto)
{
if ((DateTime.UtcNow - _session.LastHeartBeat).TotalMilliseconds
> _heartBeatMs * _maxSkippedHeartBeatReplies)
{
_throwOnSend = true; //do not allow send
_hostDead = true;
_logger.Debug("Heartbeat from server skipped {0} time. Host is dead.",
_maxSkippedHeartBeatReplies);
}
else
{
_logger.Debug("Heartbeat sent.");
HeartBeatsSentCount++;
_sendQueue.Enqueue(new List <byte[]> {
MessageHeader.HeartBeat
});
}
}
else
{
_throwOnSend = true; //do not allow send
}
}
public virtual Task <byte[]> SendRequestAsync(string service, byte[] message)
{
var outgoingMessage = new ClientEngine.OutgoingMessage(new TaskCompletionSource <byte[]>(), service, message, false);
// NetMQQueue is thread safe, so no need to lock
m_outgoingQueue.Enqueue(outgoingMessage);
return(outgoingMessage.TaskCompletionSource.Task);
}
public void AddToQue(StoredLogType logType, string logString, DateTime date, string applicationId)
{
if (string.IsNullOrEmpty(logString) == false)
{
queue.Enqueue(new RawLogData {
Type = logType, Data = logString, IsListData = false, ReceiveDate = date, ApplicationId = applicationId
});
}
}
//Executes on same poller thread as dealer socket, so we enqueue to the received queue
//and raise the event on the client poller thread for received queue
private void DealerSocket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msg = e.Socket.ReceiveMultipartMessage();
_logger.Debug("Message received. Frame count: {0}", msg.FrameCount);
var message = msg.ToMessageWithoutClientFrame(_clientId);
_receiveQueue.Enqueue(message.Frames);
}
public void SendMessage(string msg)
{
if (!string.IsNullOrEmpty(msg))
{
mRawDataStream.Write($"[{ DateTime.UtcNow:HH:mm:ss.fff}] >> { msg }\n");
mRawDataStream.Flush();
mMessageQueue.Enqueue(msg);
}
}
private void DisposeClient()
{
var old = m_client;
old.ReceiveReady -= OnReceiveReady;
old.SendReady -= OnSendReady;
m_poller.Remove(old);
m_pollerQueue.Enqueue(() => old.Dispose());
}
public void EnqueueDequeue()
{
using (var queue = new NetMQQueue<int>())
{
queue.Enqueue(1);
Assert.AreEqual(1, queue.Dequeue());
}
}
public void EnqueueDequeue()
{
using (var queue = new NetMQQueue <int>())
{
queue.Enqueue(1);
Assert.AreEqual(1, queue.Dequeue());
}
}
public void Send(Guid clientId, List <byte[]> frames)
{
if (_disposed)
{
throw new ObjectDisposedException("Client", "Cannot send on disposed client.");
}
if (null == frames || frames.Count == 0)
{
_logger.Error("Send message failed. Empty message.");
throw new ArgumentException("Cannot be null or empty.", nameof(frames));
}
var message = new NetMQMessage();
message.Append(clientId.ToByteArray());
message.AppendEmptyFrame();
if (null != _authRepository)
{
HostSession session = null;
if (!_sessions.TryGetValue(clientId, out session))
{
session = null;
}
if (null != session && null != session.Crypto)
{
foreach (var frame in frames)
{
message.Append(session.Crypto.Encrypt(frame));
}
}
else
{
_logger.Error("Send message failed. Protocol not established for this client {0}.", clientId);
throw new OperationCanceledException("Encrypted session not established.");
}
}
else
{
foreach (var frame in frames)
{
message.Append(frame);
}
}
_sendQueue.Enqueue(message); //send by message to socket poller
}
public void EnqueueDequeue()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQQueue<int> queue = new NetMQQueue<int>(context))
{
queue.Enqueue(1);
Assert.AreEqual(1, queue.Dequeue());
}
}
public void EnqueueDequeue()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQQueue <int> queue = new NetMQQueue <int>(context))
{
queue.Enqueue(1);
Assert.AreEqual(1, queue.Dequeue());
}
}
public void TryDequeue()
{
using (var queue = new NetMQQueue <int>())
{
Assert.IsFalse(queue.TryDequeue(out int result, TimeSpan.FromMilliseconds(100)));
queue.Enqueue(1);
Assert.IsTrue(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100)));
Assert.AreEqual(1, result);
}
}
public static void Main()
{
int count = 10000000;
using (NetMQContext context = NetMQContext.Create())
{
NetMQQueue <int> queue = new NetMQQueue <int>(context);
var task = Task.Factory.StartNew(() =>
{
queue.Dequeue();
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
queue.Dequeue();
}
stopwatch.Stop();
Console.WriteLine("Dequeueing items per second: {0:N0}", count / stopwatch.Elapsed.TotalSeconds);
});
queue.Enqueue(-1);
Stopwatch writeStopwatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
queue.Enqueue(i);
}
writeStopwatch.Stop();
Console.WriteLine("Enqueueing items per second: {0:N0}", count / writeStopwatch.Elapsed.TotalSeconds);
task.Wait();
}
}
public static void Main()
{
int count = 10000000;
using (NetMQContext context = NetMQContext.Create())
{
NetMQQueue<int> queue = new NetMQQueue<int>(context);
var task = Task.Factory.StartNew(() =>
{
queue.Dequeue();
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
queue.Dequeue();
}
stopwatch.Stop();
Console.WriteLine("Dequeueing items per second: {0:N0}", count /stopwatch.Elapsed.TotalSeconds);
});
queue.Enqueue(-1);
Stopwatch writeStopwatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
queue.Enqueue(i);
}
writeStopwatch.Stop();
Console.WriteLine("Enqueueing items per second: {0:N0}", count/writeStopwatch.Elapsed.TotalSeconds);
task.Wait();
}
}
//occurs on socket polling thread to assure sending and receiving on same thread
private void RouterSocket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msg = e.Socket.ReceiveMultipartMessage();
if (null == msg || msg.FrameCount < 2)
{
return; //ignore this message - nothing in it
}
_logger.Debug("Message received. Frame count: {0}", msg.FrameCount);
var message = msg.ToMessageWithClientFrame();
_receivedQueue.Enqueue(message); //sends by message to host poller
}
public void SendAck(NetMQMessage reply)
{
if (ReferenceEquals(reply, null))
{
throw new ArgumentNullException("reply");
}
if (ReferenceEquals(m_returnIdentity, null))
{
throw new Exception("You can only send a message after receiving a reply!");
}
var message = Wrap(reply, m_returnIdentity);
if (m_requestId != null)
{
message.Append(m_requestId);
}
m_returnIdentity = null;
m_requestId = null;
m_pollerQueue.Enqueue(() => Send(MDPCommand.Reply, null, message));
}
public void TryDequeue()
{
using (var queue = new NetMQQueue<int>())
{
int result;
Assert.IsFalse(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100)));
queue.Enqueue(1);
Assert.IsTrue(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100)));
Assert.AreEqual(1, result);
}
}
public void TryDequeue()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQQueue <int> queue = new NetMQQueue <int>(context))
{
int result;
Assert.IsFalse(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100)));
queue.Enqueue(1);
Assert.IsTrue(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100)));
Assert.AreEqual(1, result);
}
}
private async Task ProcessMessageAsync <T>(
Blockchain <T> blockchain,
Message message,
CancellationToken cancellationToken)
where T : IAction
{
switch (message)
{
case Ping ping:
_logger.Debug($"Ping received.");
var reply = new Pong
{
Identity = ping.Identity,
};
await ReplyAsync(reply, cancellationToken);
break;
case Messages.PeerSetDelta peerSetDelta:
_deltas.Enqueue(peerSetDelta.Delta);
break;
case GetBlocks getBlocks:
IEnumerable <HashDigest <SHA256> > inventories =
blockchain.FindNextHashes(
getBlocks.Locator, getBlocks.Stop, 500);
var inv = new Inventory(inventories)
{
Identity = getBlocks.Identity,
};
await ReplyAsync(inv, cancellationToken);
break;
case GetData getData:
await TransferBlocks(
blockchain, getData, cancellationToken);
break;
default:
Trace.Fail($"Can't handle message. [{message}]");
break;
}
}
private static void Run(object obj)
{
while (true)
{
//using (var s = new PublisherSocket(">tcp://localhost:1022"))
//{
// for (var i = 0; i < 1000; i++)
// {
// s.SendMoreFrame("aaa").SendFrame(Convert.ToString(DateTime.Now.Ticks));
// }
//}
queue.Enqueue(Convert.ToString(DateTime.Now.Ticks));
Thread.Sleep(1);
}
}
public void StartSending(int id)
{
client.Options.Identity = Encoding.Unicode.GetBytes(id.ToString());
var message = string.Format("Id = {0}", id.ToString());
var bytes = Encoding.ASCII.GetBytes(message);
using (var poller = new NetMQPoller())
{
poller.Add(client);
poller.Add(messageQueue);
poller.RunAsync();
var messageToServer = new NetMQMessage();
messageToServer.Append(message);
messageQueue.Enqueue(messageToServer);
}
}
public void WithPoller()
{
using (var queue = new NetMQQueue<int>())
using (var poller = new NetMQPoller { queue })
{
var manualResetEvent = new ManualResetEvent(false);
queue.ReceiveReady += (sender, args) =>
{
Assert.AreEqual(1, queue.Dequeue());
manualResetEvent.Set();
};
poller.RunAsync();
Assert.IsFalse(manualResetEvent.WaitOne(100));
queue.Enqueue(1);
Assert.IsTrue(manualResetEvent.WaitOne(100));
}
}
/// <summary>
/// 收到客户端请求，交由Actor进行处理
/// </summary>
/// <param name="protocolPackage"></param>
/// <param name="body"></param>
public virtual void ProcessRequest(ProtocolPackage protocolPackage, byte[] body)
{
if (protocolPackage == null)
{
return;
}
var request = protocolPackage.UnPackToPacket(body);
var msg = new NetMQMessage();
msg.Append(new byte[] { 1 }); //版本号
msg.Append("req"); //动作
msg.Append(protocolPackage.SessionID); //sessionid
msg.Append(protocolPackage.PackKeys); //客户端密钥
msg.Append(protocolPackage.UnPackKeys); //服务端密钥
msg.Append(request.HeaderBytes); //信息头
msg.Append(request.ContentBytes); //信息体
//加入队列
PushQueue.Enqueue(msg);
}
public void WithPoller()
{
using (var queue = new NetMQQueue <int>())
using (var poller = new NetMQPoller {
queue
})
{
var manualResetEvent = new ManualResetEvent(false);
queue.ReceiveReady += (sender, args) =>
{
Assert.AreEqual(1, queue.Dequeue());
manualResetEvent.Set();
};
poller.RunAsync();
Assert.IsFalse(manualResetEvent.WaitOne(100));
queue.Enqueue(1);
Assert.IsTrue(manualResetEvent.WaitOne(100));
}
}
public async Task ReceiveMessageAsync()
{
CheckEntered();
while (true)
{
NetMQMessage message = await _router.ReceiveMultipartMessageAsync();
_logger.Debug($"Message received.[f-count: {message.FrameCount}]");
byte[] addr = message[0].ToByteArray();
var type = (MessageType)message[1].Buffer[0];
switch (type)
{
case MessageType.Ping:
_logger.Debug($"Ping received.");
NetMQMessage reply = CreateMessage(MessageType.Pong, addr);
await _router.SendMultipartMessageAsync(reply);
break;
case MessageType.PeerSetDelta:
byte[] payload = message[2].ToByteArray();
var(publicKey, msg) = VerifyMessage(payload);
using (var stream = new MemoryStream(msg))
{
var formatter = new BinaryFormatter();
_deltas.Enqueue((PeerSetDelta)formatter.Deserialize(stream));
}
break;
default:
_logger.Warning($"Can't recognize message type[{type}]. ignored.");
break;
}
}
}
//occurs on socket polling thread to assure sending and receiving on same thread
private void SendQueue_ReceiveReady(object sender, NetMQQueueEventArgs <NetMQMessage> e)
{
NetMQMessage message;
if (e.Queue.TryDequeue(out message, new TimeSpan(1000)))
{
try
{
_routerSocket.SendMultipartMessage(message);
_logger.Info("Message sent with {0} frames.", message.FrameCount);
}
catch (Exception ex) //clientId not found or other error, raise event
{
var unreachable = ex as HostUnreachableException;
_logger.Error("Error sending message to {0} with {1} frames.", new Guid(message.First.Buffer), message.FrameCount);
_sendFailureQueue.Enqueue(new MessageFailure
{
Message = message.ToMessageWithClientFrame(),
ErrorCode = null != unreachable ? unreachable.ErrorCode.ToString() : "Unknown",
ErrorMessage = ex.Message
});
}
}
}
public void WithPoller()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQQueue <int> queue = new NetMQQueue <int>(context))
{
Poller poller = new Poller();
poller.AddSocket(queue);
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
queue.ReceiveReady += (sender, args) =>
{
manualResetEvent.Set();
};
poller.PollTillCancelledNonBlocking();
Assert.IsFalse(manualResetEvent.WaitOne(100));
queue.Enqueue(1);
Assert.IsTrue(manualResetEvent.WaitOne(100));
poller.CancelAndJoin();
}
}
public void WithPoller()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQQueue<int> queue = new NetMQQueue<int>(context))
{
Poller poller = new Poller();
poller.AddSocket(queue);
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
queue.ReceiveReady += (sender, args) =>
{
manualResetEvent.Set();
};
poller.PollTillCancelledNonBlocking();
Assert.IsFalse(manualResetEvent.WaitOne(100));
queue.Enqueue(1);
Assert.IsTrue(manualResetEvent.WaitOne(100));
poller.CancelAndJoin();
}
}
protected void EnqueueMessage(NetMQMessage message)
{
MessageQueue.Enqueue(message);
}
private async Task ProcessMessageAsync <T>(
Blockchain <T> blockchain,
Message message,
CancellationToken cancellationToken)
where T : IAction
{
switch (message)
{
case Ping ping:
{
_logger.Debug($"Ping received.");
var reply = new Pong
{
Identity = ping.Identity,
};
await ReplyAsync(reply, cancellationToken);
break;
}
case Messages.PeerSetDelta peerSetDelta:
{
_deltas.Enqueue(peerSetDelta.Delta);
break;
}
case GetBlockHashes getBlockHashes:
{
IEnumerable <HashDigest <SHA256> > hashes =
blockchain.FindNextHashes(
getBlockHashes.Locator,
getBlockHashes.Stop,
500);
var reply = new BlockHashes(hashes)
{
Identity = getBlockHashes.Identity,
};
await ReplyAsync(reply, cancellationToken);
break;
}
case GetBlocks getBlocks:
{
await TransferBlocks(
blockchain, getBlocks, cancellationToken);
break;
}
case GetTxs getTxs:
{
await TransferTxs(
blockchain, getTxs, cancellationToken);
break;
}
case TxIds txIds:
{
await ProcessTxIds(
txIds, blockchain, cancellationToken);
break;
}
default:
Trace.Fail($"Can't handle message. [{message}]");
break;
}
}
protected override void HandleInvocation(IInvocation invocation) => Queue.Enqueue(invocation);
public void Enqueue(object evnt)
{
_queue.Enqueue(evnt);
}
static void Main(string[] args)
{
var proxy1 = new Proxy(new RouterSocket("@tcp://*:5001"), new DealerSocket("@tcp://*:5002"));
Task.Factory.StartNew(proxy1.Start);
var dealer = new DealerSocket(">tcp://127.0.0.1:5002");
var queue = new NetMQQueue <NetMQMessage>();
var poller = new NetMQPoller {
dealer, queue
};
var show = false;
dealer.ReceiveReady += (s, e) =>
{
var clientmessage = e.Socket.ReceiveMultipartMessage();
Task.Factory.StartNew((o) =>
{
var cmsg = (NetMQMessage)o;
var address = cmsg.First().ConvertToString();
var msg = cmsg.Last().ConvertToString() + "-OK";
var servermessage = new NetMQMessage(3);
servermessage.Append(address);//fortest
servermessage.AppendEmptyFrame();
servermessage.Append(msg);
//var r = random.NextDouble();
//if (r > 0 && r < 0.78)
//{
// Thread.Sleep(random.Next(1, 51));
//}
//else if (r >= 0.78 & r < 0.78 + 0.21)
//{
// Thread.Sleep(random.Next(51, 101));
//}
//else
//{
// Thread.Sleep(random.Next(101, 300));
//}
queue.Enqueue(servermessage);
//if (show)
// Console.WriteLine(msg);
}, clientmessage);
if (show)
{
Console.WriteLine(1);
}
};
queue.ReceiveReady += (s, e) =>
{
var msg = e.Queue.Dequeue();
dealer.SendMultipartMessage(msg);
};
poller.RunAsync();
//for (var i = 0; i < 5; i++)
//{
// Task.Factory.StartNew(() =>
// {
// while (true)
// {
// var servermessage = new NetMQMessage(3);
// servermessage.Append(Encoding.UTF8.GetBytes("dealerclient")); //for test
// servermessage.AppendEmptyFrame();
// servermessage.Append($"================={DateTime.Now.ToString()}======================");
// queue.Enqueue(servermessage);
// Thread.Sleep(1000);
// }
// });
//}
Console.WriteLine("Press any key to stop!");
Console.Read();
show = true;
Console.Read();
Console.Read();
Console.Read();
}
public void Start()
{
_frontend = new RouterSocket();
_backend = new RouterSocket();
_workQueue = new NetMQQueue <Work>();
_workerQueue = new NetMQQueue <Guid>();
_frontend.Bind(_frontendRouterEndpoint);
_backend.Bind(_backendRouterEndpoint);
_poller = new NetMQPoller {
_frontend, _backend, _workQueue, _workerQueue
};
_workQueue.ReceiveReady += (s, e) =>
{
if (_workerQueue.TryDequeue(out Guid worker, TimeSpan.FromMilliseconds(0)))
{
var work = e.Queue.Dequeue();
work.WorkerId = worker;
_backend.SendMoreFrame(worker.ToByteArray())
.SendMoreFrameEmpty()
.SendFrame(work.Serialize());
}
};
_workerQueue.ReceiveReady += (s, e) =>
{
if (_workQueue.TryDequeue(out Work work, TimeSpan.FromMilliseconds(0)))
{
var worker = e.Queue.Dequeue();
work.WorkerId = worker;
_backend.SendMoreFrame(worker.ToByteArray())
.SendMoreFrameEmpty()
.SendFrame(work.Serialize());
}
};
_frontend.ReceiveReady += (s, e) =>
{
var transportMessage = e.Socket.ReceiveMultipartMessage()
.GetMessageFromRouter <Work>();
var work = transportMessage.Message;
work.ClientId = new Guid(transportMessage.SenderId);
if (work.MessageType == MessageType.Ask)
{
_workQueue.Enqueue(work);
}
};
_backend.ReceiveReady += (s, e) =>
{
var transportMessage = e.Socket.ReceiveMultipartMessage()
.GetMessageFromRouter <Work>();
var work = transportMessage.Message;
if (work.MessageType == MessageType.Ready)
{
_workerQueue.Enqueue(new Guid(transportMessage.SenderId));
}
if (work.MessageType == MessageType.Finished)
{
_frontend.SendMoreFrame(work.ClientId.ToByteArray())
.SendMoreFrameEmpty()
.SendFrame(transportMessage.MessageBytes);
_workerQueue.Enqueue(new Guid(transportMessage.SenderId));
}
};
_poller.Run();
}
static void Main(string[] args)
{
Console.WriteLine("Press any key to start!");
Console.Read();
NetMQPoller Poller2 = new NetMQPoller();
NetMQQueue <int> Queue = new NetMQQueue <int>();
var index = 0;
var client = new DealerSocket(">tcp://127.0.0.1:5001");
prereceivecount = testcount;
new Thread(() =>
{
while (true)
{
Console.WriteLine($"send:{(sendcount) / 10}/s,receive:{(receivecount) / 10}/s");
sendcount = 0;
receivecount = 0;
Thread.Sleep(1000 * 10);
}
}).Start();
new Thread(() =>
{
while (true)
{
if (prereceivecount >= testcount)
{
prereceivecount = 0;
for (var i = 0; i < testcount; i++)
{
Queue.Enqueue(++index);
}
}
Thread.Sleep(0);
}
}).Start();
client.Options.Identity = Encoding.UTF8.GetBytes($"clientid-{Process.GetCurrentProcess().Id}");
client.ReceiveReady += (s, e) =>
{
e.Socket.ReceiveFrameBytes();
var msg = e.Socket.ReceiveFrameString();
//Console.WriteLine($"RECEIVE:{msg}");
receivecount++;
prereceivecount++;
};
Queue.ReceiveReady += (s, e) =>
{
var msg = e.Queue.Dequeue();
client.SendMoreFrameEmpty().SendFrame($"{Encoding.UTF8.GetString(client.Options.Identity)}-{msg}");
//Console.WriteLine($"SEND:{msg}");
sendcount++;
};
Poller2.Add(Queue);
Poller2.Add(client);
Poller2.RunAsync();
Console.WriteLine("Press any key to stop!");
Console.Read();
}
