public void SetTimeoutReset()
{
// arrange
var loop = new EventLoop();
loop.Start(() => { });
var callbackinvoked = new ManualResetEvent(false);
var callback = new Action(() => callbackinvoked.Set());
var timeout = TimeSpan.FromMilliseconds(100);
// act
var cancelTimeout = loop.SetTimeout(callback, timeout);
Thread.Sleep(50);
cancelTimeout.Reset();
Thread.Sleep(50);
cancelTimeout.Reset();
// assert
Assert.That(callbackinvoked.WaitOne(0), Is.False);
Assert.That(cancelTimeout, Is.Not.Null);
Assert.That(callbackinvoked.WaitOne(timeout + timeout), Is.True);
// cleanup
loop.Dispose();
callbackinvoked.Dispose();
}
public void StartsElectionAfterElectionTimeout()
{
// arrange
var resetEvent = new ManualResetEvent(false);
var timeout = TimeSpan.FromMilliseconds(100);
var configMock = new Mock <IServerConfiguration>();
configMock.Setup(mocked => mocked.ElectionTimeout).Returns(timeout);
var config = configMock.Object;
var scheduler = new EventLoop();
var serverMock = new Mock <IConsensusServerStateApi>();
serverMock.Setup(mocked => mocked.StartElection()).Callback(() => resetEvent.Set());
serverMock.Setup(mocked => mocked.Configuration).Returns(config);
serverMock.Setup(mocked => mocked.Scheduler).Returns(scheduler);
var server = serverMock.Object;
var state = new Follower(server);
// act
state.Start();
var changedToCandidate = resetEvent.WaitOne(timeout + timeout);
// assert
Assert.That(changedToCandidate, Is.True, "An election timout should have occurred and the state should be changed to candidate");
// cleanup
scheduler.Dispose();
resetEvent.Dispose();
}
public static void Main(string[] args)
{
LogFactory.AddConsoleProvider(LogLevel.Debug);
try
{
eventLoop = new EventLoop();
Task task = Task.Run(async() => await RunLoopAsync());
eventLoop.Schedule(loop => loop
.CreateTcp()
.SimultaneousAccepts(true)
.Listen(EndPoint, OnConnection));
Console.WriteLine("Waiting for loop to complete.");
task.Wait();
Console.WriteLine("Loop completed.");
}
catch (Exception exception)
{
Console.WriteLine($"Loop thread error {exception}.");
}
finally
{
eventLoop?.Dispose();
}
Console.WriteLine("Press any key to terminate the program.");
Console.ReadLine();
}
private static void Main(string[] args)
{
// create the event loop
var loop = new EventLoop();
// start it with a callback
loop.Start(() => Console.WriteLine("Event loop has started"));
// start a timer
loop.SetTimeout(() => Console.WriteLine("Hello, I am a timeout happening after 1 second"), TimeSpan.FromSeconds(1));
loop.SetInterval(() => Console.WriteLine("Hello, I am an interval happening every 2 seconds"), TimeSpan.FromSeconds(2));
// read the app.config
var appConfigFile = new FileInfo("NLoop.TestApp.exe.config");
var promise = appConfigFile.ReadAllBytes(loop);
promise.Then(content => Console.WriteLine("Success!! read {0} bytes from app.config", content.Length), reason => Console.WriteLine("Dread!! got an error: {0}", reason));
// send a web request
var httpClient = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://www.google.com/");
var httpPromise = httpClient.Send(loop, request);
httpPromise.Then(content => Console.WriteLine("Success!! read {0} from google.com", content.StatusCode), reason => Console.WriteLine("Dread!! got an error: {0}", reason));
//httpPromise.Cancel();
// wait
Console.WriteLine("Event loop is processing, press any key to exit");
Console.Read();
// we are done, dispose the loop so resources will be cleaned up
loop.Dispose();
}
static async Task RunLoopAsync()
{
Console.WriteLine("Starting event loop.");
await eventLoop.RunAsync();
Console.WriteLine("Event loop completed");
eventLoop.Dispose();
}
public void Close()
{
_reactor.CloseConnection(this);
if (NetworkEventLoop.Disconnection != null)
{
NetworkEventLoop.Disconnection(new HeliosConnectionException(ExceptionType.Closed), this);
}
EventLoop.Dispose();
}
public void TrackResourceDispose()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var disposed = false;
loop.TrackResource(token, new DisposeAction(() => { disposed = true; }));
// act
loop.Dispose();
// assert
Assert.That(disposed, Is.True);
// cleanup
loop.Dispose();
cts.Dispose();
}
public override void Dispose(bool disposing)
{
if (!WasDisposed && disposing && Listener != null)
{
Stop();
Listener.Dispose();
EventLoop.Dispose();
}
IsActive = false;
WasDisposed = true;
}
public void ThrowIfDisposed()
{
// arrange
var loop = new EventLoop();
// act
loop.Start(() => { });
loop.Dispose();
// assert
Assert.That(() => loop.Start(() => { }), Throws.InstanceOf <ObjectDisposedException>());
}
public void TrackResourceUntrack()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var disposed = false;
var disposer = new DisposeAction(() => { disposed = true; });
var untrack = loop.TrackResource(token, disposer);
// assert
Assert.That(untrack(token), Is.True, "Expected the resource to be untracked");
Assert.That(untrack(token), Is.False, "Expected the resource to be untracked already");
// dispose the loop
loop.Dispose();
Assert.That(disposed, Is.False);
// cleanup
loop.Dispose();
cts.Dispose();
}
protected void Dispose(bool disposing)
{
if (!WasDisposed)
{
WasDisposed = true;
if (disposing)
{
Close();
Socket = null;
EventLoop.Dispose();
}
}
}
public void StartWithCallback()
{
// arrange
var loop = new EventLoop();
var wait = new AutoResetEvent(false);
// act
loop.Start(() => wait.Set());
// assert
Assert.That(() => wait.WaitOne(100), Is.True);
// cleanup
loop.Dispose();
wait.Dispose();
}
protected override void Dispose(bool disposing)
{
if (!WasDisposed)
{
if (disposing)
{
if (Client != null)
{
Close();
((IDisposable)Client).Dispose();
EventLoop.Dispose();
}
}
}
WasDisposed = true;
}
protected override void Dispose(bool disposing)
{
if (!WasDisposed)
{
if (disposing)
{
if (_client != null)
{
((IDisposable)_client).Dispose();
_client = null;
EventLoop.Dispose();
}
}
}
WasDisposed = true;
}
public void SetIntervalParameterChecking()
{
// arrange
var loop = new EventLoop();
loop.Start(() => { });
var callback = new Action(() => { });
var timeout = TimeSpan.FromMilliseconds(100);
// assert
Assert.That(() => ((EventLoop)null).SetInterval(callback, timeout), Throws.InstanceOf <ArgumentNullException>());
Assert.That(() => loop.SetInterval(null, timeout), Throws.InstanceOf <ArgumentNullException>());
// cleanup
loop.Dispose();
}
public void StartWithCallback()
{
// arrange
var loop = new EventLoop();
var wait = new AutoResetEvent(false);
// act
loop.Start(() => wait.Set());
// assert
Assert.That(() => wait.WaitOne(100), Is.True);
// cleanup
loop.Dispose();
wait.Dispose();
}
public void StartWithCallbackCalledTwice()
{
// arrange
var loop = new EventLoop();
var wait = new CountdownEvent(2);
// act
loop.Start(() => wait.Signal());
loop.Start(() => wait.Signal());
// assert
Assert.That(() => wait.WaitHandle.WaitOne(100), Is.True);
Assert.That(wait.CurrentCount, Is.EqualTo(0));
// cleanup
loop.Dispose();
wait.Dispose();
}
public void StartWithCallbackCalledTwice()
{
// arrange
var loop = new EventLoop();
var wait = new CountdownEvent(2);
// act
loop.Start(() => wait.Signal());
loop.Start(() => wait.Signal());
// assert
Assert.That(() => wait.WaitHandle.WaitOne(100), Is.True);
Assert.That(wait.CurrentCount, Is.EqualTo(0));
// cleanup
loop.Dispose();
wait.Dispose();
}
//[Fact]
public void DisposingLetNoEventsBeDispatched()
{
var brokerMock = new Mock <IObservable <IRxModellingEvent> >();
var timeScheduler = new ModelTimeScheduler(ModelTimeStep.Day, DateTimeOffset.Parse("2019-01-01"));
var loop = new EventLoop(timeScheduler, brokerMock.Object);
loop.Run(time =>
{
time.OnUniformTestPassed(t =>
{
}, 0.2);
}, 15);
Thread.Sleep(80);
loop.Dispose();
Console.WriteLine("loop disposed");
Thread.Sleep(TimeSpan.FromSeconds(10));
}
public void SetInterval()
{
// arrange
var loop = new EventLoop();
loop.Start(() => { });
var counter = new CountdownEvent(2);
var callback = new Action(() => counter.Signal());
var timeout = TimeSpan.FromMilliseconds(100);
// act
loop.SetInterval(callback, timeout);
// assert
Assert.That(counter.Wait(timeout + timeout + timeout), Is.True);
// cleanup
loop.Dispose();
counter.Dispose();
}
public void Schedule()
{
// arrange
var loop = new EventLoop();
var wait = new AutoResetEvent(false);
var counter = 0;
// act
loop.Schedule(() => counter++);
loop.Schedule(() => counter++);
loop.Start(() => wait.Set());
loop.Schedule(() => counter++);
// assert
Assert.That(() => wait.WaitOne(100), Is.True);
Assert.That(counter, Is.EqualTo(3));
// cleanup
loop.Dispose();
wait.Dispose();
}
public void DisposesLogAndProtocol()
{
// arrange
var configuration = new Mock <IServerConfiguration>().Object;
var scheduler = new EventLoop();
var logMock = new Mock <ILog>();
var log = logMock.Object;
var protocolMock = new Mock <IProtocol>();
var protocol = protocolMock.Object;
var server = new ConsensusServer(configuration, log, protocol, scheduler);
// act
server.Dispose();
// assert
logMock.Verify(x => x.Dispose(), Times.Once());
protocolMock.Verify(x => x.Dispose(), Times.Once());
// cleanup
scheduler.Dispose();
}
public void Schedule()
{
// arrange
var loop = new EventLoop();
var wait = new AutoResetEvent(false);
var counter = 0;
// act
loop.Schedule(() => counter++);
loop.Schedule(() => counter++);
loop.Start(() => wait.Set());
loop.Schedule(() => counter++);
// assert
Assert.That(() => wait.WaitOne(100), Is.True);
Assert.That(counter, Is.EqualTo(3));
// cleanup
loop.Dispose();
wait.Dispose();
}
public void TrackResourceCancel()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var cancelled = false;
token.Register(() => { cancelled = true; });
loop.TrackResource(token, new DisposeAction(() => { }));
// act
cts.Cancel();
// assert
Assert.That(cancelled, Is.True);
// cleanup
loop.Dispose();
cts.Dispose();
}
public void SetTimeoutCancel()
{
// arrange
var loop = new EventLoop();
loop.Start(() => { });
var callbackinvoked = new ManualResetEvent(false);
var callback = new Action(() => callbackinvoked.Set());
var timeout = TimeSpan.FromMilliseconds(100);
// act
var timer = loop.SetTimeout(callback, timeout);
timer.Cancel();
// assert
Assert.That(callbackinvoked.WaitOne(timeout + timeout), Is.False);
// cleanup
loop.Dispose();
callbackinvoked.Dispose();
}
public void TrackResourceCancel()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var cancelled = false;
token.Register(() => { cancelled = true; });
loop.TrackResource(token, new DisposeAction(() => { }));
// act
cts.Cancel();
// assert
Assert.That(cancelled, Is.True);
// cleanup
loop.Dispose();
cts.Dispose();
}
public void TrackResourceUntrack()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var disposed = false;
var disposer = new DisposeAction(() => { disposed = true; });
var untrack = loop.TrackResource(token, disposer);
// assert
Assert.That(untrack(token), Is.True, "Expected the resource to be untracked");
Assert.That(untrack(token), Is.False, "Expected the resource to be untracked already");
// dispose the loop
loop.Dispose();
Assert.That(disposed, Is.False);
// cleanup
loop.Dispose();
cts.Dispose();
}
public void ThrowIfDisposed()
{
// arrange
var loop = new EventLoop();
// act
loop.Start(() => { });
loop.Dispose();
// assert
Assert.That(() => loop.Start(() => { }), Throws.InstanceOf<ObjectDisposedException>());
}
public void TrackResourceDispose()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var disposed = false;
loop.TrackResource(token, new DisposeAction(() => { disposed = true; }));
// act
loop.Dispose();
// assert
Assert.That(disposed, Is.True);
// cleanup
loop.Dispose();
cts.Dispose();
}
