/// <summary>
/// Create new client
/// </summary>
/// <param name="serializer">Serialize to to use to serialize the message to byte array</param>
/// <param name="address">Address of the server</param>
public Client(ISerializer serializer, string address)
{
this.Serializer = serializer;
this.Address = address;
m_outgoingQueue = new NetMQQueue <ClientEngine.OutgoingMessage>();
Engine = new ClientEngine(Serializer, m_outgoingQueue, Address);
}
public LogCollectService(ILogRepository logRepository, IAppConfiguration config)
{
this.logRepository = logRepository;
queue = new NetMQQueue <RawLogData>();
poller = new NetMQPoller
{
queue
};
queue.ReceiveReady += (sender, args) =>
{
var item = queue.Dequeue();
var lst = new List <RawLogData>
{
item
};
if (config.BatchSizeToIndex > 1)
{
for (int i = 0; i < config.BatchSizeToIndex; ++i)
{
if (queue.TryDequeue(out RawLogData outData, new TimeSpan(10)) == false)
{
break; //no more items in the Queue so we''ll make the system wait for the Queue
}
lst.Add(outData);
}
}
Thread.Sleep(1000);
ProcessLogFromQueue(lst);
};
poller.RunAsync();
}
public Swarm(
PrivateKey privateKey,
Uri listenUrl,
TimeSpan?dialTimeout = null,
DateTime?createdAt = null)
{
_privateKey = privateKey;
_listenUrl = listenUrl;
_dialTimeout = dialTimeout ?? TimeSpan.FromMilliseconds(15000);
_peers = new Dictionary <Peer, DateTime>();
_removedPeers = new Dictionary <Peer, DateTime>();
LastSeenTimestamps = new Dictionary <Peer, DateTime>();
DateTime now = createdAt.GetValueOrDefault(DateTime.UtcNow);
LastDistributed = now;
LastReceived = now;
DeltaDistributed = new AsyncManualResetEvent();
DeltaReceived = new AsyncManualResetEvent();
TxReceived = new AsyncAutoResetEvent();
_dealers = new Dictionary <Address, DealerSocket>();
_router = new RouterSocket();
_deltas = new NetMQQueue <PeerSetDelta>();
_distributeMutex = new AsyncLock();
_receiveMutex = new AsyncLock();
_logger = Log.ForContext <Swarm>()
.ForContext("Swarm_listenUrl", _listenUrl.ToString());
_contextInitialized = false;
}
static void Main(string[] args)
{
Console.WriteLine("Press any key to start!");
Console.Read();
NetMQPoller Poller2 = new NetMQPoller();
NetMQQueue <int> Queue = new NetMQQueue <int>();
for (var i = 0; i < 10; i++)
{
Task.Factory.StartNew((o) =>
{
using (var req = new RequestSocket(">tcp://127.0.0.1:5001"))
{
if (req.TrySendFrame(TimeSpan.FromSeconds(1), $"task:{o}"))
{
var msg = req.ReceiveFrameString();
Console.WriteLine(msg);
}
else
{
Console.WriteLine($"task:{i} timeout!");
}
}
}, i);
}
Console.WriteLine("Press any key to stop!");
Console.Read();
Console.Read();
}
public ClientEngine(ISerializer serializer, NetMQQueue <OutgoingMessage> outgoingQueue, string address)
{
m_serializer = serializer;
m_outgoingQueue = outgoingQueue;
m_address = address;
m_pendingRequests = new Dictionary <ulong, PendingMessage>();
m_nextMessageId = 0;
}
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 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());
}
}
/// <summary>
/// Client constructor.
/// </summary>
/// <param name="connectionString">Valid NetMQ client socket connection string.</param>
/// <param name="identity">Client identifier passed to the server in Zero Knowledge authentication.
/// Null for unsecured hosts.</param>
/// <param name="identityKey">Secret key used by NOT passed to the server in Zero Knowledge authentication
/// but used in memory to validate authentication of the server. Null for
/// unsecured hosts</param>
/// <param name="logger">ILogger implementation for logging operations. Null is replaced with NullLogger.</param>
/// <param name="stats">IStats implementation for logging perf metrics. Null is replaced with NullStats.</param>
/// <param name="heartBeatIntervalMs">Number of milliseconds between client sending heartbeat message to the server.
/// Default 30,000 (30 seconds). Min is 1000 (1 second) and max is 600,000 (10 mins).</param>
/// <param name="maxSkippedHeartBeatReplies">Maximum heartbeat intervals skipped without a heartbeat reply
/// from the server before the client begins throwing on Send and returns false for the IsHostAlive property.
/// Default is 3. Min is 1 and max is 10.</param>
public Client(string connectionString, string identity = null, string identityKey = null,
ILog logger = null, IStats stats = null,
int heartBeatIntervalMs = 30000, int maxSkippedHeartBeatReplies = 3)
{
_identity = identity;
_identityKey = identityKey;
_connectionString = connectionString;
_logger = logger ?? new NullLogger();
_stats = stats ?? new NullStats();
_heartBeatMs = (heartBeatIntervalMs < 1000)
? 1000
: (heartBeatIntervalMs > 600000) ? 600000 : heartBeatIntervalMs;
_maxSkippedHeartBeatReplies = (maxSkippedHeartBeatReplies < 1)
? 1
: (maxSkippedHeartBeatReplies > 10) ? 10 : maxSkippedHeartBeatReplies;
_clientId = Guid.NewGuid();
_clientIdBytes = _clientId.ToByteArray();
_sendQueue = new NetMQQueue <List <byte[]> >();
_dealerSocket = new DealerSocket(_connectionString);
_dealerSocket.Options.Identity = _clientIdBytes;
_sendQueue.ReceiveReady += SendQueue_ReceiveReady;
_dealerSocket.ReceiveReady += DealerSocket_ReceiveReady;
_socketPoller = new NetMQPoller {
_dealerSocket, _sendQueue
};
_socketPoller.RunAsync();
_receiveQueue = new NetMQQueue <List <byte[]> >();
_receiveQueue.ReceiveReady += ReceivedQueue_ReceiveReady;
if (null != _identity && null != _identityKey)
{
_throwOnSend = true;
_heartBeatTimer = new NetMQTimer(_heartBeatMs);
_heartBeatTimer.Elapsed += HeartBeatTimer_Elapsed;
_clientPoller = new NetMQPoller {
_receiveQueue, _heartBeatTimer
};
_heartBeatTimer.Enable = true;
_logger.Debug("Client created with protocol enabled.");
}
else
{
_clientPoller = new NetMQPoller {
_receiveQueue
};
_logger.Debug("Client created. Protocol NOT enabled.");
}
_clientPoller.RunAsync();
}
/// <summary>
/// Host constructor. Supply an IZkRepository to enable Zero Knowledge authentication and encryption.
/// </summary>
/// <param name="connectionString">Valid NetMQ server socket connection string.</param>
/// <param name="authRepository">External authentication repository. Null creates host with no encryption.</param>
/// <param name="logger">ILogger implementation for logging operations. Null is replaced with NullLogger.</param>
/// <param name="stats">IStats implementation for logging perf metrics. Null is replaced with NullStats.</param>
/// <param name="sessionTimeoutMins">Session timout check interval. If no heartbeats or messages
/// received on a given session in this period of time, the session will be removed from memory
/// and futher attempts from the client will fail. Default is 20 minutes. Min is 1 and Max is 3600.</param>
public Host(string connectionString, IKeyRepository authRepository = null,
ILog logger = null, IStats stats = null, int sessionTimeoutMins = 20)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException("Connection string cannot be null.", nameof(connectionString));
}
_connectionString = connectionString;
_logger = logger ?? new NullLogger();
_stats = stats ?? new NullStats();
//enforce min and max session check
_sessionTimeoutMins = (sessionTimeoutMins < 1)
? 1
: (sessionTimeoutMins > 3600) ? 3600 : sessionTimeoutMins;
_authRepository = authRepository;
_sessions = new ConcurrentDictionary <Guid, HostSession>();
_sendQueue = new NetMQQueue <NetMQMessage>();
_routerSocket = new RouterSocket(_connectionString);
_routerSocket.Options.RouterMandatory = true;
_sendQueue.ReceiveReady += SendQueue_ReceiveReady;
_routerSocket.ReceiveReady += RouterSocket_ReceiveReady;
_socketPoller = new NetMQPoller {
_routerSocket, _sendQueue
};
_socketPoller.RunAsync();
_sendFailureQueue = new NetMQQueue <MessageFailure>();
_receivedQueue = new NetMQQueue <Message>();
_sendFailureQueue.ReceiveReady += SendFailureQueue_ReceiveReady;
_receivedQueue.ReceiveReady += ReceivedQueue_ReceiveReady;
if (null == _authRepository)
{
_hostPoller = new NetMQPoller {
_receivedQueue, _sendFailureQueue
};
_logger.Debug("Hoste created. Protocol NOT enabled.");
}
else
{
_sessionCleanupTimer = new NetMQTimer(new TimeSpan(0, _sessionTimeoutMins, 0));
_sessionCleanupTimer.Elapsed += SessionCleanupTimer_Elapsed;
_hostPoller = new NetMQPoller {
_receivedQueue, _sendFailureQueue, _sessionCleanupTimer
};
_sessionCleanupTimer.Enable = true;
_logger.Debug("Host created with protocol enabled.");
}
_hostPoller.RunAsync();
}
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 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 ZeroMqPublisher()
{
_pubSocket = new PublisherSocket();
_pubSocket.Options.SendHighWatermark = 10;
_pubSocket.Options.DelayAttachOnConnect = true;
_queue = new NetMQQueue <object>(10);
_queue.ReceiveReady += (sender, args) => Publish(_queue.Dequeue());
_poller = new NetMQPoller {
_queue
};
}
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);
}
}
/// <summary>
/// Creates a new instance of the <see cref="DualSocketBusPublisher"/> type.
/// </summary>
/// <param name="messageBusEndpoint"> The subscribed message bus' endpoint. </param>
/// <param name="dispatcher"> The dispatcher that is used for outgoing messages from the subscibed bus. </param>
public DualSocketBusPublisher(
IDualSocketEndpoint messageBusEndpoint,
ISocketDispatcherThread dispatcher)
{
Dispatcher = dispatcher;
MessageBusEndpoint = messageBusEndpoint;
OutgoingMessages = new Lazy <PublisherSocket>(() =>
{
var socket = new PublisherSocket();
socket.Connect(MessageBusEndpoint.Incoming);
return(socket);
}, true);
OutgoingMessageQueue = new Lazy <NetMQQueue <NetMQMessage> >(() =>
{
var queue = new NetMQQueue <NetMQMessage>();
queue.ReceiveReady += OnMessageQueued;
return(queue);
}, true);
}
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>
/// create worker with standard parameter
/// HeartbeatDelay == 2500 milliseconds
/// ReconnectDelay == 2500 milliseconds
/// ConnectionRetries == 3
/// Verbose == false
/// </summary>
private MDPWorker()
{
HeartbeatDelay = TimeSpan.FromMilliseconds(2500);
ReconnectDelay = TimeSpan.FromMilliseconds(2500);
m_timer = new NetMQTimer(HeartbeatDelay);
m_timer.Enable = false;
m_timer.Elapsed += (s, e) => OnHeartbeat();
m_pollerQueue = new NetMQQueue <Action>();
m_pollerQueue.ReceiveReady += (sender, args) =>
{
var action = args.Queue.Dequeue();
action.Invoke();
};
m_poller = new NetMQPoller();
m_poller.Add(m_pollerQueue);
m_poller.Add(m_timer);
m_poller.RunAsync();
}
/// <summary>
/// create worker with standard parameter
/// HeartbeatDelay == 2500 milliseconds
/// ReconnectDelay == 2500 milliseconds
/// ConnectionRetries == 3
/// Verbose == false
/// </summary>
private MDPWorker()
{
HeartbeatDelay = TimeSpan.FromMilliseconds(2500);
ReconnectDelay = TimeSpan.FromMilliseconds(2500);
m_timer = new NetMQTimer(HeartbeatDelay);
m_timer.Enable = false;
m_timer.Elapsed += (s, e) => OnHeartbeat();
m_pollerQueue = new NetMQQueue<Action>();
m_pollerQueue.ReceiveReady += (sender, args) =>
{
var action = args.Queue.Dequeue();
action.Invoke();
};
m_poller = new NetMQPoller();
m_poller.Add(m_pollerQueue);
m_poller.Add(m_timer);
m_poller.RunAsync();
}
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();
}
}
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>
/// setup the client with standard values
/// verbose == false
/// Connect the client to broker
/// </summary>
private MDPClientAsync()
{
m_client = null;
m_connected = false;
m_currentBrokerIndex = -1; // TODO use random!?
m_pollerQueue = new NetMQQueue <Action>();
m_pollerQueue.ReceiveReady += (sender, args) => OnAction(args);
m_requestQueue = new RequestsQueue();
m_requestQueue.FailedRequest += (s, e) => OnFailedRequest(e);
m_poller = new NetMQPoller();
Timeout = m_defaultTimeOut;
m_timer = new NetMQTimer(m_purgeCheckTime);
m_timer.Enable = false;
m_timer.Elapsed += (s, e) => OnPurgeRequest();
m_poller.Add(m_timer);
m_poller.Add(m_pollerQueue);
m_poller.Add(m_timer);
m_poller.RunAsync();
}
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();
}
}
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();
}
/// <summary>
/// setup the client with standard values
/// verbose == false
/// Connect the client to broker
/// </summary>
private MDPClientAsync()
{
m_client = null;
m_connected = false;
m_currentBrokerIndex = -1; // TODO use random!?
m_pollerQueue = new NetMQQueue<Action>();
m_pollerQueue.ReceiveReady += (sender, args) => OnAction(args);
m_requestQueue = new RequestsQueue();
m_requestQueue.FailedRequest += (s, e) => OnFailedRequest(e);
m_poller = new NetMQPoller();
Timeout = m_defaultTimeOut;
m_timer = new NetMQTimer(m_purgeCheckTime);
m_timer.Enable = false;
m_timer.Elapsed += (s, e) => OnPurgeRequest();
m_poller.Add(m_timer);
m_poller.Add(m_pollerQueue);
m_poller.Add(m_timer);
m_poller.RunAsync();
}
public ClientSafeEngine(ISerializer serializer, NetMQQueue <OutgoingMessage> outgoingQueue, string address, TaskCompletionSource <object> source)
: base(serializer, outgoingQueue, address) =>
this.source = source;
/// <summary>
/// Create new client
/// </summary>
/// <param name="serializer">Serialize to to use to serialize the message to byte array</param>
/// <param name="address">Address of the server</param>
public Client(ISerializer serializer, string address)
{
m_outgoingQueue = new NetMQQueue<ClientEngine.OutgoingMessage>();
m_actor = NetMQActor.Create(new ClientEngine(serializer, m_outgoingQueue, address));
}
public PublisherService() : base(new PublisherSocket())
{
Queue = new NetMQQueue <IInvocation>();
Poller.Add(Queue);
Queue.ReceiveReady += Queue_ReceiveReady;
}
/// <summary>
/// Create new client
/// </summary>
/// <param name="serializer">Serialize to to use to serialize the message to byte array</param>
/// <param name="address">Address of the server</param>
public Client(ISerializer serializer, string address)
{
m_outgoingQueue = new NetMQQueue <ClientEngine.OutgoingMessage>();
m_actor = NetMQActor.Create(new ClientEngine(serializer, m_outgoingQueue, address));
}
private async Task Handler()
{
while (this.IsRunning)
{
try
{
bool isListening = false;
var connectionString = this.FrontendEndpoint.ToConnectionString();
using (var frontendSocket = new RouterSocket())
using (this.FrontendBuffer = new NetMQQueue <TransportMessage>())
using (var poller = new NetMQPoller()
{
frontendSocket, this.FrontendBuffer
})
using (var monitor = new NetMQ.Monitoring.NetMQMonitor(frontendSocket, $"inproc://monitor.forwarderdevice.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Accepted | SocketEvents.Disconnected | SocketEvents.Closed))
{
frontendSocket.ReceiveReady += (sender, e) =>
{
try
{
var netmqMessage = new NetMQMessage();
while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
{
var message = netmqMessage.ToMessage(out var envelope);
string serviceIdentifier = message.Metadata.TryGetLast("serviceIdentifier", out var encodedService) ? Encoding.UTF8.GetString(encodedService) : null;
try
{
var cancellationSource = new CancellationTokenSource(5000);
var registeredBackend = this.ResolveBackend(serviceIdentifier, cancellationSource.Token);
//var registeredBackend = this.InprocTransportScope.GetNextServerTransport(serviceIdentifier, cancellationSource.Token);
message.Metadata.Add($"envelope[{this.Identity}]", envelope);
//registeredBackend.ReceiveBuffer.QueueMessage(message);
registeredBackend.Send(message).ContinueWith(task =>
{
this.OnDiagnosticMessage($"Failed to forward to backend [{task.Exception.InnerException.Message}]");
}, TaskContinuationOptions.OnlyOnFaulted);
}
catch (OperationCanceledException)
{
this.OnDiagnosticMessage($"No backends available for {serviceIdentifier}!!!");
var nmqm = MessageHelpers.CreateNetMQErrorMessage(envelope, "No backends found", message.Metadata);
e.Socket.SendMultipartMessage(nmqm);
}
}
}
catch (Exception ex)
{
this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
}
};
this.FrontendBuffer.ReceiveReady += (sender, e) =>
{
try
{
while (this.FrontendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
{
if (!message.Metadata.TryPluckLast($"envelope[{this.Identity}]", out var envelope))
{
throw new Exception("Message envelope not found");
}
if (!frontendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope)))
{
this.OnDiagnosticMessage("Failed to forward to frontend");
}
}
}
catch (Exception ex)
{
this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
}
};
monitor.Listening += (sender, e) =>
{
this.OnDiagnosticMessage($"Frontend router socket listening at {connectionString}");
isListening = true;
};
monitor.Closed += (sender, e) =>
{
this.OnDiagnosticMessage($"Frontend router socket closed on {connectionString}");
isListening = false;
};
monitor.Accepted += (sender, e) =>
{
this.OnDiagnosticMessage($"Frontend router socket connection accepted at {connectionString}");
};
monitor.Disconnected += (sender, e) =>
{
this.OnDiagnosticMessage($"Frontend router socket disconnected at {connectionString}");
};
this.OnDiagnosticMessage($"Attempting to bind frontend socket to {connectionString}");
monitor.StartAsync();
monitor.AttachToPoller(poller);
var pollerTask = new Task(poller.Run);
pollerTask.ContinueWith(task =>
{
var ex = task.Exception;
this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
isListening = false;
}, TaskContinuationOptions.OnlyOnFaulted);
pollerTask.Start();
frontendSocket.Bind(connectionString);
var start = DateTime.Now;
while (!isListening)
{
if ((DateTime.Now - start).TotalMilliseconds > 5000)
{
throw new Exception($"Frontend socket bind timeout ({connectionString})");
}
await Task.Delay(1000);
}
while (this.IsRunning && isListening)
{
await Task.Delay(1000);
}
poller.StopAsync();
frontendSocket.Disconnect(connectionString);
monitor.DetachFromPoller();
monitor.Stop();
}
}
catch (Exception ex)
{
this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
}
}
}
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();
}
public async Task <bool> RunSimulationAsync(Options options, TextWriter logger, CancellationToken token = default)
{
Logger = logger;
try {
Id = options.Id;
_socket = new DealerSocket();
_socket.Options.Linger = TimeSpan.FromSeconds(30);
_socket.Options.Identity = Encoding.ASCII.GetBytes(Id);
if (options.Connect)
{
_socket.Connect(options.URL);
}
else
{
_socket.Bind(options.URL);
}
using (Outgoing = new NetMQQueue <NetMQMessage>()) {
using var poller = new NetMQPoller()
{
_socket, Outgoing
};
_socket.ReceiveReady += (sender, e) => {
var msg = _socket.ReceiveMultipartMessage();
if (msg.FrameCount < 3)
{
logger.WriteLine($"Received message with only {msg.FrameCount} frames.");
return;
}
var type = msg[1].ConvertToString();
logger.WriteLine($"Received {type} message.");
switch (type)
{
case "crane":
OnCraneMessageReceived(msg[2].Buffer);
break;
case "sim":
OnSimMessageReceived(msg[2].Buffer);
break;
default: //Console.WriteLine($"Received message with unmapped type {type}");
break;
}
};
Outgoing.ReceiveReady += (sender, e) => {
var msg = Outgoing.Dequeue();
if (_socket.TrySendMultipartMessage(TimeSpan.FromMinutes(1), msg)) // Note that for policyruns (virtual time) a lot of events are generated
{
logger.WriteLine($"Sent {msg[1].ConvertToString()} message.");
}
//else logger.WriteLine($"Discarded outgoing {msg[1].ConvertToString()} message.");
};
if (!options.RunSync || options.Connect)
{
poller.RunAsync();
}
if (!string.IsNullOrEmpty(options.SettingsPath))
{
if (options.SettingsPath.Equals("Default", StringComparison.OrdinalIgnoreCase))
{
logger.WriteLine("Using default settings");
_settingsReceived.SetResult(GetDefaultSettings());
}
else
{
logger.WriteLine($"Reading settings from {options.SettingsPath}");
_settingsReceived.SetResult(File.ReadAllBytes(options.SettingsPath));
}
}
var result = false;
try {
if (!options.RunSync)
{
result = await RunSimulationAsync(await _settingsReceived.Task, options.PolicyRun);
// wait until the outgoing queue is cleared
var remaining = Outgoing.Count;
while (remaining > 0)
{
await Task.Delay(1000, token);
if (Outgoing.Count == remaining)
{
break; // assume nobody is listening for world states
}
remaining = Outgoing.Count;
}
}
else
{
result = RunSimulation(await _settingsReceived.Task, options.SyncURL, options.Id);
}
} finally {
poller.Stop();
}
return(result);
}
} finally {
DisposeSocket();
}
}
private async Task Handler()
{
while (this.IsRunning)
{
try
{
bool isListening = false;
var connectionString = this.FrontendEndpoint.ToConnectionString();
using (var frontendSocket = new RouterSocket())
using (this.frontendBuffer = new NetMQQueue <TransportMessage>())
using (var poller = new NetMQPoller()
{
frontendSocket, this.frontendBuffer
})
using (var monitor = new NetMQ.Monitoring.NetMQMonitor(frontendSocket, $"inproc://monitor.forwarderdevice.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Accepted | SocketEvents.Disconnected | SocketEvents.Closed))
{
frontendSocket.ReceiveReady += (sender, e) =>
{
try
{
var netmqMessage = new NetMQMessage();
while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
{
var message = netmqMessage.ToMessage(out var envelope);
//var sourceEnvelope = message.Envelope;
this.OnFrontendReceived(message);
var forwardStart = DateTime.UtcNow;
RegisteredBackend registeredBackend = null;
while (this.IsRunning && registeredBackend == null)
{
while (this.backendEndpointIds.TryDequeue(out string backendIdentifier))
{
if (this.backendEndpoints.TryGetValue(backendIdentifier, out RegisteredBackend candidateBackend))
{
this.backendEndpointIds.Enqueue(backendIdentifier);
if (candidateBackend.IsConnected)
{
registeredBackend = this.backendEndpoints[backendIdentifier];
break;
}
}
//if ((DateTime.UtcNow - registeredBackend.RegisteredDate).TotalMilliseconds < 10000)
//{
// this.backendEndpointIds.Enqueue(backendIdentifier);
// break;
//}
//else
//{
// if (this.backendEndpoints.TryRemove(backendIdentifier, out RegisteredBackend expiredBackend))
// {
// Console.WriteLine($"Backend {backendIdentifier} expired");
// expiredBackend.Close().ContinueWith((result) =>
// {
// Console.WriteLine($"Backend {backendIdentifier} closed");
// });
// }
//}
}
if (registeredBackend != null || (DateTime.Now - forwardStart).TotalMilliseconds > 30000)
{
break;
}
System.Threading.Thread.Sleep(100);
}
if (registeredBackend != null)
{
message.Metadata.Add($"envelope[{this.Identity}]", envelope);
registeredBackend.BackendBuffer.Enqueue(message);
}
else
{
Console.WriteLine("No backends available!!!");
var nmqm = MessageHelpers.CreateNetMQErrorMessage(envelope, "No backends found", message.Metadata);
e.Socket.SendMultipartMessage(nmqm);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}
};
this.frontendBuffer.ReceiveReady += (sender, e) =>
{
try
{
while (this.frontendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
{
if (!message.Metadata.TryPluck($"envelope[{this.Identity}]", out var envelope))
{
throw new Exception("Message envelope not found");
}
this.OnBackendForwarded(message);
if (!frontendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope)))
{
Console.WriteLine("Failed to forward to frontend");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}
};
monitor.Listening += (sender, e) =>
{
Console.WriteLine($"Frontend router socket listening at {connectionString}");
isListening = true;
};
monitor.Closed += (sender, e) =>
{
Console.WriteLine($"Frontend router socket closed on {connectionString}");
isListening = false;
};
monitor.Accepted += (sender, e) =>
{
Console.WriteLine($"Frontend router socket connection accepted at {connectionString}");
};
monitor.Disconnected += (sender, e) =>
{
Console.WriteLine($"Frontend router socket disconnected at {connectionString}");
};
Console.WriteLine($"Attempting to bind frontend socket to {connectionString}");
monitor.StartAsync();
monitor.AttachToPoller(poller);
var pollerTask = new Task(poller.Run);
pollerTask.ContinueWith((Task task) =>
{
var ex = task.Exception;
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
isListening = false;
}, TaskContinuationOptions.OnlyOnFaulted);
pollerTask.Start();
frontendSocket.Bind(connectionString);
var start = DateTime.Now;
while (!isListening)
{
if ((DateTime.Now - start).TotalMilliseconds > 5000)
{
throw new Exception($"Frontend socket bind timeout ({connectionString})");
}
await Task.Delay(1000);
}
while (this.IsRunning && isListening)
{
await Task.Delay(1000);
}
poller.StopAsync();
frontendSocket.Disconnect(connectionString);
monitor.DetachFromPoller();
monitor.Stop();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}
}
}
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 XplaneConnectionManager(IEventBroker broker, IAppConfig config, IFsdManger fsdManager) : base(broker)
{
DealerSocket visualDealerSocket = null;
mVisualDealerSockets = null;
mConfig = config;
mFsdManager = fsdManager;
if (mConfig.VisualClientIPs.Count > 0)
{
foreach (string mIP in mConfig.VisualClientIPs)
{
visualDealerSocket = new DealerSocket();
visualDealerSocket.Options.Identity = Encoding.UTF8.GetBytes("CLIENT");
visualDealerSocket.Options.TcpKeepalive = true;
try
{
visualDealerSocket.Connect("tcp://" + mIP + ":" + mConfig.TcpPort);
if (mVisualDealerSockets == null)
{
mVisualDealerSockets = new List <DealerSocket>();
}
mVisualDealerSockets.Add(visualDealerSocket);
}
catch (AddressAlreadyInUseException)
{
NotificationPosted?.Invoke(this, new NotificationPostedEventArgs(NotificationType.Error, "Plugin port already in use. Please choose a different TCP port."));
}
}
}
if (!string.IsNullOrEmpty(mConfig.SimClientIP))
{
mSimulatorIP = mConfig.SimClientIP;
}
mMessageQueue = new NetMQQueue <string>();
mDealerSocket = new DealerSocket();
mDealerSocket.Options.TcpKeepalive = true;
mDealerSocket.Options.Identity = Encoding.UTF8.GetBytes("CLIENT");
mDealerSocket.ReceiveReady += DealerSocket_ReceiveReady;
try
{
mDealerSocket.Connect("tcp://" + mSimulatorIP + ":" + mConfig.TcpPort);
}
catch (AddressAlreadyInUseException)
{
NotificationPosted?.Invoke(this, new NotificationPostedEventArgs(NotificationType.Error, "Plugin port already in use. Please choose a different TCP port."));
}
mPoller = new NetMQPoller {
mDealerSocket, mMessageQueue
};
if (!mPoller.IsRunning)
{
mPoller.RunAsync();
}
mMessageQueue.ReceiveReady += (s, e) =>
{
if (mMessageQueue.TryDequeue(out string msg, TimeSpan.FromMilliseconds(100)))
{
if (mDealerSocket != null)
{
mDealerSocket.SendFrame(msg);
}
if (mVisualDealerSockets != null && mVisualDealerSockets.Count > 0)
{
foreach (DealerSocket socket in mVisualDealerSockets)
{
socket.SendFrame(msg);
}
}
}
};
mXplaneConnector = new XPlaneConnector.XPlaneConnector(mSimulatorIP);
mUserAircraftData = new UserAircraftData();
mRadioStackState = new UserAircraftRadioStack();
mGetXplaneDataTimer = new Timer
{
Interval = 10
};
mGetXplaneDataTimer.Tick += GetXplaneDataTimer_Tick;
mGetXplaneDataTimer.Start();
mConnectionTimer = new Timer
{
Interval = 50
};
mConnectionTimer.Tick += ConnectionTimer_Tick;
mConnectionTimer.Start();
mRetryConnectionTimer = new Timer
{
Interval = 1000
};
mRetryConnectionTimer.Tick += RetryConnectionTimer_Tick;
mRetryConnectionTimer.Start();
mWhosOnlineListRefresh = new Timer
{
Interval = 5000
};
mWhosOnlineListRefresh.Tick += WhosOnlineListRefresh_Tick;
SetupSubscribers();
if (!Directory.Exists(Path.Combine(mConfig.AppPath, "PluginLogs")))
{
Directory.CreateDirectory(Path.Combine(mConfig.AppPath, "PluginLogs"));
}
var directory = new DirectoryInfo(Path.Combine(mConfig.AppPath, "PluginLogs"));
var query = directory.GetFiles("*", SearchOption.AllDirectories);
foreach (var file in query.OrderByDescending(file => file.CreationTime).Skip(10))
{
file.Delete();
}
mRawDataStream = new StreamWriter(Path.Combine(mConfig.AppPath, string.Format($"PluginLogs/PluginLog-{DateTime.UtcNow:yyyyMMddHHmmss}.log")), false);
}
private async Task BackendHandler()
{
while (this.IsRunning)
{
try
{
while (this.RegisteredBackendIdentifiers.TryDequeue(out string identifier))
{
}
bool isListening = false;
var connectionString = this.BackendEndpoint.ToConnectionString();
using (var backendSocket = new RouterSocket())
using (this.AltBackendBuffer = new NetMQQueue <TransportMessage>())
using (var poller = new NetMQPoller()
{
backendSocket, this.AltBackendBuffer
})
using (var monitor = new NetMQ.Monitoring.NetMQMonitor(backendSocket, $"inproc://monitor.routerdevice.backend.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Disconnected | SocketEvents.Closed | SocketEvents.BindFailed))
{
backendSocket.ReceiveReady += (sender, e) =>
{
try
{
//Console.WriteLine("Backend message received");
//Console.WriteLine($"RECEIVED BACKEND ({this.BackendSocket.HasIn}) ({this.BackendSocket.HasOut})");
var netmqMessage = new NetMQMessage();
while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
{
var message = netmqMessage.ToMessage(out var envelope);
this.OnBackendReceived(message);
//this.BackendBuffer.Enqueue(message);
if (message.Metadata.TryPluck("Greeting", out var encodedGreeting))
{
var identifier = BitConverter.ToString(envelope);
if (this.RegisteredBackends.TryAdd(identifier, new RegisteredBackend(envelope, DateTime.UtcNow)))
{
Console.WriteLine($"Backend registered [ {identifier} ]");
this.RegisteredBackendIdentifiers.Enqueue(identifier);
}
else
{
this.RegisteredBackends[identifier].RegsiteredDate = DateTime.UtcNow;
}
}
else
{
this.AltFrontendBuffer.Enqueue(message);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}
};
//var lastFlushed = DateTime.UtcNow;
//backendSocket.SendReady += (sender, e) =>
//{
// try
// {
// if (!this.FrontendBuffer.IsEmpty)
// {
// while (this.FrontendBuffer.TryDequeue(out Message message))
// {
// Console.WriteLine("Frontend forwarding");
// if (!e.Socket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(true)))
// {
// Console.WriteLine("Failed to forward to backend");
// //var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope);
// //this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true));
// }
// }
// lastFlushed = DateTime.UtcNow;
// }
// if ((DateTime.UtcNow - lastFlushed).TotalSeconds > 1)
// Task.Delay(1).Wait();
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex.Message + ": " + ex.StackTrace);
// }
//};
this.AltBackendBuffer.ReceiveReady += (sender, e) =>
{
try
{
while (this.AltBackendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
{
if (!message.Metadata.TryPluck($"backendEnvelope[{this.Identity}]", out var envelope))
{
throw new Exception("Message backend envelope not found");
}
this.OnFrontendForwarded(message);
if (!backendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope)))
{
Console.WriteLine("Failed to forward to backend");
//var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope);
//this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}
};
monitor.Listening += (sender, e) =>
{
Console.WriteLine($"Backend router socket listening at {connectionString}");
isListening = true;
};
monitor.Closed += (sender, e) =>
{
Console.WriteLine($"Backend router socket accepted connection on {connectionString}");
isListening = false;
};
monitor.Disconnected += (sender, e) =>
{
Console.WriteLine($"Backend router socket disconnected at {connectionString}");
};
monitor.BindFailed += (sender, e) =>
{
Console.WriteLine($"Backend router bind failed {connectionString}");
};
Console.WriteLine($"Attempting to bind backend socket to {connectionString}");
monitor.StartAsync();
monitor.AttachToPoller(poller);
var pollerTask = new Task(poller.Run);
pollerTask.ContinueWith((Task task) =>
{
var ex = task.Exception;
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
isListening = false;
}, TaskContinuationOptions.OnlyOnFaulted);
pollerTask.Start();
backendSocket.Bind(connectionString);
var start = DateTime.Now;
while (!isListening)
{
if ((DateTime.Now - start).TotalMilliseconds > 5000)
{
throw new Exception($"Backend socket bind timeout ({connectionString})");
}
await Task.Delay(1000);
}
while (this.IsRunning && isListening)
{
if (this.BackendAnnouncer != null)
{
//Console.WriteLine("Registering backend");
await this.BackendAnnouncer.Register(this.BackendEndpoint);
}
await Task.Delay(1000);
}
poller.StopAsync();
backendSocket.Disconnect(connectionString);
monitor.DetachFromPoller();
monitor.Stop();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
}
}
}
