public static IServiceCollection AddMessageQueue(
this IServiceCollection services,
Action <MessageQueueConfiguration> configure)
{
var configuration = new MessageQueueConfiguration(services);
configure(configuration);
return(services
.AddSingleton <ConnectionFactory>()
.AddSingleton <IMessageQueueService>(sp =>
{
var connectionFactory = sp.GetRequiredService <ConnectionFactory>();
var queueOptions = sp.GetRequiredService <IOptions <MessageQueueOptions> >().Value;
var options = ConnectionFactory.GetDefaultOptions();
options.Url = queueOptions.Url;
return ActivatorUtilities.CreateInstance <MessageQueueService>(sp, connectionFactory.CreateConnection(options));
})
.AddHostedService <MessageQueueBackground>()
.AddOptions <MessageQueueOptions>()
.Configure(configuration.OptionsConfigure)
.Services);
}
public EventBusService(IServiceBusPersisterConnection serviceBusPersisterConnection,
IEventBusSubscriptionsManager subscriptionsManager,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
MessageQueueConfiguration messageQueueConfiguration,
EventPublishConfiguration eventPublishConfiguration)
{
_topicConnection = serviceBusPersisterConnection.TopicConnection;
_queueConnection = serviceBusPersisterConnection.QueueConnection;
_subscriptionsManager = subscriptionsManager;
_serviceProvider = serviceProvider;
_messageQueueConfiguration = messageQueueConfiguration;
_eventPublishConfiguration = eventPublishConfiguration;
_logger = loggerFactory.CreateLogger(GetType());
}
/// <summary>
/// Initializes an instance of the <see cref="ClientMessageProcessor"/> class.
/// </summary>
/// <param name="messageToServiceMapper">The message to service mapper.</param>
/// <param name="messageSerializer">The message serializer.</param>
/// <param name="messageQueueConfigurationOptions">The message queue configuration options.</param>
/// <param name="serviceMessageProcessor">The service message processor.</param>
/// <param name="messageTypeCache">The message type cache.</param>
/// <param name="clientMessageProcessorLogger">The client message processor logger.</param>
/// <param name="sslWSNetworkConnectorLogger">The ssl websocket network connector logger.</param>
/// <param name="wsHandshakeLogger">The websocket handshake logger.</param>
public ClientMessageProcessor(
IMessageToServiceMapper messageToServiceMapper,
IMessageSerializer messageSerializer,
IOptions <MessageQueueConfiguration> messageQueueConfigurationOptions,
IServiceMessageProcessor serviceMessageProcessor,
IClientMessageTypeCache messageTypeCache,
ILogger <ClientMessageProcessor> clientMessageProcessorLogger,
ILogger <SslWSNetworkConnector> sslWSNetworkConnectorLogger,
ILogger <NeuralmWSHandshakeHandler> wsHandshakeLogger)
{
_messageToServiceMapper = messageToServiceMapper;
_messageSerializer = messageSerializer;
_messageQueueConfiguration = messageQueueConfigurationOptions.Value;
_serviceMessageProcessor = serviceMessageProcessor;
_messageTypeCache = messageTypeCache;
_clientMessageProcessorLogger = clientMessageProcessorLogger;
_sslWSNetworkConnectorLogger = sslWSNetworkConnectorLogger;
_wsHandshakeLogger = wsHandshakeLogger;
_tcpListener = new TcpListener(IPAddress.Any, _messageQueueConfiguration.Port);
}
/// <summary>
/// Helper method to collect and validate common configuration parameters.
/// </summary>
public static void CollectCommonConfiguration(ref Dictionary <string, string> rawConfiguration, MessageQueueConfiguration configuration, IEnumerable <string> allowedKeys)
{
#region Parameters Validation & Collection
if (configuration != null)
{
allowedKeys = allowedKeys ?? new List <string>();
rawConfiguration = rawConfiguration ?? new Dictionary <string, string>();
var notSupportedParams =
rawConfiguration.Keys.Where(x => !CommonConfigurationKeys.GetAllKeys().Contains(x) && !allowedKeys.Contains(x)).ToList();
if (notSupportedParams.Any())
{
throw new QueueException(QueueErrorCode.NotSupportedConfigurationParameters,
ErrorMessages.NotSupportedConfigurationParameters,
context: new Dictionary <string, string>
{
[CommonContextKeys.NotSupportedParameters] = string.Join(",", notSupportedParams)
});
}
// Address
if (!rawConfiguration.ContainsKey(CommonConfigurationKeys.Address) ||
string.IsNullOrWhiteSpace(rawConfiguration[CommonConfigurationKeys.Address]))
{
throw new QueueException(QueueErrorCode.MissingRequiredConfigurationParameter,
string.Format(ErrorMessages.MissingRequiredConfigurationParameter, CommonConfigurationKeys.Address),
context: new Dictionary <string, string>
{
[CommonContextKeys.ParameterName] = CommonConfigurationKeys.Address
});
}
configuration.Address = rawConfiguration[CommonConfigurationKeys.Address];
}
#endregion
}
public void Startup()
{
//
// get configuration information
//
MessageQueueAppConfig messageQueueAppConfig = new MessageQueueAppConfig();
ConnectionStrings connectionStrings = new ConnectionStrings();
var basePath = PlatformServices.Default.Application.ApplicationBasePath;
if (basePath.ToLower().Contains("salesordermanagementqa"))
{
CodeProject.Shared.Common.Models.AppSettings.MessageQueueAppSettings appSettings = new CodeProject.Shared.Common.Models.AppSettings.MessageQueueAppSettings();
string readContents;
using (StreamReader streamReader = new StreamReader(basePath + @"\AppSettings.QA.json", Encoding.UTF8))
{
readContents = streamReader.ReadToEnd();
}
appSettings = CodeProject.Shared.Common.Utilities.SerializationFunction <CodeProject.Shared.Common.Models.AppSettings.MessageQueueAppSettings> .ReturnObjectFromString(readContents);
messageQueueAppConfig.MessageQueueHostName = appSettings.MessageQueueAppConfig.MessageQueueHostName;
messageQueueAppConfig.MessageQueueUserName = appSettings.MessageQueueAppConfig.MessageQueueUserName;
messageQueueAppConfig.MessageQueuePassword = appSettings.MessageQueueAppConfig.MessageQueuePassword;
messageQueueAppConfig.MessageQueueEnvironment = appSettings.MessageQueueAppConfig.MessageQueueEnvironment;
messageQueueAppConfig.ExchangeName = appSettings.MessageQueueAppConfig.ExchangeName;
messageQueueAppConfig.RoutingKey = appSettings.MessageQueueAppConfig.RoutingKey;
messageQueueAppConfig.InboundMessageQueue = appSettings.MessageQueueAppConfig.InboundMessageQueue;
messageQueueAppConfig.OutboundMessageQueues = appSettings.MessageQueueAppConfig.OutboundMessageQueues;
messageQueueAppConfig.LoggingExchangeName = appSettings.MessageQueueAppConfig.LoggingExchangeName;
messageQueueAppConfig.LoggingMessageQueue = appSettings.MessageQueueAppConfig.LoggingMessageQueue;
messageQueueAppConfig.OriginatingQueueName = appSettings.MessageQueueAppConfig.OriginatingQueueName;
messageQueueAppConfig.SendToLoggingQueue = appSettings.MessageQueueAppConfig.SendToLoggingQueue;
messageQueueAppConfig.AcknowledgementMessageExchangeSuffix = appSettings.MessageQueueAppConfig.AcknowledgementMessageExchangeSuffix;
messageQueueAppConfig.AcknowledgementMessageQueueSuffix = appSettings.MessageQueueAppConfig.AcknowledgementMessageQueueSuffix;
messageQueueAppConfig.TriggerExchangeName = appSettings.MessageQueueAppConfig.TriggerExchangeName;
messageQueueAppConfig.TriggerQueueName = appSettings.MessageQueueAppConfig.TriggerQueueName;
messageQueueAppConfig.QueueImmediately = appSettings.MessageQueueAppConfig.QueueImmediately;
messageQueueAppConfig.InboundSemaphoreKey = appSettings.MessageQueueAppConfig.InboundSemaphoreKey;
messageQueueAppConfig.OutboundSemaphoreKey = appSettings.MessageQueueAppConfig.OutboundSemaphoreKey;
messageQueueAppConfig.ProcessingIntervalSeconds = appSettings.MessageQueueAppConfig.ProcessingIntervalSeconds;
messageQueueAppConfig.SendingIntervalSeconds = appSettings.MessageQueueAppConfig.SendingIntervalSeconds;
messageQueueAppConfig.ReceivingIntervalSeconds = appSettings.MessageQueueAppConfig.ReceivingIntervalSeconds;
messageQueueAppConfig.SignalRHubUrl = appSettings.MessageQueueAppConfig.SignalRHubUrl;
messageQueueAppConfig.RunAsService = appSettings.MessageQueueAppConfig.RunAsService;
connectionStrings.PrimaryDatabaseConnectionString = appSettings.ConnectionStrings.PrimaryDatabaseConnectionString;
using (var sw = File.AppendText(Path))
{
sw.WriteLine("HostName=" + messageQueueAppConfig.MessageQueueHostName + "*");
}
}
else
{
string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
string jsonFile = $"AppSettings.{environment}.json";
var configBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(jsonFile, optional: true, reloadOnChange: true);
IConfigurationRoot configuration = configBuilder.Build();
configuration.GetSection("MessageQueueAppConfig").Bind(messageQueueAppConfig);
configuration.GetSection("ConnectionStrings").Bind(connectionStrings);
}
//
// set up sending queue
//
IMessageQueueConnection sendingQueueConnection = new MessageQueueConnection(messageQueueAppConfig);
sendingQueueConnection.CreateConnection();
List <IMessageQueueConfiguration> messageQueueConfigurations = new List <IMessageQueueConfiguration>();
IMessageQueueConfiguration salesOrderSubmittedConfiguration = new MessageQueueConfiguration(MessageQueueExchanges.SalesOrderSubmitted, messageQueueAppConfig, sendingQueueConnection);
salesOrderSubmittedConfiguration.AddQueue(MessageQueueEndpoints.InventoryQueue);
salesOrderSubmittedConfiguration.AddQueue(MessageQueueEndpoints.LoggingQueue);
salesOrderSubmittedConfiguration.InitializeOutboundMessageQueueing();
messageQueueConfigurations.Add(salesOrderSubmittedConfiguration);
ISalesOrderManagementDataService salesOrderManagementDataService = new SalesOrderManagementDataService();
IMessageQueueProcessing messageProcessing = new MessageProcessing(salesOrderManagementDataService);
_sendSalesOrderManagementMessages =
new SendMessages(sendingQueueConnection, messageProcessing, messageQueueAppConfig,
connectionStrings, messageQueueConfigurations, MessageQueueEndpoints.SalesOrderQueue);
//
// set up receiving queue
//
IMessageQueueConnection receivingConnection = new MessageQueueConnection(messageQueueAppConfig);
receivingConnection.CreateConnection();
List <IMessageQueueConfiguration> inboundMessageQueueConfigurations = new List <IMessageQueueConfiguration>();
IMessageQueueConfiguration inboundConfiguration = new MessageQueueConfiguration(messageQueueAppConfig, receivingConnection);
inboundMessageQueueConfigurations.Add(inboundConfiguration);
inboundConfiguration.InitializeInboundMessageQueueing(MessageQueueEndpoints.SalesOrderQueue);
inboundConfiguration.InitializeLoggingExchange(MessageQueueExchanges.Logging, MessageQueueEndpoints.LoggingQueue);
ISalesOrderManagementDataService inboundSalesOrderManagementDataService = new SalesOrderManagementDataService();
IMessageQueueProcessing inboundMessageProcessing = new MessageProcessing(inboundSalesOrderManagementDataService);
_receiveSalesOrderManagementMessages = new ReceiveMessages(receivingConnection, inboundMessageProcessing, messageQueueAppConfig, connectionStrings, inboundMessageQueueConfigurations);
//
// Set Up Message Processing
//
ISalesOrderManagementDataService salesOrderManagementProcessingDataService = new SalesOrderManagementDataService();
IMessageQueueProcessing messageProcessor = new MessageProcessing(salesOrderManagementProcessingDataService);
_processMessages = new ProcessMessages(messageProcessor, messageQueueAppConfig, connectionStrings);
var builder = new HostBuilder().ConfigureAppConfiguration((hostingContext, config) =>
{
})
.ConfigureServices((hostContext, services) =>
{
services.AddTransient <IHostedService>(provider => _sendSalesOrderManagementMessages);
})
.ConfigureServices((hostContext, services) =>
{
services.AddTransient <IHostedService>(provider => _processMessages);
})
.ConfigureServices((hostContext, services) =>
{
services.AddTransient <IHostedService>(provider => _receiveSalesOrderManagementMessages);
});
}
public static async Task Main(string[] args)
{
//
// get configuration information
//
MessageQueueAppConfig messageQueueAppConfig = new MessageQueueAppConfig();
ConnectionStrings connectionStrings = new ConnectionStrings();
string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
string jsonFile = $"appsettings.{environment}.json";
var configBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(jsonFile, optional: true, reloadOnChange: true);
IConfigurationRoot configuration = configBuilder.Build();
configuration.GetSection("MessageQueueAppConfig").Bind(messageQueueAppConfig);
configuration.GetSection("ConnectionStrings").Bind(connectionStrings);
//
// set up sending queue
//
IMessageQueueConnection sendingQueueConnection = new MessageQueueConnection(messageQueueAppConfig);
sendingQueueConnection.CreateConnection();
List <IMessageQueueConfiguration> messageQueueConfigurations = new List <IMessageQueueConfiguration>();
//
// Inventory Received Transactions
//
IMessageQueueConfiguration inventoryReceivedConfiguration = new MessageQueueConfiguration(MessageQueueExchanges.InventoryReceived, messageQueueAppConfig, sendingQueueConnection);
inventoryReceivedConfiguration.AddQueue(MessageQueueEndpoints.SalesOrderQueue);
inventoryReceivedConfiguration.AddQueue(MessageQueueEndpoints.PurchaseOrderQueue);
inventoryReceivedConfiguration.AddQueue(MessageQueueEndpoints.LoggingQueue);
inventoryReceivedConfiguration.InitializeOutboundMessageQueueing();
messageQueueConfigurations.Add(inventoryReceivedConfiguration);
//
// Product Creation and Updates
//
IMessageQueueConfiguration productUpdatedConfiguration = new MessageQueueConfiguration(MessageQueueExchanges.ProductUpdated, messageQueueAppConfig, sendingQueueConnection);
productUpdatedConfiguration.AddQueue(MessageQueueEndpoints.SalesOrderQueue);
productUpdatedConfiguration.AddQueue(MessageQueueEndpoints.PurchaseOrderQueue);
productUpdatedConfiguration.AddQueue(MessageQueueEndpoints.LoggingQueue);
productUpdatedConfiguration.InitializeOutboundMessageQueueing();
messageQueueConfigurations.Add(productUpdatedConfiguration);
//
// Inventory Shipped Transactions
//
IMessageQueueConfiguration inventoryShippedConfiguration = new MessageQueueConfiguration(MessageQueueExchanges.InventoryShipped, messageQueueAppConfig, sendingQueueConnection);
inventoryShippedConfiguration.AddQueue(MessageQueueEndpoints.SalesOrderQueue);
inventoryShippedConfiguration.AddQueue(MessageQueueEndpoints.LoggingQueue);
inventoryShippedConfiguration.InitializeOutboundMessageQueueing();
messageQueueConfigurations.Add(inventoryShippedConfiguration);
//
// initialize Sending Messages
//
IInventoryManagementDataService inventoryManagementDataService = new InventoryManagementDataService();
IMessageQueueProcessing messageProcessing = new MessageProcessing(inventoryManagementDataService);
IHostedService sendInventoryManagementMessages = new SendMessages(sendingQueueConnection, messageProcessing,
messageQueueAppConfig, connectionStrings, messageQueueConfigurations, MessageQueueEndpoints.InventoryQueue);
//
// set up receiving queue
//
IMessageQueueConnection receivingConnection = new MessageQueueConnection(messageQueueAppConfig);
receivingConnection.CreateConnection();
List <IMessageQueueConfiguration> inboundMessageQueueConfigurations = new List <IMessageQueueConfiguration>();
IMessageQueueConfiguration inboundConfiguration = new MessageQueueConfiguration(messageQueueAppConfig, receivingConnection);
inboundMessageQueueConfigurations.Add(inboundConfiguration);
inboundConfiguration.InitializeInboundMessageQueueing(MessageQueueEndpoints.InventoryQueue);
inboundConfiguration.InitializeLoggingExchange(MessageQueueExchanges.Logging, MessageQueueEndpoints.LoggingQueue);
IInventoryManagementDataService inboundInventoryManagementDataService = new InventoryManagementDataService();
IMessageQueueProcessing inboundMessageProcessing = new MessageProcessing(inboundInventoryManagementDataService);
IHostedService receiveInventoryManagementMessages = new ReceiveMessages(receivingConnection, inboundMessageProcessing, messageQueueAppConfig, connectionStrings, inboundMessageQueueConfigurations);
//
// Set Up Message Processing
//
IInventoryManagementDataService inventoryManagementProcessingDataService = new InventoryManagementDataService();
IMessageQueueProcessing messageProcessor = new MessageProcessing(inventoryManagementProcessingDataService);
ProcessMessages processMessages = new ProcessMessages(messageProcessor, messageQueueAppConfig, connectionStrings);
var builder = new HostBuilder().ConfigureAppConfiguration((hostingContext, config) => {})
.ConfigureServices((hostContext, services) =>
{
services.AddTransient <IHostedService>(provider => processMessages);
})
.ConfigureServices((hostContext, services) =>
{
services.AddTransient <IHostedService>(provider => sendInventoryManagementMessages);
})
.ConfigureServices((hostContext, services) =>
{
services.AddTransient <IHostedService>(provider => receiveInventoryManagementMessages);
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
});
await builder.RunConsoleAsync();
}
/// <summary>
/// Creates the server certificate.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Returns an awaitable <see cref="Task"/>.</returns>
private Task CreateServerCertificate(CancellationToken cancellationToken)
{
MessageQueueConfiguration configuration = _genericServiceProvider.GetService <IOptions <MessageQueueConfiguration> >().Value;
X509Store computerCaStore;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
computerCaStore = new X509Store(StoreName.My, StoreLocation.LocalMachine);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
try
{
X509Certificate2 certificate = new X509Certificate2(Environment.GetEnvironmentVariable("CERTIFICATE_PATH"), Environment.GetEnvironmentVariable("CERTIFICATE_PASSWORD"));
DisplayCertificate(certificate);
configuration.Certificate = certificate;
return(Task.CompletedTask);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(Task.FromCanceled(cancellationToken));
}
}
else
{
Console.WriteLine("Only Windows and Linux are supported Operating Systems.");
Console.WriteLine("CreateServerCertificate is cancelled.");
return(Task.FromCanceled(cancellationToken));
}
try
{
computerCaStore.Open(OpenFlags.ReadOnly);
X509Certificate2Collection certificatesInStore = computerCaStore.Certificates.Find(X509FindType.FindBySubjectName, configuration.Host, true);
if (certificatesInStore.Count == 0)
{
throw new EmptyCertificateCollectionException($"No certificate was found with the given subject name: {configuration.Host}");
}
if (certificatesInStore.Count > 1)
{
foreach (X509Certificate2 cert in certificatesInStore)
{
DisplayCertificate(cert);
}
throw new ArgumentOutOfRangeException(nameof(certificatesInStore), "More than one certificate was found!");
}
X509Certificate2 certificate = certificatesInStore[0];
DisplayCertificate(certificate);
configuration.Certificate = certificate;
cancellationToken.ThrowIfCancellationRequested();
}
catch (Exception e)
{
Console.WriteLine($"{nameof(CreateServerCertificate)}: {e}");
if (!cancellationToken.IsCancellationRequested)
{
Console.WriteLine($"Please check if you have a valid MessageQueueConfiguration.Host name, also known as the Common Name (CN) or Fully Qualified Domain Name (FQDN)!\n\t{e.Message}");
_cancellationTokenSource.Cancel();
}
Console.WriteLine("CreateServerCertificate is cancelled.");
return(Task.FromCanceled(cancellationToken));
}
finally
{
computerCaStore.Close();
}
return(Task.CompletedTask);
}
