public void ContinueWith()
{
var threadId1 = 0;
var threadId2 = 1;
var runCount1 = 0;
var runCount2 = 0;
using (var scheduler = new NetMQScheduler())
{
var task = new Task(() =>
{
threadId1 = Thread.CurrentThread.ManagedThreadId;
runCount1++;
});
var task2 = task.ContinueWith(t =>
{
threadId2 = Thread.CurrentThread.ManagedThreadId;
runCount2++;
}, scheduler);
task.Start(scheduler);
task.Wait();
task2.Wait();
Assert.AreEqual(threadId1, threadId2);
Assert.AreEqual(1, runCount1);
Assert.AreEqual(1, runCount2);
}
}
private Task RunServer <T>(ICommonSerializer serializer, Action <int> loadPort, Action <Poller> loadPoller, T service)
where T : class
{
var task = new Task(() =>
{
var serverContext = NetMQContext.Create();
var serverSocket = serverContext.CreateResponseSocket(); // serverContext.CreateRouterSocket();
var serverPoller = new Poller(serverSocket);
var serverScheduler = new NetMQScheduler(serverContext, serverPoller);
var serverTransport = serverSocket.GenerateTransportSource(serverScheduler);
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService(service);
var port = serverSocket.BindRandomPort("tcp://localhost");
loadPoller.Invoke(serverPoller);
loadPort.Invoke(port);
serverPoller.PollTillCancelled();
serverScheduler.Dispose();
serverPoller.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
serverSocket.Dispose();
serverContext.Dispose();
}, TaskCreationOptions.LongRunning);
task.Start();
return(task);
}
public void ExternalPoller()
{
bool triggered = false;
using (NetMQContext context = NetMQContext.Create())
{
Poller poller = new Poller();
using (NetMQScheduler scheduler = new NetMQScheduler(context, poller))
{
Task.Factory.StartNew(poller.Start);
Task task = new Task(() =>
{
triggered = true;
});
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
poller.Stop();
}
}
private Task RunClient <T>(ICommonSerializer serializer, int port, Action <Poller> loadPoller, Action <T> loadProxy)
where T : class
{
var task = new Task(() =>
{
var clientContext = NetMQContext.Create();
var clientSocket = clientContext.CreateRequestSocket(); // clientContext.CreateRouterSocket();
clientSocket.Options.Linger = TimeSpan.Zero;
var clientPoller = new Poller(clientSocket);
var clientScheduler = new NetMQScheduler(clientContext, clientPoller);
var clientTransport = clientSocket.GenerateTransportSource(clientScheduler);
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <T>();
clientSocket.Connect("tcp://localhost:" + port);
loadPoller.Invoke(clientPoller);
loadProxy.Invoke(proxy);
clientPoller.PollTillCancelled();
clientScheduler.Dispose();
clientPoller.Dispose();
clientRouter.Dispose();
clientTransport.Dispose();
clientSocket.Dispose();
clientContext.Dispose();
}, TaskCreationOptions.LongRunning);
task.Start();
return(task);
}
public void ContinueWith()
{
var threadId1 = 0;
var threadId2 = 1;
var runCount1 = 0;
var runCount2 = 0;
using (var scheduler = new NetMQScheduler())
{
var task = new Task(() =>
{
threadId1 = Thread.CurrentThread.ManagedThreadId;
runCount1++;
});
var task2 = task.ContinueWith(t =>
{
threadId2 = Thread.CurrentThread.ManagedThreadId;
runCount2++;
}, scheduler);
task.Start(scheduler);
task.Wait();
task2.Wait();
Assert.AreEqual(threadId1, threadId2);
Assert.AreEqual(1, runCount1);
Assert.AreEqual(1, runCount2);
}
}
public void ExternalPoller()
{
bool triggered = false;
using (NetMQContext context = NetMQContext.Create())
{
Poller poller = new Poller();
using (NetMQScheduler scheduler = new NetMQScheduler(context, poller))
{
poller.PollTillCancelledNonBlocking();
Task task = new Task(() =>
{
triggered = true;
});
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
poller.CancelAndJoin();
}
}
public void ContinueWith()
{
int threadId1 = 0;
int threadId2 = 1;
int runCount1 = 0;
int runCount2 = 0;
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQScheduler scheduler = new NetMQScheduler(context))
{
Task task = new Task(() =>
{
threadId1 = Thread.CurrentThread.ManagedThreadId;
runCount1++;
});
Task task2 = task.ContinueWith(t =>
{
threadId2 = Thread.CurrentThread.ManagedThreadId;
runCount2++;
}, scheduler);
task.Start(scheduler);
task.Wait();
task2.Wait();
Assert.AreEqual(threadId1, threadId2);
Assert.AreEqual(1, runCount1);
Assert.AreEqual(1, runCount2);
}
}
}
public void ExternalPoller()
{
bool triggered = false;
using (NetMQContext context = NetMQContext.Create())
{
Poller poller = new Poller();
using (NetMQScheduler scheduler = new NetMQScheduler(context, poller))
{
Task.Factory.StartNew(poller.Start);
Task task = new Task(() =>
{
triggered = true;
});
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
poller.Stop();
}
}
public BinaryNetMQConnection(IWampBinaryBinding <TMessage> binding, NetMQSocket socket, NetMQScheduler scheduler)
{
_binding = binding;
_socket = socket;
_scheduler = scheduler;
_socket.ReceiveReady += OnReceiveMessage;
}
public void ContinueWith()
{
int threadId1 = 0;
int threadId2 = 1;
int runCount1 = 0;
int runCount2 = 0;
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQScheduler scheduler = new NetMQScheduler(context))
{
Task task = new Task(() =>
{
threadId1 = Thread.CurrentThread.ManagedThreadId;
runCount1++;
});
Task task2 = task.ContinueWith(t =>
{
threadId2 = Thread.CurrentThread.ManagedThreadId;
runCount2++;
}, scheduler);
task.Start(scheduler);
task.Wait();
task2.Wait();
Assert.AreEqual(threadId1, threadId2);
Assert.AreEqual(1, runCount1);
Assert.AreEqual(1, runCount2);
}
}
}
public void Start()
{
poller = new Poller();
clientSocket = context.CreateDealerSocket();
clientSocket.ReceiveReady += clientSocket_ReceiveReady;
clientSocket.Connect(address);
scheduler = new NetMQScheduler(context, poller);
Task.Factory.StartNew(poller.Start, TaskCreationOptions.LongRunning);
}
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);
}
public void OneTask()
{
bool triggered = false;
using (var scheduler = new NetMQScheduler())
{
var task = new Task(() => { triggered = true; });
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
}
public void OneTask()
{
bool triggered = false;
using (var scheduler = new NetMQScheduler())
{
var task = new Task(() => { triggered = true; });
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
}
public void CanDisposeSchedulerWhenPollerExternalAndCancelled()
{
using (var poller = new Poller())
using (var scheduler = new NetMQScheduler(poller))
{
poller.PollTillCancelledNonBlocking();
var startedEvent = new ManualResetEvent(false);
Task.Factory.StartNew(() => { startedEvent.Set(); }, CancellationToken.None, TaskCreationOptions.None, scheduler);
startedEvent.WaitOne();
poller.CancelAndJoin();
}
}
public void CanDisposeSchedulerWhenPollerExternalAndCancelled()
{
using (var poller = new Poller())
using (var scheduler = new NetMQScheduler(poller))
{
poller.PollTillCancelledNonBlocking();
var startedEvent = new ManualResetEvent(false);
Task.Factory.StartNew(() => { startedEvent.Set(); }, CancellationToken.None, TaskCreationOptions.None, scheduler);
startedEvent.WaitOne();
poller.CancelAndJoin();
}
}
public void ExternalPoller()
{
var triggered = false;
using (var poller = new Poller())
using (var scheduler = new NetMQScheduler(poller))
{
poller.PollTillCancelledNonBlocking();
var task = new Task(() => { triggered = true; });
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
}
public void ExternalPoller()
{
var triggered = false;
using (var poller = new Poller())
using (var scheduler = new NetMQScheduler(poller))
{
poller.PollTillCancelledNonBlocking();
var task = new Task(() => { triggered = true; });
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
}
public void TwoThreads()
{
int count1 = 0;
int count2 = 0;
ConcurrentBag <Task> allTasks = new ConcurrentBag <Task>();
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQScheduler scheduler = new NetMQScheduler(context))
{
Task t1 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
Task task = new Task(() =>
{
count1++;
});
allTasks.Add(task);
task.Start(scheduler);
}
});
Task t2 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
Task task = new Task(() =>
{
count2++;
});
allTasks.Add(task);
task.Start(scheduler);
}
});
t1.Wait(100);
t2.Wait(100);
Task.WaitAll(allTasks.ToArray(), 100);
Assert.AreEqual(100, count1);
Assert.AreEqual(100, count2);
}
}
}
public void OneTask()
{
bool triggered = false;
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQScheduler scheduler = new NetMQScheduler(context))
{
Task task = new Task(() =>
{
triggered = true;
});
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
}
}
public void Start()
{
_worker.ReceiveReady += _worker_ReceiveReady;
_worker.Connect("tcp://localhost:5556");
_heartbeatTimer = new NetMQTimer(Paranoid.HEARTBEAT_INTERVAL_MS);
_heartbeatTimer.Elapsed += heartbeatTimer_Elapsed;
_poller = new Poller();
_poller.AddSocket(_worker);
_poller.AddTimer(_heartbeatTimer);
_scheduler = new NetMQScheduler(_context, _poller);
_nextHeartbeatAt = DateTime.Now.AddMilliseconds(Paranoid.HEARTBEAT_INTERVAL_MS);
_cylces = 0;
Task.Factory.StartNew(() => Run(), TaskCreationOptions.LongRunning);
SendReady();
}
private static IDisposable StartNetMQServer()
{
var host = new WampHost();
var serverContext = NetMQContext.Create();
var serverSocket = serverContext.CreateResponseSocket(); // serverContext.CreateRouterSocket();
var serverPoller = new Poller(serverSocket);
var serverScheduler = new NetMQScheduler(serverContext, serverPoller);
serverPoller.PollTillCancelledNonBlocking();
host.RegisterTransport(new NetMQTransport(serverSocket, serverScheduler),
new JTokenJsonBinding(), new JTokenMsgpackBinding(), new ProtobufBinding());
host.Open();
var realm = host.RealmContainer.GetRealmByName("realm1");
realm.Services.RegisterCallee(new SumService(), new CalleeNameInterceptor()).Wait(); // add services (aka, RPC endpoints) like this
// realm.Services.RegisterPublisher // register some event triggerer here
return(host);
}
public void TwoThreads()
{
var count1 = 0;
var count2 = 0;
var allTasks = new ConcurrentBag <Task>();
using (var scheduler = new NetMQScheduler())
{
var t1 = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
var task = new Task(() => { count1++; });
allTasks.Add(task);
task.Start(scheduler);
}
});
var t2 = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
var task = new Task(() => { count2++; });
allTasks.Add(task);
task.Start(scheduler);
}
});
t1.Wait(100);
t2.Wait(100);
Task.WaitAll(allTasks.ToArray(), 100);
Assert.AreEqual(100, count1);
Assert.AreEqual(100, count2);
}
}
public NetMQTransport(NetMQSocket socket, NetMQScheduler scheduler)
{
_socket = socket;
_scheduler = scheduler;
}
public void TwoThreads()
{
int count1 = 0;
int count2 = 0;
ConcurrentBag<Task> allTasks = new ConcurrentBag<Task>();
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQScheduler scheduler = new NetMQScheduler(context))
{
Task t1 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
Task task = new Task(() =>
{
count1++;
});
allTasks.Add(task);
task.Start(scheduler);
}
});
Task t2 = Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
Task task = new Task(() =>
{
count2++;
});
allTasks.Add(task);
task.Start(scheduler);
}
});
t1.Wait(100);
t2.Wait(100);
Task.WaitAll(allTasks.ToArray(), 100);
Assert.AreEqual(100, count1);
Assert.AreEqual(100, count2);
}
}
}
public void OneTask()
{
bool triggered = false;
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQScheduler scheduler = new NetMQScheduler(context))
{
Task task = new Task(() =>
{
triggered = true;
});
task.Start(scheduler);
task.Wait();
Assert.IsTrue(triggered);
}
}
}
public void TwoThreads()
{
var count1 = 0;
var count2 = 0;
var allTasks = new ConcurrentBag<Task>();
using (var scheduler = new NetMQScheduler())
{
var t1 = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
var task = new Task(() => { count1++; });
allTasks.Add(task);
task.Start(scheduler);
}
});
var t2 = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
var task = new Task(() => { count2++; });
allTasks.Add(task);
task.Start(scheduler);
}
});
t1.Wait(100);
t2.Wait(100);
Task.WaitAll(allTasks.ToArray(), 100);
Assert.AreEqual(100, count1);
Assert.AreEqual(100, count2);
}
}
public static ITransportSource GenerateTransportSource(this NetMQSocket socket, NetMQScheduler scheduler)
{
return(new NetMQSocketTransportSource(socket, scheduler));
}
public NetMQSocketTransportSource(NetMQSocket socket, NetMQScheduler scheduler)
{
_socket = socket;
_scheduler = scheduler;
_socket.ReceiveReady += OnReceiveMessage;
}
