public void Dequeue()
{
var setup = new QueueSetup <object>()
{
Name = "test",
Priority = QueuePriority.High,
};
var random = new Random();
var scale = new Range <byte>();
scale.Maximum = (byte)random.Next(byte.MinValue, byte.MaxValue);
scale.Minimum = (byte)random.Next(byte.MinValue, scale.Maximum);
var throughput = Substitute.For <IQueueThroughput>();
throughput.Scale(setup.Priority).Returns(scale);
throughput.CheckScaleEvery(setup.Priority).Returns((byte)random.Next(1, 300));
var f = new DequeueFactory(ConnectionString, throughput);
var task = f.Dequeue <object>(setup);
Assert.IsNotNull(task);
var scaler = task as StorageQueueAutoScaler <object>;
Assert.IsNotNull(scaler);
Assert.AreEqual(scale.Minimum, scaler.InstanceCount.Minimum);
Assert.AreEqual(scale.Maximum, scaler.InstanceCount.Maximum);
throughput.Received().Scale(setup.Priority);
throughput.Received().CheckScaleEvery(setup.Priority);
}
public IEnumerable <IRunnable> Tasks(AppConfig config)
{
// List of tasks to run
var tasks = new List <IRunnable>(new IRunnable[] {
// Initialization task
new InitTask(),
// Initialize Table; creates table if it doesn't already exist
new InitializeStorageTask(new TableStorage(config.TableName, config.ConnectionString)),
// Initialize Container; creates container if it doesn't already exist
new InitializeStorageTask(new Container(config.ContainerName, config.ConnectionString)),
// Initialize Container; creates container if it doesn't already exist
new InitializeStorageTask(new StorageQueue(config.GenericQueueName, config.ConnectionString)),
//basic task
new Recurring(),
//Task once daily on the (specified/current) hour
new OnceDaily(config.ConnectionString),
//Backoff task
new Backoff(),
//Self governing task
new Adaptive(),
//Dequeue task, Backoff behavior
new BackoffRunner(new CompanyDequeuer(config.GenericQueueName, config.ConnectionString)),
//Dequeue task, Adaptive behavior
new AdaptiveRunner(new CompanyDequeuer(config.GenericQueueName, config.ConnectionString)),
//Dequeue task, Recurring behavior
new RecurringRunner(new CompanyDequeuer(config.GenericQueueName, config.ConnectionString)),
//Auto Scaling Task
new DynamicScaler(config),
});
///Dequeue examples
var f = new DequeueFactory(config.ConnectionString);
tasks.AddRange(f.Dequeue <CompanyProcessor, CompanyModel>(config.SlowQueueName));
tasks.AddRange(f.Dequeue <CompanyProcessor, CompanyModel>(config.ModerateQueueName, QueuePriority.Medium));
tasks.AddRange(f.Dequeue <CompanyProcessor, CompanyModel>(config.FastQueueName, QueuePriority.High));
tasks.AddRange(f.Shards <CompanyProcessor, CompanyModel>(config.ShardQueueName, 10));
//Cordinated Tasks between Instances
var coordinated = new Coordinated(config.ConnectionString);
// Add once to ensure that Table is created for Instances to communicate with
tasks.AddRange(coordinated.Tasks());
// Add your coordinated task
tasks.Add(coordinated);
return(tasks);
}
public void InitializeNames()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Initialize(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
Assert.IsNotNull(tasks);
Assert.AreEqual(3, tasks.Count());
}
public void InitializeName()
{
var f = new DequeueFactory(ConnectionString);
var task = f.Initialize(Guid.NewGuid().ToString());
Assert.IsNotNull(task);
Assert.IsNotNull(task as InitializeStorageTask);
}
public void TasksSetupsNull()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks <object>((IEnumerable <QueueSetup <object> >)null);
Assert.IsNotNull(tasks);
Assert.That(() => tasks.Count(), Throws.TypeOf <ArgumentNullException>());
}
public void InitializeNamesNull()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Initialize((string[])null);
Assert.IsNotNull(tasks);
Assert.That(() => tasks.Count(), Throws.TypeOf <ArgumentNullException>());
}
/// <summary>
/// Load Tasks
/// </summary>
/// <param name="config">Task Configuration</param>
/// <returns>Runnable Tasks</returns>
public virtual IEnumerable <IRunnable> Tasks(ITaskConfiguration config)
{
var tasks = new List <IRunnable>();
tasks.AddRange(this.Initialize(config));
var factory = new DequeueFactory(config.ConnectionString);
tasks.AddRange(factory.Tasks <ImageQueued>(new ImageDequeueSetup(config)));
return(tasks);
}
public void ShardsZeroCount()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Shards <HelpP, object>("testing", 0);
Assert.IsNotNull(tasks);
Assert.AreEqual(2 * 2, tasks.Count());
var t = (from n in tasks
where n.GetType() == typeof(InitializeStorageTask)
select true).FirstOrDefault();
Assert.IsTrue(t);
}
public void TasksSimple()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks <object>("test", () => { return(null); });
Assert.IsNotNull(tasks);
Assert.AreEqual(2, tasks.Count());
var t = (from n in tasks
where n.GetType() == typeof(InitializeStorageTask)
select true).FirstOrDefault();
Assert.IsTrue(t);
}
public void Tasks()
{
var setup = new QueueSetup <object>()
{
Name = "test",
Priority = QueuePriority.Low,
};
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks(setup);
Assert.IsNotNull(tasks);
Assert.AreEqual(2, tasks.Count());
var t = (from n in tasks
where n.GetType() == typeof(InitializeStorageTask)
select true).FirstOrDefault();
Assert.IsTrue(t);
}
public void Tasks()
{
var setup = new QueueSetup<object>()
{
Name = "test",
Priority = QueuePriority.Low,
};
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks(setup);
Assert.IsNotNull(tasks);
Assert.AreEqual(2, tasks.Count());
var t = (from n in tasks
where n.GetType() == typeof(InitializeStorageTask)
select true).FirstOrDefault();
Assert.IsTrue(t);
}
public void TasksMultiple()
{
var random = new Random();
var count = random.Next(1, 20);
var setups = new List<IQueueSetup<object>>();
for (var i = 0; i < count; i++)
{
var setup = new QueueSetup<object>()
{
Name = "test",
Priority = QueuePriority.Low,
};
setups.Add(setup);
}
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks(setups);
Assert.IsNotNull(tasks);
Assert.AreEqual(count * 2, tasks.Count());
}
public void TasksMultiple()
{
var random = new Random();
var count = random.Next(1, 20);
var setups = new List <IQueueSetup <object> >();
for (var i = 0; i < count; i++)
{
var setup = new QueueSetup <object>()
{
Name = "test",
Priority = QueuePriority.Low,
};
setups.Add(setup);
}
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks(setups);
Assert.IsNotNull(tasks);
Assert.AreEqual(count * 2, tasks.Count());
}
public void TasksSetupsNull()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks<object>((IEnumerable<QueueSetup<object>>)null);
Assert.IsNotNull(tasks);
Assert.AreEqual(2, tasks.Count());
}
public void TasksSimpleProcessorNull()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks<object>("test", null);
Assert.IsNotNull(tasks);
Assert.AreEqual(2, tasks.Count());
var t = (from n in tasks
where n.GetType() == typeof(InitializeStorageTask)
select true).FirstOrDefault();
Assert.IsTrue(t);
}
public void TasksSimpleQueueNameNull()
{
var f = new DequeueFactory(ConnectionString);
var tasks = f.Tasks<object>(null, () => { return null; });
}
public void DequeueTaskSetupNull()
{
var df = new DequeueFactory(ConnectionString);
df.Dequeue<object>(null);
}
public void Dequeue()
{
var setup = new QueueSetup<object>()
{
Name = "test",
Priority = QueuePriority.High,
};
var random = new Random();
var scale = new Range<byte>();
scale.Maximum = (byte)random.Next(byte.MinValue, byte.MaxValue);
scale.Minimum = (byte)random.Next(byte.MinValue, scale.Maximum);
var throughput = Substitute.For<IQueueThroughput>();
throughput.Scale(setup.Priority).Returns(scale);
throughput.CheckScaleEvery(setup.Priority).Returns((byte)random.Next(1, 300));
var f = new DequeueFactory(ConnectionString, throughput);
var task = f.Dequeue<object>(setup);
Assert.IsNotNull(task);
var scaler = task as StorageQueueAutoScaler<object>;
Assert.IsNotNull(scaler);
Assert.AreEqual(scale.Minimum, scaler.InstanceCount.Minimum);
Assert.AreEqual(scale.Maximum, scaler.InstanceCount.Maximum);
throughput.Received().Scale(setup.Priority);
throughput.Received().CheckScaleEvery(setup.Priority);
}
public void TasksSimpleProcessorNull()
{
var f = new DequeueFactory(ConnectionString);
Assert.That(() => f.Tasks <object>("test", null), Throws.TypeOf <ArgumentNullException>());
}
public void TasksSimpleQueueNameNull()
{
var f = new DequeueFactory(ConnectionString);
Assert.That(() => f.Tasks <object>(null, () => { return(null); }), Throws.TypeOf <ArgumentException>());
}
public void DequeueTaskSetupNull()
{
var df = new DequeueFactory(ConnectionString);
Assert.That(() => df.Dequeue <object>(null), Throws.TypeOf <ArgumentNullException>());
}
public void InitializeNameNull()
{
var f = new DequeueFactory(ConnectionString);
Assert.That(() => f.Initialize((string)null), Throws.TypeOf <ArgumentException>());
}
public void ShardsNameNull()
{
var f = new DequeueFactory(ConnectionString);
Assert.That(() => f.Shards <HelpP, object>(null), Throws.TypeOf <ArgumentException>());
}
