public RabbitServiceTests(ITestOutputHelper output)
{
rabbitService = new RabbitService("Config.json");
rabbitService
.InitializeAsync("passwordforencryption", "saltforencryption")
.GetAwaiter().GetResult();
}
public static void Main(string[] args)
{
var recieveQueueName = "BasicTest";
RabbitService.RecieveMessage <List <EmployeeInternal> >(recieveQueueName, PrintEmployees);
Console.WriteLine("Press [Enter] to exit the Reciever App...");
Console.ReadLine();
}
public void Setup()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterModule(new MessagingCoreModule());
using (var container = containerBuilder.Build())
{
_sut = container.Resolve <RabbitService <DefaultRabbitPublisher, DefaultRabbitConsumer> >();
}
}
private static async Task RunSimpleClientWithEncryptionAsync()
{
await Console.Out.WriteLineAsync("Starting SimpleClient w/ Encryption...").ConfigureAwait(false);
var sentMessage = new TestMessage {
Message = "Sensitive Message"
};
var letter = new Letter("", "TestRabbitServiceQueue", JsonSerializer.SerializeToUtf8Bytes(sentMessage), new LetterMetadata());
var rabbitService = new RabbitService("Config.json", "passwordforencryption", "saltforencryption");
await rabbitService
.Topologer
.CreateQueueAsync("TestRabbitServiceQueue")
.ConfigureAwait(false);
// Queue the letter for delivery by the library.
await rabbitService
.Publisher
.QueueLetterAsync(letter);
// Start Consumer
var consumer = rabbitService.GetConsumer("ConsumerFromConfig");
await consumer
.StartConsumerAsync(false, true)
.ConfigureAwait(false);
// Get Message From Consumer
var receivedLetter = await consumer
.ReadAsync()
.ConfigureAwait(false);
// Do work with message inside the receivedLetter
var decodedLetter = JsonSerializer.Deserialize <TestMessage>(receivedLetter.Letter.Body);
await Console.Out.WriteLineAsync($"Sent: {sentMessage.Message}").ConfigureAwait(false);
await Console.Out.WriteLineAsync($"Received: {decodedLetter.Message}").ConfigureAwait(false);
// Acknowledge Message
if (receivedLetter.Ackable)
{
receivedLetter.AckMessage();
}
// Cleanup the queue
await rabbitService
.Topologer
.DeleteQueueAsync("TestRabbitServiceQueue")
.ConfigureAwait(false);
await Console.In.ReadLineAsync().ConfigureAwait(false);
}
public async Task ProductionBug_CantFindConsumer_WhenStartingMessageConsumers()
{
var rabbitService = new RabbitService("TestConfig.json", "passwordforencryption", "saltforencryption");
await rabbitService
.Topologer
.CreateTopologyFromFileAsync("TestTopologyConfig.json")
.ConfigureAwait(false);
var consumer = rabbitService.GetConsumer("TestMessageConsumer");
await consumer
.StartConsumerAsync(false, true)
.ConfigureAwait(false);
}
public static void Main(string[] args)
{
var employees = new List <Employee>();
employees.Add(new Employee("tomer", "12/08/1994", 26, "programmer"));
employees.Add(new Employee("ron", "26/5/1994", 26, "fireman"));
employees.Add(new Employee("yoni", "26/09/1990", 30, "waiter"));
var employeesToSend = CreateSendModels(employees);
var sendQueueName = "BasicTest";
RabbitService.SendMessage(employeesToSend, sendQueueName);
Console.WriteLine("\nPress [Enter] to exit the Sender App...");
Console.ReadLine();
}
public async Task BuildRabbitService_AndTopology()
{
var rabbitService = new RabbitService(
"TestConfig.json",
_fixture.SerializationProvider,
_fixture.EncryptionProvider,
_fixture.CompressionProvider);
await rabbitService
.Topologer
.CreateTopologyFromFileAsync("TestTopologyConfig.json")
.ConfigureAwait(false);
var consumer = rabbitService.GetConsumer("TestMessageConsumer");
await consumer
.StartConsumerAsync()
.ConfigureAwait(false);
}
public void ShouldApplySettingsToProperties()
{
// GIVEN - A rabbit service and a byte conversion service
var service = new RabbitService(
this.mockModelAccessor.Object,
this.mockConverter.Object,
this.mockPropertiesHandler.Object,
TestLogger.Create <RabbitService>()
);
// WHEN - Publish is called with a body object
service.Publish("body", "routing-key", "exchange");
// THEN - The byte conversion service should have been called with the body
this.mockPropertiesHandler.Verify(
propHand => propHand.ApplySettingsProperties(
It.IsAny <IBasicProperties>()
)
);
this.mockPropertiesHandler.VerifyNoOtherCalls();
}
private async Task <RabbitService> SetupAsync()
{
_hashingProvider = new Argon2IDHasher();
var hashKey = await _hashingProvider.GetHashKeyAsync("passwordforencryption", "saltforencryption", 32).ConfigureAwait(false);
_encryptionProvider = new AesGcmEncryptionProvider(hashKey, _hashingProvider.Type);
_compressionProvider = new GzipProvider();
_serializationProvider = new Utf8JsonProvider(StandardResolver.Default);
var letterTemplate = new Letter("", "TestRabbitServiceQueue", null, new LetterMetadata());
var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole().SetMinimumLevel(Program.LogLevel));
_logger = loggerFactory.CreateLogger <ConsumerPipelineMicroservice>();
var rabbitService = new RabbitService(
"Config.json",
_serializationProvider,
_encryptionProvider,
_compressionProvider,
loggerFactory);
await rabbitService
.Topologer
.CreateQueueAsync("TestRabbitServiceQueue")
.ConfigureAwait(false);
for (var i = 0L; i < _targetCount; i++)
{
var letter = letterTemplate.Clone();
letter.Body = JsonSerializer.SerializeToUtf8Bytes(new Message {
StringMessage = $"Sensitive ReceivedLetter {i}", MessageId = i
});
letter.LetterId = (ulong)i;
await rabbitService
.Publisher
.PublishAsync(letter, true, true)
.ConfigureAwait(false);
}
return(rabbitService);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole().SetMinimumLevel(LogLevel.Information));
var metricsProvider = new PrometheusMetricsProvider()
.AddDotNetRuntimeStats();
var serializationProvider = new Utf8JsonProvider();
var hashingProvider = new Argon2IDHasher();
var hashKey = hashingProvider
.GetHashKeyAsync("passwordforencryption", "saltforencryption", 32)
.GetAwaiter()
.GetResult();
var encryptionProvider = new AesGcmEncryptionProvider(hashKey, hashingProvider.Type);
var compressionProvider = new LZ4PickleProvider();
var rabbitService = new RabbitService(
"Config.json",
serializationProvider,
encryptionProvider,
compressionProvider,
loggerFactory);
services.AddSingleton(
s =>
{
return(new ConsumerDataflowService(
s.GetRequiredService <IConfiguration>(),
loggerFactory,
rabbitService,
serializationProvider,
compressionProvider,
encryptionProvider,
metricsProvider));
});
}
public async Task RabbitServiceCCDCTest()
{
var rabbitService = new RabbitService(
"Config.json",
Passphrase,
Salt);
var message = new Message {
StringMessage = $"Sensitive ReceivedLetter 0", MessageId = 0
};
var data = JsonSerializer.SerializeToUtf8Bytes(message);
var letter = new Letter("", "Test", data);
var letter2 = letter.Clone();
letter2.Body = JsonSerializer.SerializeToUtf8Bytes(message);
await rabbitService.ComcryptAsync(letter2);
await rabbitService.DecomcryptAsync(letter2);
Assert.Equal(letter.Body, letter2.Body);
}
public void ShouldConvertBody()
{
// GIVEN - A rabbit service and a byte conversion service
var body = new object();
var service = new RabbitService(
this.mockModelAccessor.Object,
this.mockConverter.Object,
this.mockPropertiesHandler.Object,
TestLogger.Create <RabbitService>()
);
// WHEN - Publish is called with a body object
service.Publish(body, "", "");
// THEN - The byte conversion service should have been called with the body
this.mockConverter.Verify(
con => con.ConvertToByteArray(
It.Is <object>(ob => ob == body)
)
);
this.mockConverter.VerifyNoOtherCalls();
}
public RabbitFixture()
{
CompressionProvider = new GzipProvider();
HashingProvider = new Argon2IDHasher();
HashKey = HashingProvider.GetHashKeyAsync(Passphrase, Salt, 32).GetAwaiter().GetResult();
EncryptionProvider = new AesGcmEncryptionProvider(HashKey, HashingProvider.Type);
SerializationProvider = new Utf8JsonProvider();
Options = JsonFileReader.ReadFileAsync <Options>("Config.json").GetAwaiter().GetResult();
RabbitService = new RabbitService(
Options,
SerializationProvider,
EncryptionProvider,
CompressionProvider,
LoggerFactory
.Create(
builder => builder.AddConsole().SetMinimumLevel(LogLevel.Information)));
ChannelPool = RabbitService.ChannelPool;
Topologer = RabbitService.Topologer;
Publisher = RabbitService.Publisher;
}
private static async Task RunDataExecutionEngineAsync()
{
await Console.Out.WriteLineAsync("Starting SimpleClient w/ Encryption As An DataExecutionEngine...").ConfigureAwait(false);
var letterTemplate = new Letter("", "TestRabbitServiceQueue", null, new LetterMetadata());
var rabbitService = new RabbitService("Config.json", "passwordforencryption", "saltforencryption");
await rabbitService
.Topologer
.CreateQueueAsync("TestRabbitServiceQueue")
.ConfigureAwait(false);
// Produce Messages
for (ulong i = 0; i < 100; i++)
{
var letter = letterTemplate.Clone();
letter.LetterId = i;
var sentMessage = new TestMessage {
Message = "Sensitive Message"
};
sentMessage.Message += $" {i}";
letter.Body = JsonSerializer.SerializeToUtf8Bytes(sentMessage);
await rabbitService
.Publisher
.QueueLetterAsync(letter);
}
// Start Consumer As An Execution Engine
var consumer = rabbitService.GetConsumer("ConsumerFromConfig");
await consumer
.StartConsumerAsync(false, true)
.ConfigureAwait(false);
_ = Task.Run(() => consumer.DataflowExecutionEngineAsync(ConsumerWorkerAsync, 7));
await Console.In.ReadLineAsync().ConfigureAwait(false);
}
public void TestClean()
{
_rabbitService = null;
}
public void Subscribe(string exchange, string queue, string routingKey, bool isProperties, Action <string, MqDirectKey> handler, bool isDeadLetter)
{
RabbitService.Subscribe(exchange, queue, routingKey, isProperties, handler, isDeadLetter);
}
public void Subscribe <T>(string queue, bool isProperties, Action <T> handler, bool isDeadLetter) where T : class
{
RabbitService.Subscribe(queue, isProperties, handler, isDeadLetter);
}
public void Subscribe <T>(Action <T> handler) where T : class
{
RabbitService.Subscribe(handler);
}
public void Pull(string exchange, string queue, string routingKey, Action <string, MqDirectKey> handler)
{
RabbitService.Pull(exchange, queue, routingKey, handler);
}
public void Pull <T>(Action <T> handler) where T : class
{
RabbitService.Pull(handler);
}
public void TestInit()
{
string rabbitServiceConfigJson = @"
{
'rabbitServerConfig':{
'nameSpace': null,
'host': 'localhost',
'altHost': null,
'virtualHost': null,
'username': null,
'password': null,
'port': null
},
'profiles':{
'proto':{
'basicProperties': {
'appId': 'protoAppId',
'contentType': 'application/x-protobuf',
'contentEncoding': null,
'clusterId': null,
'correlationId': null,
'expiration': null,
'persist': true,
'enableMessageId': true,
'enableTimestamp': true,
'type': null,
'headers': {
'x-test': 'x-test-value'
}
},
'profileQueue': {
'queue': 'proto',
'durable': true,
'exclusive': false,
'autoDelete': false
},
'name': 'proto',
'routeKey': 'proto',
'userAgent': 'proto-aggregator-useragent',
'exchange': null,
'deadLetterExchange': null,
'maxQueueLength': 1000000,
'args': {
'x-arg': 'x-arg-value'
}
}
}
}";
/*
*
* _factory = new ConnectionFactory
* {
* UserName = userName,
* Password = password,
* HostName = hostName,
* VirtualHost = virtualhost,
* Port = port
* };
*/
RabbitServiceConfig rabbitServiceConfig =
JsonConvert.DeserializeObject <RabbitServiceConfig>(rabbitServiceConfigJson);
_rabbitService = new RabbitService(rabbitServiceConfig);
}
public RabbitServiceTests(ITestOutputHelper output)
{
rabbitService = new RabbitService("TestConfig.json", "passwordforencryption", "saltforencryption");
}
