Beispiel #1
0
        public SomeActorInstance()
        {
            _queue = new ThreadPoolActionQueue();
            _future = new Future<MyMessage>();

            MessageChannel = new ConsumerChannel<MyMessage>(_queue, Consume);
            LambdaMessageChannel = new ConsumerChannel<MyMessage>(_queue, message => _future.Complete(message));
        }
Beispiel #2
0
            public Pinger()
            {
                _queue = new ThreadPoolActionQueue();

                Ponged = new Future<Pong>();

                PongChannel = new ConsumerChannel<Pong>(_queue, HandlePong);
            }
Beispiel #3
0
        public void Should_not_stall_the_scheduler()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(200.Milliseconds(), queue, () => { throw new InvalidOperationException("Bugger!"); });
            scheduler.Schedule(400.Milliseconds(), queue, () => called.Complete(true));

            called.IsAvailable(1.Seconds()).ShouldBeTrue();
        }
Beispiel #4
0
        public void Should_wait_until_the_appropriate_time_for_the_action_to_execute()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new SynchronousActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(100.Milliseconds(), queue, () => called.Complete(true));

            called.IsAvailable(0.Seconds()).ShouldBeFalse();

            called.IsAvailable(1.Seconds()).ShouldBeTrue();
        }
Beispiel #5
0
        public void Should_not_run_any_pending_actions()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(1.Seconds(), queue, () => called.Complete(true));

            scheduler.Disable();

            called.IsAvailable(2.Seconds()).ShouldBeFalse();
        }
Beispiel #6
0
        public void Should_prevent_new_actions_from_being_queued()
        {
            ActionQueue queue = new ThreadPoolActionQueue();

            var called = new Future<bool>();

            queue.StopAcceptingActions();

            Assert.Throws<ActionQueueException>(() => queue.Enqueue(() => called.Complete(true)));

            queue.ExecuteAll(10.Seconds());

            called.IsAvailable().ShouldBeFalse();
        }
Beispiel #7
0
        public void Should_result_in_an_exception()
        {
            var action = MockRepository.GenerateMock<Action>();

            var queue = new ThreadPoolActionQueue(2, 0);
            queue.Enqueue(action);
            queue.Enqueue(action);

            try
            {
                queue.Enqueue(action);
                Assert.Fail("Should have thrown an exception");
            }
            catch (ActionQueueException ex)
            {
                ex.Message.Contains("Insufficient").ShouldBeTrue();
            }
        }
Beispiel #8
0
        public void Should_result_in_no_waiting_actions_in_the_queue()
        {
            TraceLogProvider.Configure(LogLevel.Debug);

            ActionQueue queue = new ThreadPoolActionQueue();

            queue.Enqueue(() => Thread.Sleep(1000));

            var called = new Future<bool>();

            queue.Enqueue(() => called.Complete(true));

            queue.ExecuteAll(8.Seconds());

            called.IsAvailable().ShouldBeTrue();
        }
Beispiel #9
0
        public void Should_run_the_action_immediately()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new SynchronousActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(TimeSpan.Zero, queue, () => called.Complete(true));

            called.IsAvailable(1.Seconds()).ShouldBeTrue();
        }
Beispiel #10
0
        public void Should_run_the_action_until_disabled()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());

            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(), queue, () =>
                {
                    count++;
                    if (count == 10)
                    {
                        called.Complete(count);
                        scheduledAction.Cancel();
                    }
                    else if (count > 10)
                    {
                        failed.Complete(true);
                    }
                });

            called.IsAvailable(5.Seconds()).ShouldBeTrue();

            elapsed.Stop();

            failed.IsAvailable(200.Milliseconds()).ShouldBeFalse();

            Trace.WriteLine("Time Period: " + elapsed.ElapsedMilliseconds);
        }