private void RemoveScheduler(TimerScheduler scheduler)
{
lock (sync)
{
schedulers.Add(scheduler);
}
}
public List<IDisposable> CreateFileSystemEventProducers(string directory, bool usePolling, bool useFileSystemWatcher, UntypedChannel eventChannel, TimeSpan pollingInterval)
{
if (string.IsNullOrEmpty(directory))
{
throw new ArgumentException("Directory must not be null or empty.", "directory");
}
if (eventChannel != null)
{
throw new ArgumentException("A channel must be provided.", "eventChannel");
}
List<IDisposable> producers = new List<IDisposable>();
FiberFactory fiberFactory = () => new SynchronousFiber();
if (usePolling)
{
Scheduler scheduler = new TimerScheduler(fiberFactory());
IDisposable poller = new PollingFileSystemEventProducer(directory, eventChannel,
scheduler, fiberFactory(), pollingInterval);
producers.Add(poller);
}
if (useFileSystemWatcher)
{
IDisposable watcher = new FileSystemEventProducer(directory, eventChannel);
}
return producers;
}
public IDisposable Schedule(Action <object> action, object state, TimeSpan dueTime, TimeSpan period)
{
var scheduler = new TimerScheduler(action, state, dueTime, period, this);
AddScheduler(scheduler);
return(scheduler);
}
public void Should_run_the_action_until_disabled()
{
Fiber fiber = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new PoolFiber());
Stopwatch elapsed = Stopwatch.StartNew();
int count = 0;
var called = new Future <int>();
var failed = new Future <bool>();
ScheduledOperation scheduledAction = null;
scheduledAction = scheduler.Schedule(TimeSpan.Zero, 100.Milliseconds(), fiber, () =>
{
count++;
if (count == 10)
{
called.Complete(count);
scheduledAction.Cancel();
}
else if (count > 10)
{
failed.Complete(true);
}
});
called.WaitUntilCompleted(5.Seconds()).ShouldBeTrue();
elapsed.Stop();
failed.WaitUntilCompleted(200.Milliseconds()).ShouldBeFalse();
Trace.WriteLine("Time Period: " + elapsed.ElapsedMilliseconds);
}
public List <IDisposable> CreateFileSystemEventProducers(string directory, bool usePolling, bool useFileSystemWatcher, UntypedChannel eventChannel, TimeSpan pollingInterval)
{
if (string.IsNullOrEmpty(directory))
{
throw new ArgumentException("Directory must not be null or empty.", "directory");
}
if (eventChannel != null)
{
throw new ArgumentException("A channel must be provided.", "eventChannel");
}
List <IDisposable> producers = new List <IDisposable>();
FiberFactory fiberFactory = () => new SynchronousFiber();
if (usePolling)
{
Scheduler scheduler = new TimerScheduler(fiberFactory());
IDisposable poller = new PollingFileSystemEventProducer(directory, eventChannel,
scheduler, fiberFactory(), pollingInterval);
producers.Add(poller);
}
if (useFileSystemWatcher)
{
IDisposable watcher = new FileSystemEventProducer(directory, eventChannel);
}
return(producers);
}
public void Should_capture_the_interval_channel()
{
var channel = new ConsumerChannel<ICollection<int>>(new SynchronousFiber(), x => { });
var scheduler = new TimerScheduler(new SynchronousFiber());
var interval = new IntervalChannel<int>(new SynchronousFiber(), scheduler, 5.Minutes(), channel);
new ChannelVisitor().Visit(interval);
}
public void Should_capture_the_interval_channel()
{
var channel = new ConsumerChannel <ICollection <int> >(new SynchronousFiber(), x => { });
var scheduler = new TimerScheduler(new SynchronousFiber());
var interval = new IntervalChannel <int>(new SynchronousFiber(), scheduler, 5.Minutes(), channel);
new ChannelVisitor().Visit(interval);
}
public static Timer Start(float timeSeconds, TimerScheduler.Callback callback, bool loop = false)
{
if (TimerScheduler.IsInitialized)
{
return TimerScheduler.Instance.StartTimer(timeSeconds, callback, loop);
}
return Timer.Invalid;
}
public static Timer StartNextFrame(TimerScheduler.Callback callback)
{
if (TimerScheduler.IsInitialized)
{
return TimerScheduler.Instance.StartTimer(0.0f, callback, false, true);
}
return Timer.Invalid;
}
public T UseTimerScheduler()
{
TimerScheduler scheduler = null;
_schedulerFactory = () => { return(scheduler ?? (scheduler = new TimerScheduler(new PoolFiber()))); };
_owned = true;
return(this as T);
}
public OutputBuffer(IService server)
{
Guard.ArgumentNotNull(server, "server");
_server = server;
_timerScheduler = new TimerScheduler();
#if DEBUG
this.debugLog = ObjectFactory.Current.Get<IDebugLogWriter>(Lifetime.ContainerControlled);
#endif
}
public void Timer_Based_Demo()
{
Scheduler scheduler = new TimerScheduler(new SynchronousFiber());
scheduler.Schedule(0, 1000, new SynchronousFiber(), () =>
{
Trace.WriteLine("Starting it up");
_ping.Start(10, _pong);
});
Thread.Sleep(6000);
}
public void Should_run_the_action_immediately()
{
Fiber fiber = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future <bool>();
scheduler.Schedule(TimeSpan.Zero, fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Should_not_stall_the_scheduler()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new ThreadPoolFiber());
var called = new Future <bool>();
scheduler.Schedule(200.Milliseconds(), fiber, () => { throw new InvalidOperationException("Bugger!"); });
scheduler.Schedule(400.Milliseconds(), fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Timer_Based_Demo()
{
Scheduler scheduler = new TimerScheduler(new SynchronousFiber());
scheduler.Schedule(0, 1000, new SynchronousFiber(), () =>
{
Trace.WriteLine("Starting it up");
_ping.Start(10, _pong);
});
Thread.Sleep(6000);
}
public void Should_not_stall_the_scheduler()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new ThreadPoolFiber());
var called = new Future<bool>();
scheduler.Schedule(200.Milliseconds(), fiber, () => { throw new InvalidOperationException("Bugger!"); });
scheduler.Schedule(400.Milliseconds(), fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Should_run_the_new_action_immediately()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new ThreadPoolFiber());
var called = new Future <bool>();
scheduler.Schedule(2.Seconds(), fiber, () => { });
scheduler.Schedule(0.Seconds(), fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Should_not_run_any_pending_actions()
{
Fiber fiber = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new PoolFiber());
var called = new Future <bool>();
scheduler.Schedule(1.Seconds(), fiber, () => called.Complete(true));
scheduler.Stop(60.Seconds());
called.WaitUntilCompleted(2.Seconds()).ShouldBeFalse();
}
public void Should_wait_until_the_appropriate_time_for_the_action_to_execute()
{
Fiber fiber = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future <bool>();
scheduler.Schedule(100.Milliseconds(), fiber, () => called.Complete(true));
called.IsCompleted.ShouldBeFalse();
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Should_wait_until_the_appropriate_time_for_the_action_to_execute()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future<bool>();
scheduler.Schedule(100.Milliseconds(), fiber, () => called.Complete(true));
called.IsCompleted.ShouldBeFalse();
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Should_not_run_any_pending_actions()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new ThreadPoolFiber());
var called = new Future<bool>();
scheduler.Schedule(1.Seconds(), fiber, () => called.Complete(true));
scheduler.Stop();
called.WaitUntilCompleted(2.Seconds()).ShouldBeFalse();
}
public static bool Close(NSJSVirtualMachine machine)
{
TimerScheduler scheduler = null;
if (machine == null)
{
return(false);
}
if (!schedulers.TryRemove(machine, out scheduler))
{
return(false);
}
scheduler.Dispose();
return(true);
}
public void Should_not_stall_the_scheduler()
{
Fiber stopped = new PoolFiber();
stopped.Stop();
Fiber running = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new PoolFiber());
var called = new Future <bool>();
scheduler.Schedule(200.Milliseconds(), stopped, () => { });
scheduler.Schedule(400.Milliseconds(), running, () => called.Complete(true));
called.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
private static TimerScheduler GetScheduler(NSJSVirtualMachine machine)
{
if (machine == null)
{
throw new ArgumentNullException("machine");
}
if (machine.IsDisposed)
{
throw new ObjectDisposedException("machine");
}
return(schedulers.GetOrAdd(machine, (key) =>
{
TimerScheduler scheduler = new TimerScheduler();
machine.Disposed += (sender, e) => Close(machine);
return scheduler;
}));
}
public void Should_schedule_events()
{
var update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};
Fiber fiber = new SynchronousFiber();
var future = new FutureChannel<UserUpdate>();
Channel<UserUpdate> channel = new BroadcastChannel<UserUpdate>(new Channel<UserUpdate>[] {future});
var scheduler = new TimerScheduler(fiber);
scheduler.Schedule(1000, fiber, () => channel.Send(update));
Thread.Sleep(500);
Assert.IsFalse(future.WaitUntilCompleted(0.Seconds()));
Assert.IsTrue(future.WaitUntilCompleted(1.Seconds()));
}
public void Schedule()
{
var fiber = new SynchronousFiber();
var count = 0;
var reset = new AutoResetEvent(false);
Action one = () => Assert.AreEqual(0, count++);
Action two = () => Assert.AreEqual(1, count++);
Action three = delegate
{
Assert.AreEqual(2, count++);
reset.Set();
};
var thread = new TimerScheduler(fiber);
thread.Schedule(50, fiber, three);
thread.Schedule(1, fiber, one);
thread.Schedule(1, fiber, two);
Assert.IsTrue(reset.WaitOne(10000, false));
}
public void Schedule()
{
var fiber = new SynchronousFiber();
var count = 0;
var reset = new AutoResetEvent(false);
Action one = () => Assert.AreEqual(0, count++);
Action two = () => Assert.AreEqual(1, count++);
Action three = delegate
{
Assert.AreEqual(2, count++);
reset.Set();
};
var thread = new TimerScheduler(fiber);
thread.Schedule(50, fiber, three);
thread.Schedule(1, fiber, one);
thread.Schedule(1, fiber, two);
Assert.IsTrue(reset.WaitOne(10000, false));
}
public IDisposable Watch(string directoryToWatch, Action <Directory> actionToTake)
{
_actionToTake = actionToTake;
Func <Fiber> fiberFactory = () => new SynchronousFiber();
if (!System.IO.Directory.Exists(directoryToWatch))
{
System.IO.Directory.CreateDirectory(directoryToWatch);
}
var eventChannel = new ChannelAdapter();
eventChannel.Connect(x => x.AddConsumerOf <FileCreated>().UsingConsumer(ProcessNewFile));
Scheduler scheduler = new TimerScheduler(fiberFactory());
var watcher = new PollingFileSystemEventProducer(directoryToWatch, eventChannel, scheduler, fiberFactory(),
1.Seconds());
return(watcher);
}
public void Should_schedule_events()
{
var update = new UserUpdate {
LastActivity = DateTime.Now - 5.Minutes()
};
Fiber fiber = new SynchronousFiber();
var future = new FutureChannel <UserUpdate>();
Channel <UserUpdate> channel = new BroadcastChannel <UserUpdate>(new Channel <UserUpdate>[] { future });
var scheduler = new TimerScheduler(fiber);
scheduler.Schedule(1000, fiber, () => channel.Send(update));
Thread.Sleep(500);
Assert.IsFalse(future.WaitUntilCompleted(0.Seconds()));
Assert.IsTrue(future.WaitUntilCompleted(1.Seconds()));
}
public void Should_deliver_the_messages_at_once()
{
var queue = new SynchronousFiber();
var scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future <ICollection <MyMessage> >();
var consumer = new ConsumerChannel <ICollection <MyMessage> >(queue, called.Complete);
var channel = new IntervalChannel <MyMessage>(queue, scheduler, 2.Seconds(), consumer);
for (int i = 0; i < 5; i++)
{
channel.Send(new MyMessage());
}
called.WaitUntilCompleted(4.Seconds()).ShouldBeTrue();
channel.Dispose();
called.Value.ShouldNotBeNull();
called.Value.Count.ShouldEqual(5);
}
public void Should_deliver_the_messages_at_once()
{
var queue = new SynchronousFiber();
var scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future<ICollection<MyMessage>>();
var consumer = new ConsumerChannel<ICollection<MyMessage>>(queue, called.Complete);
var channel = new IntervalChannel<MyMessage>(queue, scheduler, 2.Seconds(), consumer);
for (int i = 0; i < 5; i++)
{
channel.Send(new MyMessage());
}
called.WaitUntilCompleted(4.Seconds()).ShouldBeTrue();
channel.Dispose();
called.Value.ShouldNotBeNull();
called.Value.Count.ShouldEqual(5);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (TimerScheduler != null)
{
TimerScheduler.Dispose();
}
if (_timerCheckChannelTimedOut != null)
{
_timerCheckChannelTimedOut.Dispose();
_timerCheckChannelTimedOut = null;
}
if (_channels != null)
{
foreach (var item in _channels.Values)
{
item.Dispose();
}
_channels = null;
}
}
}
public void Schedule1000In1ms()
{
var fiber = new SynchronousFiber();
var count = 0;
var reset = new AutoResetEvent(false);
Action one = delegate
{
count++;
if (count == 1000)
{
reset.Set();
}
};
var thread = new TimerScheduler(fiber);
{
for (var i = 0; i < 1000; i++)
{
thread.Schedule(i, fiber,one);
}
Assert.IsTrue(reset.WaitOne(1200, false));
}
}
public void Schedule1000In1ms()
{
var fiber = new SynchronousFiber();
var count = 0;
var reset = new AutoResetEvent(false);
Action one = delegate
{
count++;
if (count == 1000)
{
reset.Set();
}
};
var thread = new TimerScheduler(fiber);
{
for (var i = 0; i < 1000; i++)
{
thread.Schedule(i, fiber, one);
}
Assert.IsTrue(reset.WaitOne(1200, false));
}
}
public Timer()
{
scheduler = TimerScheduler.CurrentScheduler;
}
public void Should_run_the_action_until_disabled()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new ThreadPoolFiber());
Stopwatch elapsed = Stopwatch.StartNew();
int count = 0;
var called = new Future<int>();
var failed = new Future<bool>();
ScheduledAction scheduledAction = null;
scheduledAction = scheduler.Schedule(TimeSpan.Zero, 100.Milliseconds(), fiber, () =>
{
count++;
if (count == 10)
{
called.Complete(count);
scheduledAction.Cancel();
}
else if (count > 10)
{
failed.Complete(true);
}
});
called.WaitUntilCompleted(5.Seconds()).ShouldBeTrue();
elapsed.Stop();
failed.WaitUntilCompleted(200.Milliseconds()).ShouldBeFalse();
Trace.WriteLine("Time Period: " + elapsed.ElapsedMilliseconds);
}
public void Should_run_the_new_action_immediately()
{
Fiber fiber = new ThreadPoolFiber();
Scheduler scheduler = new TimerScheduler(new ThreadPoolFiber());
var called = new Future<bool>();
scheduler.Schedule(2.Seconds(), fiber, () => { });
scheduler.Schedule(0.Seconds(), fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Terminate()
{
TimerScheduler.Terminate();
}
public void Should_not_stall_the_scheduler()
{
Fiber stopped = new PoolFiber();
stopped.Stop();
Fiber running = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new PoolFiber());
var called = new Future<bool>();
scheduler.Schedule(200.Milliseconds(), stopped, () => { });
scheduler.Schedule(400.Milliseconds(), running, () => called.Complete(true));
called.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
public static Timer New(NSJSVirtualMachine machine)
{
TimerScheduler scheduler = GetScheduler(machine);
return(new Timer(scheduler));
}
public void Should_run_the_action_immediately()
{
Fiber fiber = new PoolFiber();
Scheduler scheduler = new TimerScheduler(new SynchronousFiber());
var called = new Future<bool>();
scheduler.Schedule(TimeSpan.Zero, fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
