public void Route(ExecutionEnvelope envelope)
{
Contract.Require(envelope != null, "envelope != null");
var result = _matcher.TryMatch(envelope.Task);
if (!result)
{
throw new InvalidOperationException(string.Format("Task {0} does not match any executor", envelope.Task));
}
IExecutorImplementation executor = null;
var executorName = result.Value;
if (_executors.TryGetValue(executorName, out executor))
{
if (Logger.IsDebugEnabled)
{
Logger.Debug("Task {0} routed to {1}", envelope.Task, executor.Name);
}
envelope.Region = executor.Region;
executor.Enqueue(envelope);
}
else
{
var message = string.Format("Not found executor '{0}' for task {1}", executorName, envelope.Task);
throw new InvalidOperationException(message);
}
}
public void Setup()
{
_queuedExecutorSettings = new QueuedExecutorSettings{Name = "test"};
_queue = new QueuedExecutor(_queuedExecutorSettings, NullPersister.Instance);
_queue.TaskAdded += delegate { };
_task = new LongRunningTask(true);
_executionEnvelope = new ExecutionEnvelope(_task, DefaultReleaser.Instance);
}
public void Release()
{
Contract.Require(TplTask != null, "TplTask != null");
Contract.Require(_ownedCellIndex > Free, "_ownedCellIndex > Free");
CurrentTask = null;
TplTask = null;
_ownedCellIndex = Free;
}
public void Returns_enqueued_task_if_added()
{
int dequeed = int.MinValue;
var queue = new QueuedExecutor(_queuedExecutorSettings, NullPersister.Instance);
queue.TaskAdded += delegate { };
var expected = new ExecutionEnvelope(new LongRunningTask(false), DefaultReleaser.Instance);
queue.Enqueue(expected);
var task = queue.Dequeue();
Assert.That(task, Is.SameAs(expected));
}
public void Enqueue(ExecutionEnvelope envelope)
{
Execute(envelope.Task);
}
public void When_task_completed_allow_to_take_next_task()
{
var queue = new QueuedExecutor(_queuedExecutorSettings, NullPersister.Instance);
queue.TaskAdded += delegate { };
var task1 = new LongRunningTask(false);
var task2 = new LongRunningTask(false);
var envelope1 = new ExecutionEnvelope(task1, DefaultReleaser.Instance);
queue.Enqueue(envelope1);
var envelope2 = new ExecutionEnvelope(task2, DefaultReleaser.Instance);
queue.Enqueue(envelope2);
var extracted = queue.Dequeue();
extracted.ExecuteTask();
Assert.That(queue.Dequeue(), Is.SameAs(envelope2));
}
public void Starts_thread_if_a_task_added()
{
var task = new LongRunningTask(false);
var envelope = new ExecutionEnvelope(task, DefaultReleaser.Instance);
_queue.Enqueue(envelope);
task.WaitForFinish();
Assert.That(task.Executed, Is.True);
}
private void AfterExecute(ExecutionEnvelope envelope)
{
Interlocked.Decrement(ref _currentConcurrency);
if (envelope.Persistent)
{
_persister.Delete(envelope.Id);
}
}
public void Enqueue(ExecutionEnvelope envelope)
{
Contract.Require(envelope != null, "envelope != null");
Contract.Require(TaskAdded != null, "TaskAdded != null");
if (_persister.IsPersistent(envelope.Task))
{
envelope.Persistent = true;
_persister.Persist(envelope.Id, envelope.Task);
}
//TODO Consider reusing wraps to decrease workload on GC.
envelope.AfterExecute += AfterExecute;
_queue.Enqueue(envelope);
if(_currentConcurrency > _settings.MaxConcurrency) return;
TaskAdded(this);
}
