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 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());
}
}
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 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 virtual void Setup(INetManager netManager)
{
if (string.IsNullOrEmpty(PushsocketString))
{
throw new ArgumentNullException(nameof(PushsocketString));
}
if (string.IsNullOrEmpty(PullSocketString))
{
throw new ArgumentNullException(nameof(PullSocketString));
}
if (netManager == null)
{
throw new ArgumentNullException(nameof(netManager));
}
if (!string.IsNullOrEmpty(XPubSocketString) && !string.IsNullOrEmpty(XSubSocketString))
{
var PublisherSocket = new XPublisherSocket(XPubSocketString);
var SubscriberSocket = new XSubscriberSocket(XSubSocketString);
GlobalServerProxy = new Proxy(SubscriberSocket, PublisherSocket);
}
sender = new PushSocket(PushsocketString);
responseSocket = new PullSocket(PullSocketString);
Poller = new NetMQPoller()
{
sender,
responseSocket,
PushQueue
};
NetSend = netManager;
PushQueue.ReceiveReady += (o, args) =>
{
var msg = PushQueue.Dequeue();
sender.SendMultipartMessage(msg);
};
responseSocket.ReceiveReady += ProcessResponse;
IsSetuped = 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));
}
}
private void OnOutgoingQueueReady(object sender, NetMQQueueEventArgs <OutgoingMessage> e)
{
var outgoingMessage = m_outgoingQueue.Dequeue();
//var bodySegment = m_serializer.Serialize(outgoingMessage.Message);
//byte[] body = new byte[bodySegment.Count];
//Buffer.BlockCopy(bodySegment.Array, bodySegment.Offset, body, 0, bodySegment.Count);
UInt64 messageId = ++m_nextMessageId;
m_nextMessageId = messageId;
//string subject = m_serializer.GetObjectSubject(outgoingMessage.Message);
//Console.WriteLine("Codec.Message.RelatedMessageId: " + messageId + " ; " + Codec.Error.RelatedMessageId);
Codec.Id = Codec.MessageId.Message;
Codec.Message.MessageId = messageId;
Codec.Message.Service = outgoingMessage.Service;
Codec.Message.Subject = "";
Codec.Message.Body = outgoingMessage.Message;
Codec.Message.RelatedMessageId = 0;
// one way message
if (outgoingMessage.Oneway)
{
Codec.Message.OneWay = 1;
}
else
{
Codec.Message.OneWay = 0;
// add to pending requests dictionary
// TODO: we might want to create a pending message structure that will not hold reference to the message (can lead to GC second generation)
var msg = new PendingMessage(messageId, outgoingMessage.TaskCompletionSource);
m_pendingRequests.Add(messageId, msg);
GC.KeepAlive(msg);
GC.KeepAlive(outgoingMessage);
}
Codec.Send(m_clientSocket);
}
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 <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();
}
}
