public void DequeueTask()
{
var setup = new QueueSetup<object>
{
Name = "test",
Priority = QueuePriority.High,
};
var random = new Random();
var max = (byte)random.Next(byte.MinValue, byte.MaxValue);
var min = (byte)random.Next(byte.MinValue, max);
var throughput = Substitute.For<IQueueThroughput>();
throughput.Scale(setup.Priority).Returns(new Range<byte>(min, max));
throughput.CheckScaleEvery(setup.Priority).Returns<byte>(1);
var f = new BusDequeueFactory(ConnectionString, throughput);
var task = f.Dequeue<object>(setup);
Assert.IsNotNull(task);
var scaler = task as BusQueueAutoScaler<object>;
Assert.IsNotNull(scaler);
throughput.Received().Scale(setup.Priority);
throughput.Received().CheckScaleEvery(setup.Priority);
}
public void DequeueTask()
{
var setup = new QueueSetup <object>
{
Name = "test",
Priority = QueuePriority.High,
};
var random = new Random();
var max = (byte)random.Next(byte.MinValue, byte.MaxValue);
var min = (byte)random.Next(byte.MinValue, max);
var throughput = Substitute.For <IQueueThroughput>();
throughput.Scale(setup.Priority).Returns(new Range <byte>(min, max));
throughput.CheckScaleEvery(setup.Priority).Returns <byte>(1);
var f = new BusDequeueFactory(ConnectionString, throughput);
var task = f.Dequeue <object>(setup);
Assert.IsNotNull(task);
var scaler = task as BusQueueAutoScaler <object>;
Assert.IsNotNull(scaler);
throughput.Received().Scale(setup.Priority);
throughput.Received().CheckScaleEvery(setup.Priority);
}
public void Runs()
{
var random = new Random();
var max = (byte)random.Next(byte.MinValue, byte.MaxValue);
var min = (byte)random.Next(byte.MinValue, max);
var count = Substitute.For <IQueueCount>();
var setup = new QueueSetup <object>
{
Name = "test",
Priority = QueuePriority.Low,
Processor = () => { return(Substitute.For <IProcessor <object> >()); },
};
var connection = new QueueConnection <object>()
{
ConnectionString = ConnectionString,
Setup = setup,
};
var throughput = Substitute.For <IQueueThroughput>();
throughput.Frequency(setup.Priority).Returns(new Range <byte>(min, max));
var s = new BusQueueAutoScaler <object>(count, connection, throughput);
var runs = s.Runs(connection);
Assert.IsNotNull(runs);
Assert.AreEqual(min, runs.MinimumPeriodInSeconds);
Assert.AreEqual(max, runs.MaximumPeriodInSeconds);
throughput.Received().Frequency(setup.Priority);
}
public void DeclareRpcQueue(QueueSetup setup)
{
InitialiseRpcQueue(setup.QueueName, setup.Qos, out var consumer, out var channel);
consumer.Received += async(model, eventArgs) =>
{
try
{
var headers = eventArgs.BasicProperties.Headers.ToDictionary(
t => t.Key,
t => Encoding.UTF8.GetString(t.Value as byte[]));
var body = Encoding.UTF8.GetString(eventArgs.Body.ToArray());
var basicProperties = eventArgs.BasicProperties;
var properties = channel.CreateBasicProperties();
properties.CorrelationId = basicProperties.CorrelationId;
try
{
Enum.TryParse(headers[nameof(MessageType)], out MessageType type);
var data = await Processors[type].Invoke(body);
PublishAndAcknowledge(channel, basicProperties, properties, data, eventArgs);
}
catch (Exception e)
{
m_logger.LogError(e, $"Could not finish a remote request : {JsonConvert.SerializeObject(headers)}");
PublishAndAcknowledge(channel, basicProperties, properties, new RabbitResponse(), eventArgs);
}
}
catch (Exception e)
{
m_logger.LogCritical(e, $"Could not extract request information for {setup.QueueName}");
}
};
}
public void Runs()
{
var random = new Random();
var max = (byte)random.Next(byte.MinValue, byte.MaxValue);
var min = (byte)random.Next(byte.MinValue, max);
var count = Substitute.For<IQueueCount>();
var setup = new QueueSetup<object>
{
Name = "test",
Priority = QueuePriority.Low,
Processor = () => { return Substitute.For<IProcessor<object>>(); },
};
var connection = new QueueConnection<object>()
{
ConnectionString = ConnectionString,
Setup = setup,
};
var throughput = Substitute.For<IQueueThroughput>();
throughput.Frequency(setup.Priority).Returns(new Range<byte>(min, max));
var s = new BusQueueAutoScaler<object>(count, connection, throughput);
var runs = s.Runs(connection);
Assert.IsNotNull(runs);
Assert.AreEqual(min, runs.MinimumPeriodInSeconds);
Assert.AreEqual(max, runs.MaximumPeriodInSeconds);
throughput.Received().Frequency(setup.Priority);
}
public void Runs()
{
var random = new Random();
var frequency = new Range<byte>();
frequency.Maximum = (byte)random.Next(byte.MinValue, byte.MaxValue);
frequency.Minimum = (byte)random.Next(byte.MinValue, frequency.Maximum);
var count = Substitute.For<IQueueCount>();
var setup = new QueueSetup<object>()
{
Priority = QueuePriority.High,
Name = Guid.NewGuid().ToString(),
Processor = () => { return Substitute.For<IProcessor<object>>(); },
};
var connection = new QueueConnection<object>()
{
Setup = setup,
ConnectionString = ConnectionString,
};
var throughput = Substitute.For<IQueueThroughput>();
throughput.Frequency(setup.Priority).Returns(frequency);
var s = new StorageQueueAutoScaler<object>(count, connection, throughput);
var runs = s.Runs(connection);
Assert.IsNotNull(runs);
Assert.AreEqual(frequency.Minimum, runs.MinimumPeriodInSeconds);
Assert.AreEqual(frequency.Maximum, runs.MaximumPeriodInSeconds);
throughput.Received().Frequency(setup.Priority);
}
public void Runs()
{
var random = new Random();
var frequency = new Range <byte>();
frequency.Maximum = (byte)random.Next(byte.MinValue, byte.MaxValue);
frequency.Minimum = (byte)random.Next(byte.MinValue, frequency.Maximum);
var count = Substitute.For <IQueueCount>();
var setup = new QueueSetup <object>()
{
Priority = QueuePriority.High,
Name = Guid.NewGuid().ToString(),
Processor = () => { return(Substitute.For <IProcessor <object> >()); },
};
var connection = new QueueConnection <object>()
{
Setup = setup,
ConnectionString = ConnectionString,
};
var throughput = Substitute.For <IQueueThroughput>();
throughput.Frequency(setup.Priority).Returns(frequency);
var s = new StorageQueueAutoScaler <object>(count, connection, throughput);
var runs = s.Runs(connection);
Assert.IsNotNull(runs);
Assert.AreEqual(frequency.Minimum, runs.MinimumPeriodInSeconds);
Assert.AreEqual(frequency.Maximum, runs.MaximumPeriodInSeconds);
throughput.Received().Frequency(setup.Priority);
}
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 Setup()
{
var expected = new QueueSetup<object>();
var qc = new QueueConnection<object>()
{
Setup = expected,
};
Assert.AreEqual(expected, qc.Setup);
}
public void Processor()
{
Func<IProcessor<object>> expected = () => { return null; };
var qc = new QueueSetup<object>()
{
Processor = expected,
};
Assert.AreEqual(expected, qc.Processor);
}
public void Name()
{
var expected = Guid.NewGuid().ToString();
var qc = new QueueSetup<object>()
{
Name = expected,
};
Assert.AreEqual(expected, qc.Name);
}
public void Processor()
{
Func <IProcessor <object> > expected = () => { return(null); };
var qc = new QueueSetup <object>()
{
Processor = expected,
};
Assert.AreEqual(expected, qc.Processor);
}
public void Setup()
{
var expected = new QueueSetup <object>();
var qc = new QueueConnection <object>()
{
Setup = expected,
};
Assert.AreEqual(expected, qc.Setup);
}
public void Priority()
{
var expected = QueuePriority.High;
var qc = new QueueSetup <object>()
{
Priority = expected,
};
Assert.AreEqual(expected, qc.Priority);
}
public void Name()
{
var expected = Guid.NewGuid().ToString();
var qc = new QueueSetup <object>()
{
Name = expected,
};
Assert.AreEqual(expected, qc.Name);
}
public void Priority()
{
var expected = QueuePriority.High;
var qc = new QueueSetup<object>()
{
Priority = expected,
};
Assert.AreEqual(expected, qc.Priority);
}
private void SetupExchangeAndQueue(IModel channel)
{
channel.ExchangeDeclare(this.queueConfig.Exchange, ExchangeType.Direct);
var queueSetup = new QueueSetup(this.queueConfig);
queueSetup.DeclareQueue(channel);
channel.QueueBind(
queue: this.queueConfig.QueueName,
exchange: this.queueConfig.Exchange,
routingKey: this.queueConfig.DefaultRoutingKey,
arguments: null);
}
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 StartListening()
{
this.logger.LogDebug("Initializing connection to {host}", this.queueConnectionFactory.HostName);
using (var queueConn = this.queueConnectionFactory.CreateConnection())
using (var queueChannel = queueConn.CreateModel())
{
this.logger.LogDebug(
"Connected to {host}. Declaring queue {queue}",
queueConn.Endpoint.HostName,
this.queueConfig.QueueName);
var queueSetup = new QueueSetup(this.queueConfig);
queueSetup.DeclareQueue(queueChannel);
var queueConsumer = new AsyncEventingBasicConsumer(queueChannel);
queueConsumer.Received += async(sender, e) =>
{
await ProcessMessage(queueChannel, e);
};
this.logger.LogInformation(
"Monitoring queue {queue} on {host}",
this.queueConfig.QueueName,
queueConn.Endpoint.HostName);
queueChannel.BasicQos(
prefetchCount: this.queueConfig.PrefetchCount,
prefetchSize: 0,
global: true);
queueChannel.BasicConsume(
queue: this.queueConfig.QueueName,
autoAck: false,
consumer: queueConsumer);
Console.ReadLine();
}
}
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 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 DeclareQueue(QueueSetup queueSetup)
{
InitialiseQueue(queueSetup.QueueName, queueSetup.Qos, out _);
}
