private static IBusControl SetupRabbitMq(IConfiguration configuration)
{
return(RabbitMQConfiguration.ConfigureBus(
rabbitMQHostUri: configuration.GetValue <string>("RabbitMQ:HostUri"),
rabbitMQUsername: configuration.GetValue <string>("RabbitMQ:Username"),
rabbitMQPassword: configuration.GetValue <string>("RabbitMQ:Password")));
}
public SiteStartup(IConfiguration configuration, IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
RoutingConfiguration = new RoutingConfig();
Configuration.Bind("RoutingConfig", RoutingConfiguration);
//set all URLS to point to web api -- doesn't need to be separate here even if configuration allows it
RoutingConfiguration.CustomerService.URL = RoutingConfiguration.URL;
RoutingConfiguration.OrderService.URL = RoutingConfiguration.URL;
RoutingConfiguration.ProductService.URL = RoutingConfiguration.URL;
RoutingConfiguration.ShoppingCartService.URL = RoutingConfiguration.URL;
RoutingConfiguration.PurchasedProductService.URL = RoutingConfiguration.URL;
DbConfig = new DatabaseConfiguration();
Configuration.Bind("DatabaseConfiguration", DbConfig);
RabbitConfig = new RabbitMQConfiguration();
Configuration.Bind("RabbitMQConfiguration", RabbitConfig);
}
public SignalRCounter(
IBusControl busControl,
IOptions <RabbitMQConfiguration> rmqOptions)
{
this.busControl = busControl;
rmqConfig = rmqOptions.Value;
}
public static LoggerConfiguration GetLoggerConfiguration()
{
// Read Logging configuration
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: false)
.AddUserSecrets <Startup>()
.Build();
var logCfg = configuration.GetSection("Logging");
var application = logCfg["Application"];
var environment = logCfg["Environment"];
var rabbitMQHost = logCfg["RabbitMQHost"];
var rabbitMQVHost = logCfg["RabbitMQVHost"];
var rabbitPortIsSet = int.TryParse(logCfg["RabbitMQPort"], out var rabbitMQPort);
var rabbitMQUsername = logCfg["RabbitMQUsername"];
var rabbitMQPassword = logCfg["RabbitMQPassword"];
var rabbitMQExchangeName = logCfg["RabbitMQExchangeName"];
var rabbitMQExchangeType = logCfg["RabbitMQExchangeType"];
var serilogFilePath = logCfg["SerilogFilePath"] ?? logCfg["LogFilePath"];
Enum.TryParse(logCfg["SerilogMinLevel"], out LogEventLevel serilogMinLevel);
bool.TryParse(logCfg["UseRabbit"], out var useRabbit);
bool.TryParse(logCfg["UseFile"], out var useFile);
var serilogFormatter = new NiceSerilogFormatter(environment, application);
var serilogConfiguration = new LoggerConfiguration()
.Enrich.FromLogContext()
.WriteTo.Console()
.MinimumLevel.Is(serilogMinLevel);
if (useRabbit && !string.IsNullOrEmpty(rabbitMQHost) && rabbitPortIsSet)
{
var rabbitCfg = new RabbitMQConfiguration
{
Hostname = rabbitMQHost,
VHost = rabbitMQVHost,
Port = rabbitMQPort,
Username = rabbitMQUsername ?? "",
Password = rabbitMQPassword ?? "",
Protocol = RabbitMQ.Client.Protocols.AMQP_0_9_1,
Exchange = rabbitMQExchangeName,
ExchangeType = rabbitMQExchangeType
};
// Write logs to RabbitMQ / Kibana
serilogConfiguration.WriteTo.RabbitMQ(rabbitCfg, serilogFormatter);
}
// Write logs to file
if (useFile)
{
serilogConfiguration.WriteTo.RollingFile(serilogFormatter,
serilogFilePath,
fileSizeLimitBytes: 5000000,
retainedFileCountLimit: 5,
flushToDiskInterval: TimeSpan.FromSeconds(20));
}
return(serilogConfiguration);
}
/// <summary>
/// Adds a sink that lets you push log messages to RabbitMq
/// </summary>
public static LoggerConfiguration RabbitMQ(
this LoggerSinkConfiguration loggerConfiguration,
RabbitMQConfiguration rabbitMqConfiguration,
ITextFormatter formatter,
IFormatProvider formatProvider = null)
{
if (loggerConfiguration == null)
{
throw new ArgumentNullException("loggerConfiguration");
}
if (rabbitMqConfiguration == null)
{
throw new ArgumentNullException("rabbitMqConfiguration");
}
// calls overloaded extension method
return(loggerConfiguration.RabbitMQ(
rabbitMqConfiguration.Hostname,
rabbitMqConfiguration.Username,
rabbitMqConfiguration.Password,
rabbitMqConfiguration.Exchange,
rabbitMqConfiguration.ExchangeType,
rabbitMqConfiguration.Queue,
rabbitMqConfiguration.DeliveryMode,
rabbitMqConfiguration.RouteKey,
rabbitMqConfiguration.Port,
rabbitMqConfiguration.VHost,
rabbitMqConfiguration.Heartbeat,
rabbitMqConfiguration.Protocol,
rabbitMqConfiguration.BatchPostingLimit,
rabbitMqConfiguration.Period,
formatter,
formatProvider));
}
public static void Main(string[] args)
{
var config = new RabbitMQConfiguration
{
Hostname = "localhost",
Username = "******",
Password = "******",
Exchange = "app-logging",
ExchangeType = "direct",
DeliveryMode = RabbitMQDeliveryMode.NonDurable,
RouteKey = "Logs",
Port = 5672
};
Log.Logger = new LoggerConfiguration()
.WriteTo.RabbitMQ(config, new JsonFormatter())
.Enrich.WithProperty("App Name", "WebApp")
.MinimumLevel.Verbose()
.CreateLogger();
try
{
CreateWebHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
public HomeController(ILogger <HomeController> logger, IBusControl busControl,
IOptions <RabbitMQConfiguration> rmqOptions)
{
this.logger = logger;
this.busControl = busControl;
rmqConfig = rmqOptions.Value;
}
public RabbitMQSubscription(
IModel channel,
RabbitMQChannelEventsHandler channelEvents,
Action <byte[], IMessageContext> handler,
RabbitMQConfiguration configuration,
RabbitMQMessaging messaging,
ILoggerFactory loggerFactory,
params string[] queues)
{
this.channel = channel ??
throw new ArgumentNullException(nameof(channel));
this.channelEvents = channelEvents ??
throw new ArgumentNullException(nameof(channelEvents));
this.handler = handler ??
throw new ArgumentNullException(nameof(handler));
this.configuration = configuration ??
throw new ArgumentNullException(nameof(configuration));
this.messaging = messaging ??
throw new ArgumentNullException(nameof(messaging));
this.queues = queues ??
throw new ArgumentNullException(nameof(queues));
logger = loggerFactory?.CreateLogger <RabbitMQSubscription>() ??
throw new ArgumentNullException(nameof(loggerFactory));
consumersToQueues = new Dictionary <string, string>();
}
public GameStateMachine(ILogger <GameStateMachine> logger, IOptions <RabbitMQConfiguration> rmqOptions)
{
this.logger = logger;
rmqConfig = rmqOptions.Value;
BuildStateMachine();
}
public RabbitMQContext(ILogger <RabbitMQContext> logger, IOptions <RabbitMQConfiguration> configuration)
{
_logger = logger;
_configuration = configuration.Value;
try
{
var factory = new ConnectionFactory
{
HostName = _configuration.HostName,
UserName = _configuration.Username,
Password = _configuration.Secret,
VirtualHost = _configuration.VirtualHost,
DispatchConsumersAsync = _configuration.DispatcherAsync,
TopologyRecoveryEnabled = _configuration.TopologyRecovery,
AutomaticRecoveryEnabled = _configuration.AutomaticRecovery,
NetworkRecoveryInterval = TimeSpan.FromSeconds(_configuration.NetworkRecoverySeconds)
};
_connection = factory.CreateConnection();
}
catch (Exception)
{
throw;
}
}
public void TwoQueues_SingleRetry_Success()
{
var configuration = new RabbitMQConfiguration();
configuration.AddTopology <MultipleQueuesWithRetryTopologyFactory>(
"mytopic", "q1", "q2", 4000);
var exchanges = configuration.Topologies["mytopic"].Exchanges;
var exchange = exchanges.First();
Assert.Equal("mytopic", exchange.Name);
Assert.Equal(2, exchange.Queues.Count);
Assert.Equal("q1-wait-0", GetSingleQueueDlxName(exchanges, "mytopic", "q1"));
Assert.Equal("q1-retry-0", GetSingleQueueDlxName(exchanges, "q1-wait-0"));
Assert.Equal("q1-dead", GetSingleQueueDlxName(exchanges, "q1-retry-0"));
Assert.Equal(4000, GetSingleQueueTtl(exchanges, "q1-wait-0"));
Assert.Equal("q2-wait-0", GetSingleQueueDlxName(exchanges, "mytopic", "q2"));
Assert.Equal("q2-retry-0", GetSingleQueueDlxName(exchanges, "q2-wait-0"));
Assert.Equal("q2-dead", GetSingleQueueDlxName(exchanges, "q2-retry-0"));
Assert.Equal(4000, GetSingleQueueTtl(exchanges, "q2-wait-0"));
}
public void ThreeQueues_ThreeRetries_Success()
{
var configuration = new RabbitMQConfiguration();
configuration.AddTopology <MultipleQueuesWithRetryTopologyFactory>(
"mytopic", "q1", "q2", "q3", 4000, 8000, 16000);
var exchanges = configuration.Topologies["mytopic"].Exchanges;
var exchange = exchanges.First();
Assert.Equal("mytopic", exchange.Name);
Assert.Equal(3, exchange.Queues.Count);
for (int i = 1; i < 4; i++)
{
Assert.Equal($"q{i}-wait-0", GetSingleQueueDlxName(exchanges, "mytopic", $"q{i}"));
Assert.Equal($"q{i}-retry-0", GetSingleQueueDlxName(exchanges, $"q{i}-wait-0"));
Assert.Equal($"q{i}-wait-1", GetSingleQueueDlxName(exchanges, $"q{i}-retry-0"));
Assert.Equal($"q{i}-retry-1", GetSingleQueueDlxName(exchanges, $"q{i}-wait-1"));
Assert.Equal($"q{i}-wait-2", GetSingleQueueDlxName(exchanges, $"q{i}-retry-1"));
Assert.Equal($"q{i}-retry-2", GetSingleQueueDlxName(exchanges, $"q{i}-wait-2"));
Assert.Equal($"q{i}-dead", GetSingleQueueDlxName(exchanges, $"q{i}-retry-2"));
Assert.Equal(4000, GetSingleQueueTtl(exchanges, $"q{i}-wait-0"));
Assert.Equal(8000, GetSingleQueueTtl(exchanges, $"q{i}-wait-1"));
Assert.Equal(16000, GetSingleQueueTtl(exchanges, $"q{i}-wait-2"));
}
}
/// <summary>
/// Add topology created by a specific <see cref="ITopologyFactory"/> implementation.
/// </summary>
/// <typeparam name="TTopologyFactory">An <see cref="ITopologyFactory"/> implementation.</typeparam>
/// <param name="rabbitMQconfiguration">The <see cref="RabbitMQConfiguration"/> object.</param>
/// <param name="mainExchangeName">The exchange name.</param>
/// <param name="args">
/// Custom topology args (see the specific <see cref="ITopologyFactory"/>
/// implementation for details).</param>
/// <returns>The provided <see cref="RabbitMQConfiguration"/> object.</returns>
public static RabbitMQConfiguration AddTopology <TTopologyFactory>(this RabbitMQConfiguration rabbitMQconfiguration,
string mainExchangeName, params object[] args)
where TTopologyFactory : ITopologyFactory, new()
{
if (rabbitMQconfiguration is null)
{
throw new ArgumentNullException(nameof(rabbitMQconfiguration));
}
if (mainExchangeName is null)
{
throw new ArgumentNullException(nameof(mainExchangeName));
}
var topologyFactory = new TTopologyFactory();
if (rabbitMQconfiguration.Topologies is null)
{
rabbitMQconfiguration.Topologies = new Dictionary <string, Topology>();
}
rabbitMQconfiguration.Topologies.Add(mainExchangeName, topologyFactory.Create(mainExchangeName, args));
return(rabbitMQconfiguration);
}
public RabbitMqPublisher(ILogWriter logWriter,
IRabbitMqConnection connection,
RabbitMQConfiguration rabbitConfig)
{
_logWriter = logWriter;
_connection = connection;
_rabbitConfig = rabbitConfig;
}
public HangmanController(IDbContext dbContext,
IBusControl busControl,
IOptions <RabbitMQConfiguration> rmqOptions)
{
this.dbContext = dbContext;
this.busControl = busControl;
rmqConfig = rmqOptions.Value;
}
public RabbitMQService(IConfiguration configuration,
ILogger <RabbitMQService> logger)
{
var RabbitMQConfiguration = configuration.GetSection("RabbitMQConfiguration").Get <RabbitMQConfiguration>();
this.RabbitMQConfiguration = RabbitMQConfiguration;
this.logger = logger;
}
public ConfigureSitecore(ISitecoreConfiguration configuration, ILogger <ConfigureSitecore> logger)
{
_configuration = configuration;
_logger = logger;
_rabbitMqConfiguration = new RabbitMQConfiguration();
_configuration.GetSection(_sectionName).Bind(_rabbitMqConfiguration);
}
public ProcessTurnConsumer(ILogger <ProcessTurnConsumer> logger,
IOptions <RabbitMQConfiguration> rmqOption,
IDbContext dbContext)
{
rmqConfig = rmqOption.Value;
this.dbContext = dbContext;
this.logger = logger;
}
public SelectWordConsumer(ILogger <SelectWordConsumer> logger,
IOptions <RabbitMQConfiguration> rmqOption,
WordGenerator wordGenerator)
{
rmqConfig = rmqOption.Value;
this.logger = logger;
this.wordGenerator = wordGenerator;
}
public RabbitMQSink(RabbitMQConfiguration configuration,
ITextFormatter formatter,
IFormatProvider formatProvider) : base(configuration.BatchPostingLimit, configuration.Period)
{
_formatter = formatter ?? new RawFormatter();
_formatProvider = formatProvider;
_client = new RabbitMQClient(configuration);
}
/// <summary>
/// Constructor for RabbitMqClient
/// </summary>
/// <param name="configuration">mandatory</param>
public RabbitMQClient(RabbitMQConfiguration configuration)
{
// load configuration
_config = configuration;
// initialize
InitializeEndpoint();
}
public OpenStreetMapApi(string baseUrl, RabbitMQConfiguration rabbitMQConfiguration)
{
this.baseUrl = baseUrl ?? throw new ArgumentNullException(nameof(baseUrl));
client = new HttpClient();
client.DefaultRequestHeaders.Add("User-Agent", "Services demo");
rabbitMQInteractor = new RabbitMQInteractor(rabbitMQConfiguration);
addressResultDtoFactory = new AddressResultDtoFactory();
}
public EventBusRabbitMQ(IOptions<RabbitMQConfiguration> rabbitMQOptions)
{
// using IOptions to inject
_rabbitMQConfig = rabbitMQOptions.Value;
_hostName = _rabbitMQConfig.HostName;
_password = _rabbitMQConfig.Password;
_queueName = _rabbitMQConfig.QueueName;
_userName = _rabbitMQConfig.UserName;
}
/// <summary>
/// Constructor for RabbitMqClient
/// </summary>
/// <param name="configuration">mandatory</param>
public RabbitMQClient(RabbitMQConfiguration configuration)
{
// load configuration
_config = configuration;
_publicationAddress = new PublicationAddress(_config.ExchangeType, _config.Exchange, _config.RouteKey);
// initialize
InitializeEndpoint();
}
public static IServiceCollection AddRabbitMQConnection(this IServiceCollection services, IConfiguration configuration)
{
var connectionConfig = new RabbitMQConfiguration();
configuration.Bind("rabbitmq_connection", connectionConfig);
return(services
.AddSingleton <IMessageBrokerConfiguration, RabbitMQConfiguration>(provider => connectionConfig));
}
public OrchestratorService(ILogger <OrchestratorService> logger,
IOptions <MongoDBConfiguration> mongoDbOptions,
IOptions <RabbitMQConfiguration> rabbitMqOptions,
GameStateMachine stateMachine)
{
mongoDbConfig = mongoDbOptions.Value;
rabbitMqConfig = rabbitMqOptions.Value;
this.logger = logger;
this.stateMachine = stateMachine;
}
public RabbitMQMessagingService(ISitecoreConfiguration configuration, ILogger <RabbitMQMessagingService> logger, IModel channel, IMessageProcessor messageProcessor)
{
_logger = logger;
_channel = channel;
_configuration = configuration;
_messageProcessor = messageProcessor;
_rabbitMqConfiguration = new RabbitMQConfiguration();
_configuration.GetSection(_sectionName).Bind(_rabbitMqConfiguration);
}
public static IServiceCollection RabbitMQConfiguration(this IServiceCollection services, IConfiguration Configuration)
{
var rabbitConfiguration = new RabbitMQConfiguration();
Configuration.GetSection("RabbitMQConfiguration").Bind(rabbitConfiguration);
services.AddSingleton(rabbitConfiguration);
return(services);
}
public RabbitMQSink(
RabbitMQConfiguration configuration,
ITextFormatter formatter,
IFormatProvider formatProvider
)
{
// prepare client
_client = new RabbitMQClient(configuration);
_formatProvider = formatProvider;
_formatter = formatter ?? new RawFormatter();
}
public void NoRetry_Success()
{
var rabbitMQConfiguration = new RabbitMQConfiguration();
rabbitMQConfiguration.AddTopology <SimpleQueueWithRetryTopologyFactory>(
"mytopic");
var exchanges = rabbitMQConfiguration.Topologies["mytopic"].Exchanges;
Assert.Equal("mytopic-dead", GetSingleQueueDlxName(exchanges, "mytopic"));
}
public void DefaultToOneThousand()
{
var configuration = new RabbitMQConfiguration();
Assert.That(configuration.ListenTimeout, Is.EqualTo(1000));
}
public void ShouldReturnValueFromSetter()
{
var configuration = new RabbitMQConfiguration { ListenTimeout = 123 };
Assert.That(configuration.ListenTimeout, Is.EqualTo(123));
}
