public static ServiceComponentsHostBuilder AddHealthCheck(
            this ServiceComponentsHostBuilder hostBuilder,
            Action <IConfiguration, IHealthChecksBuilder> builder,
            string readinessPath = "/.well-known/ready",
            string livenessPath  = "/.well-known/live")
        {
            return(hostBuilder

                   .RegisterCallback((configuration, environment, app) => {
                app.UseHealthChecks(readinessPath, new HealthCheckOptions {
                    Predicate = registration =>
                                registration.Tags == null || !registration.Tags.Any() ||
                                registration.Tags.Contains(ReadinessTag)
                });

                app.UseHealthChecks(livenessPath, new HealthCheckOptions {
                    Predicate = registration =>
                                registration.Tags == null || !registration.Tags.Any() ||
                                registration.Tags.Contains(LivenessTag)
                });
            })
                   .RegisterCallback((configuration, services) => {
                builder(configuration, services.AddHealthChecks()
                        .AddCheck("self", () => HealthCheckResult.Healthy(), new[] { LivenessTag }));
            }));
        }
 public static ServiceComponentsHostBuilder AddRedisDistributedCache(this ServiceComponentsHostBuilder hostBuilder, string connection, string instance = default)
 {
     return(hostBuilder.RegisterCallback((configuration, services) => services.AddStackExchangeRedisCache(options => {
         options.InstanceName = instance;
         options.Configuration = connection;
     })));
 }
Example #3
0
 public static ServiceComponentsHostBuilder AddPrometheusMetrics(this ServiceComponentsHostBuilder hostBuilder)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddPrometheusRequestMetricsService();
         containerBuilder.AddPrometheusRequestMetricsBehavior();
     }));
 }
Example #4
0
 public static ServiceComponentsHostBuilder AddBadge(this ServiceComponentsHostBuilder hostBuilder)
 {
     return(AddBadge(hostBuilder, (configuration, registry) => {
         registry.RegistrateLivenessBadge();
         registry.RegistrateReadinessBadge();
         registry.RegistrateVersionBadge();
     }));
 }
Example #5
0
 public static ServiceComponentsHostBuilder AddLoopbackSender(this ServiceComponentsHostBuilder hostBuilder, object key = default)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddLoopbackCommandSender(key);
         containerBuilder.AddLoopbackQuerySender(key);
         containerBuilder.AddLoopbackEventPublisher(key);
     }));
 }
Example #6
0
 public static ServiceComponentsHostBuilder AddHttpSender(this ServiceComponentsHostBuilder hostBuilder, Uri endpointUri, object key = default)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddHttpCommandSender(endpointUri, key);
         containerBuilder.AddHttpQuerySender(endpointUri, key);
         containerBuilder.AddHttpEventPublisher(endpointUri, key);
     }));
 }
        public static ServiceComponentsHostBuilder AddRedisDistributedCache(this ServiceComponentsHostBuilder hostBuilder, Action <ConfigurationOptions> optionsBuilder)
        {
            var opts = new ConfigurationOptions();

            optionsBuilder(opts);

            return(hostBuilder.RegisterCallback((configuration, services) => services.AddStackExchangeRedisCache(options => { options.ConfigurationOptions = opts; })));
        }
Example #8
0
 public static ServiceComponentsHostBuilder AddHttpSender(this ServiceComponentsHostBuilder hostBuilder, Func <IConfiguration, Uri> endpointUriBuilder, object key = default)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         var uri = endpointUriBuilder(context.Configuration);
         containerBuilder.AddHttpCommandSender(uri, key);
         containerBuilder.AddHttpQuerySender(uri, key);
         containerBuilder.AddHttpEventPublisher(uri, key);
     }));
 }
        public static ServiceComponentsHostBuilder AddRedis(this ServiceComponentsHostBuilder hostBuilder, Func <IConfiguration, string> connectionStringBuilder)
        {
            hostBuilder.RegisterCallback((context, containerBuilder) => {
                containerBuilder.AddRedisConnection(connectionStringBuilder(context.Configuration));
                containerBuilder.AddRedisDatabase();
            });

            return(hostBuilder);
        }
Example #10
0
 public static ServiceComponentsHostBuilder AddMediator(this ServiceComponentsHostBuilder hostBuilder, Assembly[] applicationAssemblies, bool addBehavior = true)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddMediator(applicationAssemblies);
         if (addBehavior)
         {
             containerBuilder.AddMediatorBehavior(applicationAssemblies);
         }
     }));
 }
Example #11
0
 public static ServiceComponentsHostBuilder AddBadge(this ServiceComponentsHostBuilder hostBuilder, Action <IConfiguration, IBadgeRegistry> builder, string pattern = ".badge")
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddBadgeService(registry => builder(context.Configuration, registry));
     })
            .RegisterCallback((configuration, routeBuilder) => {
         routeBuilder.MapControllerRoute(name: "badge",
                                         pattern: $"{pattern.TrimEnd('/')}/{{name?}}",
                                         defaults: new { controller = "Badge", action = "Get" });
     }));
 }
Example #12
0
 public static ServiceComponentsHostBuilder AddCorrelation(this ServiceComponentsHostBuilder hostBuilder)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddCorrelationInfo();
         containerBuilder.AddReceiverCorrelationLogEnricherBehavior();
         containerBuilder.AddHttpReceiverCorrelationBehavior();
         containerBuilder.AddHttpSenderCorrelationBehavior();
         containerBuilder.AddLoopbackReceiverCorrelationBehavior();
         containerBuilder.AddRabbitReceiverCorrelationBehavior();
         containerBuilder.AddRabbitSenderCorrelationBehavior();
     }));
 }
Example #13
0
        public static ServiceComponentsHostBuilder UseDefault(this ServiceComponentsHostBuilder builder, Assembly[] apiAssemblies, Assembly[] applicationAssemblies)
        {
            return(builder

                   // Use Autofac for dependency injection
                   .UseAutofac()

                   // Add request binder for command, query and event deserialization
                   .UseRequestBinder()

                   .RegisterCallback((configuration, services) => {
                var mvcBuilder = services.AddControllers(options => {
                    builder.MvcOptionsBuilderCallbacks.ForEach(action => action(options));
                });

                var hostAssembly = Assembly.GetEntryAssembly();
                mvcBuilder.PartManager.ApplicationParts.Add(new AssemblyPart(hostAssembly));
                mvcBuilder.PartManager.ApplicationParts.Add(new AssemblyPart(typeof(BadgeController).Assembly));
                builder.MvcBuilderCallbacks.ForEach(x => x(mvcBuilder));

                services.AddHttpContextAccessor();
                services.AddHttpClient();
                services.AddCors();
            })

                   .RegisterCallback((context, containerBuilder) => {
                containerBuilder.RegisterType <ComputerClock>().AsImplementedInterfaces().SingleInstance();
                containerBuilder.AddHttpRequestParser();
            })

                   // Add Mediator components
                   .AddMediator(applicationAssemblies, addBehavior: true)

                   // Add fluent validation behavior
                   .AddValidationBehavior(apiAssemblies)

                   // Add request logging behavior
                   .AddLogBehavior()

                   // Add stopwatch behavior for measure and log execution time of command, query and event handlers
                   .AddStopwatchBehavior()

                   // Registers CorrelationInfo service
                   .AddCorrelation()

                   // Register receivers
                   .AddReceivers()

                   // Add loopback command, query and event senders with key 'loopback'
                   .AddLoopbackSender("loopback")

                   );
        }
        public static ServiceComponentsHostBuilder AddOpenApi(this ServiceComponentsHostBuilder builder, Action <IConfiguration, SwaggerGenOptions> generatorOptions, Action <IConfiguration, SwaggerUIOptions> uiOptions)
        {
            builder.RegisterCallback((configuration, services) => {
                services.AddSwaggerGen(c => { generatorOptions(configuration, c); });
            });

            builder.RegisterCallback((configuration, environment, app) => {
                app.UseSwagger();
                app.UseSwaggerUI(c => uiOptions(configuration, c));
            });

            return(builder);
        }
Example #15
0
 public static ServiceComponentsHostBuilder AddReceivers(this ServiceComponentsHostBuilder hostBuilder, bool http = true, bool loopback = true)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.AddReceivers();
         if (http)
         {
             containerBuilder.AddHttpReceivers();
         }
         if (loopback)
         {
             containerBuilder.AddLoopbackReceivers();
         }
     }));
 }
        public static ServiceComponentsHostBuilder AddEndpoints(this ServiceComponentsHostBuilder builder)
        {
            builder.RegisterCallback((configuration, environment, app) => {
                app.UseEndpoints(endpoints => {
                    endpoints.MapControllers();

                    builder.EndpointRouteBuilderCallbacks.ForEach(action => {
                        action(configuration, endpoints);
                    });
                });
            });

            return(builder);
        }
Example #17
0
 public static ServiceComponentsHostBuilder ConfigureMvc(this ServiceComponentsHostBuilder hostBuilder, Action <IMvcBuilder> mvcBuilder)
 {
     return(hostBuilder.RegisterCallback(mvcBuilder));
 }
Example #18
0
 public static ServiceComponentsHostBuilder ConfigureApp(this ServiceComponentsHostBuilder hostBuilder, Action <IConfiguration, IHostEnvironment, IApplicationBuilder> appBuilder)
 {
     return(hostBuilder.RegisterCallback(appBuilder));
 }
Example #19
0
 public static ServiceComponentsHostBuilder AddValidationBehavior(this ServiceComponentsHostBuilder hostBuilder, Assembly[] apiAssemblies)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => { containerBuilder.AddValidationBehavior(apiAssemblies); }));
 }
 public static ServiceComponentsHostBuilder AddRedisDistributedCache(this ServiceComponentsHostBuilder hostBuilder, string connectionString)
 {
     return(hostBuilder.RegisterCallback((configuration, services) => services.AddStackExchangeRedisCache(options => {
         options.ConfigurationOptions = ConfigurationOptions.Parse(connectionString);
     })));
 }
Example #21
0
 public static ServiceComponentsHostBuilder AddStopwatchBehavior(this ServiceComponentsHostBuilder hostBuilder)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => { containerBuilder.AddStopwatchBehavior(); }));
 }
 public static ServiceComponentsHostBuilder UseRequestBinder(this ServiceComponentsHostBuilder builder)
 {
     builder.RegisterCallback(options => options.UseRequestBinder());
     return(builder);
 }
Example #23
0
        public static ServiceComponentsHostBuilder AddRabbit(
            this ServiceComponentsHostBuilder hostBuilder,
            Func <IConfiguration, string> connectionStringBuilder,
            Func <IConfiguration, string> clientNameBuilder,
            Func <IConfiguration, string> queueBuilder,
            Func <IConfiguration, string> exchangeBuilder,
            Func <IConfiguration, string> routingKeyBuilder    = default,
            Func <IConfiguration, int[]> retryIntervalsBuilder = default)
        {
            return(hostBuilder.RegisterCallback((context, containerBuilder) => {
                var uri = new Uri(connectionStringBuilder(context.Configuration));
                var clientName = clientNameBuilder(context.Configuration);
                var exchange = exchangeBuilder(context.Configuration);
                var queue = queueBuilder(context.Configuration);
                var routingKey = routingKeyBuilder(context.Configuration) ?? "";
                var retryIntervals = retryIntervalsBuilder(context.Configuration);

                // Generic connection and channel

                containerBuilder.AddRabbitConnection(uri, $"{clientName}-generic");
                containerBuilder.AddRabbitChannel();

                // Publisher connection, channel

                containerBuilder.AddRabbitConnection(uri, $"{clientName}-publisher", "publisher");
                containerBuilder.AddRabbitChannel(key: "publisher", connectionKey: "publisher");
                containerBuilder.AddRabbitEventPublisher(exchange, routingKey, channelKey: "publisher", key: "rabbit");

                // Consumers

                containerBuilder.AddRabbitConnection(uri, $"{clientName}-consumer", "consumer");

                // Add retry if defined
                if (retryIntervals != default)
                {
                    containerBuilder.AddRabbitRetryConsumers("consumer", queue, retryIntervals, clientName);
                }

                // Add consumers for queue
                var consumerCount = Environment.ProcessorCount - (retryIntervals?.Length ?? 0);
                if (consumerCount < 1)
                {
                    consumerCount = 1;
                }

                for (var i = 0; i < consumerCount; i++)
                {
                    containerBuilder.AddRabbitChannel(connectionKey: "consumer", key: $"consumer-{i}");
                    containerBuilder.AddRabbitConsumer(queue, $"{clientName}-consumer-{i}", $"consumer-{i}", $"consumer-{i}");
                }

                // Receivers and senders

                containerBuilder.AddRabbitReceivers();
                containerBuilder.AddRabbitCommandSender(exchange, string.Empty, "publisher", "rabbit");
                containerBuilder.AddRabbitQuerySender(exchange, string.Empty, "publisher", "rabbit");

                containerBuilder.Register(context => new RabbitStartup(
                                              context.Resolve <ILogger>(),
                                              context.Resolve <ILifetimeScope>(),
                                              context.Resolve <IModel>(),
                                              queue, exchange, routingKey,
                                              retryIntervals)).AsImplementedInterfaces();
            }));
        }
Example #24
0
 public static ServiceComponentsHostBuilder AddRabbit(this ServiceComponentsHostBuilder hostBuilder, string connectionString, string clientName, string queue, string exchange, string routingKey = "", int[] retryIntervals = default)
 {
     return(AddRabbit(hostBuilder, configuration => connectionString, configuration => clientName,
                      configuration => queue, configuration => exchange, configuration => routingKey,
                      configuration => retryIntervals));
 }
 public static ServiceComponentsHostBuilder UseAutofac(this ServiceComponentsHostBuilder builder)
 {
     builder.RegisterCallback(hostBuilder => hostBuilder.UseServiceProviderFactory(new AutofacServiceProviderFactory()));
     return(builder);
 }
 public static ServiceComponentsHostBuilder UseSerilog(this ServiceComponentsHostBuilder builder)
 {
     builder.RegisterCallback(hostBuilder => hostBuilder.UseSerilog((context, configuration) => configuration.ReadFrom.Configuration(context.Configuration)));
     return(builder);
 }
Example #27
0
 public static ServiceComponentsHostBuilder ConfigureContainer(this ServiceComponentsHostBuilder hostBuilder, Action <HostBuilderContext, ContainerBuilder> containerBuilder)
 {
     return(hostBuilder.RegisterCallback(containerBuilder));
 }
 public static ServiceComponentsHostBuilder AddNHibernate(this ServiceComponentsHostBuilder hostBuilder, Func <IConfiguration, string> connectionString, Action <MappingConfiguration> mapping, Action <Configuration> exposeConfiguration)
 {
     return(hostBuilder.RegisterCallback((context, containerBuilder) => {
         containerBuilder.RegisterModule(new NhibernateModule(connectionString(context.Configuration), mapping, exposeConfiguration));
     }));
 }
 public static ServiceComponentsHostBuilder AddGenericController(this ServiceComponentsHostBuilder hostBuilder, string path = default)
 {
     // TODO: solve routing to path
     return(hostBuilder);
 }
 public static ServiceComponentsHostBuilder UseSerilog(this ServiceComponentsHostBuilder builder, Action <HostBuilderContext, LoggerConfiguration> callback)
 {
     builder.RegisterCallback(hostBuilder => hostBuilder.UseSerilog(callback));
     return(builder);
 }