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_be_fast()
{
Fiber fiber = new ThreadPoolFiber();
const int limit = 5000000;
var complete = new Future<int>();
Channel<MsgStruct> channel = new ConsumerChannel<MsgStruct>(fiber, message =>
{
if (message.Count == limit)
complete.Complete(limit);
});
using (var timer = new FunctionTimer("Throughput", x =>
{
Trace.WriteLine("Time to execute: " + (int) x.ElapsedMilliseconds + "ms");
Trace.WriteLine("Per second throughput: " + (int) (limit/(x.ElapsedMilliseconds/1000)));
}))
{
for (int i = 1; i <= limit; i++)
{
channel.Send(new MsgStruct
{
Count = i,
Other = i*8,
});
}
timer.Mark();
complete.WaitUntilCompleted(30.Seconds()).ShouldBeTrue();
}
}
public Auction(Guid id)
{
Id = id;
Fiber = new ThreadPoolFiber();
BidChannel = new ConsumerChannel <Bid>(Fiber, ReceiveBid);
}
public Pinger()
{
_fiber = new ThreadPoolFiber();
Ponged = new Future<Pong>();
PongChannel = new ConsumerChannel<Pong>(_fiber, HandlePong);
}
public SomeActorInstance()
{
_fiber = new ThreadPoolFiber();
_future = new Future <MyMessage>();
MessageChannel = new ConsumerChannel <MyMessage>(_fiber, Consume);
LambdaMessageChannel = new ConsumerChannel <MyMessage>(_fiber, message => _future.Complete(message));
}
public Auction(Guid id)
{
Id = id;
Fiber = new ThreadPoolFiber();
BidChannel = new ConsumerChannel<Bid>(Fiber, ReceiveBid);
}
public Ponger()
{
_fiber = new ThreadPoolFiber();
Pinged = new Future <Ping>();
PongChannel = new ConsumerChannel <Ping>(_fiber, HandlePing);
}
public SomeActorInstance()
{
_fiber = new ThreadPoolFiber();
_future = new Future<MyMessage>();
MessageChannel = new ConsumerChannel<MyMessage>(_fiber, Consume);
LambdaMessageChannel = new ConsumerChannel<MyMessage>(_fiber, message => _future.Complete(message));
}
public void Should_properly_wrap_the_channel_as_synchronized()
{
Assert.IsNull(SynchronizationContext.Current);
var fiber = new ThreadPoolFiber();
var input = new ChannelAdapter();
var context = new TestSynchronizationContext();
var future = new Future <TestMessage>();
SynchronizationContext.SetSynchronizationContext(context);
Assert.IsNotNull(SynchronizationContext.Current);
using (input.Connect(x =>
{
x.AddConsumerOf <TestMessage>()
.OnCurrentSynchronizationContext()
.UsingConsumer(message =>
{
Trace.WriteLine("Received on Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNotNull(SynchronizationContext.Current);
Assert.AreEqual(context, SynchronizationContext.Current);
future.Complete(message);
});
}))
{
Trace.WriteLine("Subscribed on Thread: " + Thread.CurrentThread.ManagedThreadId);
SynchronizationContext.SetSynchronizationContext(null);
input.Flatten().Select(c => c.GetType()).ShouldEqual(new[]
{
typeof(ChannelAdapter),
typeof(BroadcastChannel),
typeof(TypedChannelAdapter <TestMessage>),
typeof(SynchronizedChannel <TestMessage>),
typeof(ConsumerChannel <TestMessage>),
});
fiber.Add(() =>
{
Trace.WriteLine("Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNull(SynchronizationContext.Current);
input.Send(new TestMessage());
});
Assert.IsNull(SynchronizationContext.Current);
future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
}
public void Should_properly_wrap_the_channel_as_synchronized()
{
Assert.IsNull(SynchronizationContext.Current);
var fiber = new ThreadPoolFiber();
var input = new ChannelAdapter();
var context = new TestSynchronizationContext();
var future = new Future<TestMessage>();
SynchronizationContext.SetSynchronizationContext(context);
Assert.IsNotNull(SynchronizationContext.Current);
using (input.Connect(x =>
{
x.AddConsumerOf<TestMessage>()
.OnCurrentSynchronizationContext()
.UsingConsumer(message =>
{
Trace.WriteLine("Received on Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNotNull(SynchronizationContext.Current);
Assert.AreEqual(context, SynchronizationContext.Current);
future.Complete(message);
});
}))
{
Trace.WriteLine("Subscribed on Thread: " + Thread.CurrentThread.ManagedThreadId);
SynchronizationContext.SetSynchronizationContext(null);
input.Flatten().Select(c => c.GetType()).ShouldEqual(new[]
{
typeof(ChannelAdapter),
typeof(BroadcastChannel),
typeof(TypedChannelAdapter<TestMessage>),
typeof(SynchronizedChannel<TestMessage>),
typeof(ConsumerChannel<TestMessage>),
});
fiber.Add(() =>
{
Trace.WriteLine("Thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.IsNull(SynchronizationContext.Current);
input.Send(new TestMessage());
});
Assert.IsNull(SynchronizationContext.Current);
future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
}
public void Should_run_the_action_immediately()
{
Fiber fiber = new ThreadPoolFiber();
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 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 QueryContent(int id, Consumer <MyContent> callback)
{
Id = id;
var queue = new ThreadPoolFiber();
Channel <MyContent> channel = new ConsumerChannel <MyContent>(new SynchronousFiber(), callback);
if (SynchronizationContext.Current != null)
{
channel = new SynchronizedChannel <MyContent>(queue, channel, SynchronizationContext.Current);
}
ResponseChannel = channel;
}
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 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 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_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 QueryContent(int id, Consumer<MyContent> callback)
{
Id = id;
var queue = new ThreadPoolFiber();
Channel<MyContent> channel = new ConsumerChannel<MyContent>(new SynchronousFiber(), callback);
if (SynchronizationContext.Current != null)
{
channel = new SynchronizedChannel<MyContent>(queue, channel, SynchronizationContext.Current);
}
ResponseChannel = channel;
}
public void Should_properly_release_one_waiting_writer()
{
const int writerCount = 10;
const int messageCount = 1000;
var complete = new Future <bool>();
int total = 0;
Fiber reader = new ThreadFiber();
try
{
Thread.Sleep(100);
Stopwatch timer = Stopwatch.StartNew();
var writers = new List <Fiber>();
for (int i = 0; i < writerCount; i++)
{
Fiber fiber = new ThreadPoolFiber();
for (int j = 0; j < messageCount; j++)
{
fiber.Add(() =>
{
SuperSleeper.Wait(1);
reader.Add(() =>
{
total++;
if (total == writerCount * messageCount)
{
complete.Complete(true);
}
});
});
}
writers.Add(fiber);
}
complete.WaitUntilCompleted(20.Seconds()).ShouldBeTrue();
timer.Stop();
Trace.WriteLine("Elapsed time: " + timer.ElapsedMilliseconds + "ms (expected " + writerCount * messageCount + ")");
}
finally
{
reader.Stop();
}
}
public void Should_prevent_new_actions_from_being_queued()
{
Fiber fiber = new ThreadPoolFiber();
var called = new Future <bool>();
fiber.Stop();
Assert.Throws <FiberException>(() => fiber.Add(() => called.Complete(true)));
fiber.Shutdown(10.Seconds());
called.IsCompleted.ShouldBeFalse();
}
public void Should_prevent_new_actions_from_being_queued()
{
Fiber fiber = new ThreadPoolFiber();
var called = new Future<bool>();
fiber.Stop();
Assert.Throws<FiberException>(() => fiber.Add(() => called.Complete(true)));
fiber.Shutdown(10.Seconds());
called.IsCompleted.ShouldBeFalse();
}
public void Should_properly_release_one_waiting_writer()
{
const int writerCount = 10;
const int messageCount = 1000;
var complete = new Future<bool>();
int total = 0;
Fiber reader = new ThreadFiber();
try
{
Thread.Sleep(100);
Stopwatch timer = Stopwatch.StartNew();
var writers = new List<Fiber>();
for (int i = 0; i < writerCount; i++)
{
Fiber fiber = new ThreadPoolFiber();
for (int j = 0; j < messageCount; j++)
{
fiber.Add(() =>
{
SuperSleeper.Wait(1);
reader.Add(() =>
{
total++;
if (total == writerCount*messageCount)
complete.Complete(true);
});
});
}
writers.Add(fiber);
}
complete.WaitUntilCompleted(20.Seconds()).ShouldBeTrue();
timer.Stop();
Trace.WriteLine("Elapsed time: " + timer.ElapsedMilliseconds + "ms (expected " + writerCount*messageCount + ")");
}
finally
{
reader.Stop();
}
}
public void Should_result_in_an_exception()
{
var action = MockRepository.GenerateMock<Action>();
var queue = new ThreadPoolFiber(2, 0);
queue.Enqueue(action);
queue.Enqueue(action);
try
{
queue.Enqueue(action);
Assert.Fail("Should have thrown an exception");
}
catch (FiberException ex)
{
ex.Message.Contains("Insufficient").ShouldBeTrue();
}
}
public void Should_result_in_no_waiting_actions_in_the_queue()
{
TraceLogger.Configure(LogLevel.Debug);
Fiber fiber = new ThreadPoolFiber();
var called = new Future <bool>();
10.Times(() => fiber.Add(() => Thread.Sleep(100)));
fiber.Add(() => called.Complete(true));
Stopwatch timer = Stopwatch.StartNew();
fiber.Shutdown(8.Seconds());
timer.Stop();
called.IsCompleted.ShouldBeTrue();
timer.ElapsedMilliseconds.ShouldBeLessThan(2000);
}
public void Should_result_in_no_waiting_actions_in_the_queue()
{
TraceLogger.Configure(LogLevel.Debug);
Fiber fiber = new ThreadPoolFiber();
var called = new Future<bool>();
10.Times(() => fiber.Add(() => Thread.Sleep(100)));
fiber.Add(() => called.Complete(true));
Stopwatch timer = Stopwatch.StartNew();
fiber.Shutdown(8.Seconds());
timer.Stop();
called.IsCompleted.ShouldBeTrue();
timer.ElapsedMilliseconds.ShouldBeLessThan(2000);
}
public static void Configure(LogLevel logLevel)
{
Fiber consoleFiber = new ThreadPoolFiber();
Logger.LogChannel.Connect(x =>
{
x.AddConsumerOf<DebugLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Cyan))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf<InfoLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.White))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf<WarnLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Yellow))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf<ErrorLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Red))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf<FatalLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Red))
.HandleOnFiber(consoleFiber);
});
}
public static void Configure(LogLevel logLevel)
{
Fiber consoleFiber = new ThreadPoolFiber();
Logger.LogChannel.Connect(x =>
{
x.AddConsumerOf <DebugLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Cyan))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf <InfoLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.White))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf <WarnLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Yellow))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf <ErrorLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Red))
.HandleOnFiber(consoleFiber);
x.AddConsumerOf <FatalLogMessage>()
.Where(m => m.Level.IsEnabledForLevel(logLevel))
.HandleOnCallingThread()
.OnCurrentSynchronizationContext()
.UsingConsumer(m => WriteLine(m, ConsoleColor.Red))
.HandleOnFiber(consoleFiber);
});
}
public void Should_run_the_action_immediately()
{
Fiber fiber = new ThreadPoolFiber();
FiberScheduler scheduler = new TimerFiberScheduler(new SynchronousFiber());
var called = new Future<bool>();
scheduler.Schedule(TimeSpan.Zero, fiber, () => called.Complete(true));
called.WaitUntilCompleted(1.Seconds()).ShouldBeTrue();
}
public void Should_result_in_no_waiting_actions_in_the_queue()
{
TraceLogProvider.Configure(LogLevel.Debug);
Fiber fiber = new ThreadPoolFiber();
fiber.Enqueue(() => Thread.Sleep(1000));
var called = new Future<bool>();
fiber.Enqueue(() => called.Complete(true));
fiber.ExecuteAll(8.Seconds());
called.IsCompleted.ShouldBeTrue();
}
public void Should_be_passable_to_another_action_queue()
{
Fiber fiber = new ThreadPoolFiber();
var timer = Stopwatch.StartNew();
Stopwatch inner = new Stopwatch();
Stopwatch dep = new Stopwatch();
try
{
using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
inner.Start();
DependentTransaction dependentClone = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
dependentClone.TransactionCompleted += (sender, args) =>
{
Trace.WriteLine("Completed");
};
fiber.Add(() =>
{
dep.Start();
try
{
//ThreadUtil.Sleep(20.Milliseconds());
Trace.WriteLine("complieing");
dependentClone.Complete();
dep.Stop();
Trace.WriteLine("done");
}
catch (Exception ex)
{
dependentClone.Rollback(ex);
}
finally
{
dependentClone.Dispose();
Trace.WriteLine("clone disposed");
}
});
scope.Complete();
Trace.WriteLine("scope complete");
}
Trace.WriteLine("all done");
}
catch (Exception)
{
}
inner.Stop();
timer.Stop();
Trace.WriteLine("Timer: " + (int)timer.ElapsedMilliseconds);
Trace.WriteLine("Inner: " + (int)inner.ElapsedMilliseconds);
Trace.WriteLine("Dep: " + (int)dep.ElapsedMilliseconds);
}
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 Should_be_passable_to_another_action_queue()
{
Fiber fiber = new ThreadPoolFiber();
var timer = Stopwatch.StartNew();
Stopwatch inner = new Stopwatch();
Stopwatch dep = new Stopwatch();
try
{
using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
inner.Start();
DependentTransaction dependentClone = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
dependentClone.TransactionCompleted += (sender,args) =>
{
Trace.WriteLine("Completed");
};
fiber.Add(() =>
{
dep.Start();
try
{
//ThreadUtil.Sleep(20.Milliseconds());
Trace.WriteLine("complieing");
dependentClone.Complete();
dep.Stop();
Trace.WriteLine("done");
}
catch (Exception ex)
{
dependentClone.Rollback(ex);
}
finally
{
dependentClone.Dispose();
Trace.WriteLine("clone disposed");
}
});
scope.Complete();
Trace.WriteLine("scope complete");
}
Trace.WriteLine("all done");
}
catch (Exception)
{
}
inner.Stop();
timer.Stop();
Trace.WriteLine("Timer: " + (int)timer.ElapsedMilliseconds);
Trace.WriteLine("Inner: " + (int)inner.ElapsedMilliseconds);
Trace.WriteLine("Dep: " + (int)dep.ElapsedMilliseconds);
}