private static void AddEurekaServices(IServiceCollection services, IDiscoveryLifecycle lifecycle) { services.AddSingleton <EurekaApplicationInfoManager>(); services.AddSingleton <EurekaDiscoveryManager>(); services.AddSingleton <EurekaDiscoveryClient>(); if (lifecycle == null) { services.AddSingleton <IDiscoveryLifecycle, ApplicationLifecycle>(); } else { services.AddSingleton(lifecycle); } services.AddSingleton <IDiscoveryClient>((p) => { var eurekaService = p.GetService <EurekaDiscoveryClient>(); // Wire in health checker if present if (eurekaService != null) { eurekaService.HealthCheckHandler = p.GetService <IHealthCheckHandler>(); } return(eurekaService); }); services.AddSingleton <IServiceInstanceProvider>(p => p.GetService <EurekaDiscoveryClient>()); services.AddSingleton <IHealthContributor, EurekaServerHealthContributor>(); }
private static void AddConsulServices(IServiceCollection services, IDiscoveryLifecycle lifecycle) { services.AddSingleton(s => { var consulOptions = s.GetRequiredService <IOptions <ConsulOptions> >().Value; return(new ConsulClient(options => { options.Address = new Uri($"{consulOptions.Scheme}://{consulOptions.Host}:{consulOptions.Port}"); options.Datacenter = consulOptions.Datacenter; options.Token = consulOptions.Token; if (!string.IsNullOrWhiteSpace(consulOptions.WaitTime)) { options.WaitTime = DateTimeConversions.ToTimeSpan(consulOptions.WaitTime); } })); }); services.AddSingleton <TtlScheduler>(); services.AddSingleton <ConsulDiscoveryClient>(); services.AddSingleton <ConsulServiceRegistry>(); if (lifecycle == null) { services.AddSingleton <IDiscoveryLifecycle, ApplicationLifecycle>(); } else { services.AddSingleton(lifecycle); } services.AddSingleton <IDiscoveryClient>(p => p.GetService <ConsulDiscoveryClient>()); }
private static void AddDiscoveryServices( ContainerBuilder container, IServiceInfo info, IConfiguration config, IDiscoveryLifecycle lifecycle) { var clientConfigsection = config.GetSection(EUREKA_PREFIX); int childCount = clientConfigsection.GetChildren().Count(); if (childCount > 0 || info is EurekaServiceInfo) { EurekaServiceInfo einfo = info as EurekaServiceInfo; var clientSection = config.GetSection(EurekaClientOptions.EUREKA_CLIENT_CONFIGURATION_PREFIX); container.RegisterOption <EurekaClientOptions>(clientSection); container.RegisterPostConfigure <EurekaClientOptions>((options) => { PivotalEurekaConfigurer.UpdateConfiguration(config, einfo, options); }); var instSection = config.GetSection(EurekaInstanceOptions.EUREKA_INSTANCE_CONFIGURATION_PREFIX); container.RegisterOption <EurekaInstanceOptions>(instSection); container.RegisterPostConfigure <EurekaInstanceOptions>((options) => { PivotalEurekaConfigurer.UpdateConfiguration(config, einfo, options); }); AddEurekaServices(container, lifecycle); } else { throw new ArgumentException("Discovery client type UNKNOWN, check configuration"); } }
public static void RegisterDiscoveryClient( this ContainerBuilder container, IConfiguration config, string serviceName, IDiscoveryLifecycle lifecycle = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (string.IsNullOrEmpty(serviceName)) { throw new ArgumentNullException(nameof(serviceName)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } IServiceInfo info = GetNamedDiscoveryServiceInfo(config, serviceName); AddDiscoveryServices(container, info, config, lifecycle); }
private static void AddEurekaServices(ContainerBuilder container, IDiscoveryLifecycle lifecycle) { container.RegisterType <EurekaApplicationInfoManager>().SingleInstance(); container.RegisterType <EurekaDiscoveryManager>().SingleInstance(); container.RegisterType <EurekaDiscoveryClient>().AsSelf().As <IDiscoveryClient>().SingleInstance(); if (lifecycle == null) { container.RegisterType <ApplicationLifecycle>().As <IDiscoveryLifecycle>(); } else { container.RegisterInstance(lifecycle).SingleInstance(); } }
public static IServiceCollection AddConsulDiscoveryClient( this IServiceCollection services, IConfiguration configuration, IDiscoveryLifecycle lifecycle = null) { var consulConfigSection = configuration.GetSection("consul"); services.Configure <ConsulOptions>(consulConfigSection); var discoveryConfigurationSection = consulConfigSection.GetSection("discovery"); services.Configure <ConsulDiscoveryOptions>(discoveryConfigurationSection); services.Configure <HeartbeatOptions>(discoveryConfigurationSection.GetSection("heartbeat")); services.PostConfigure <ConsulDiscoveryOptions>(options => { if (!options.PreferIpAddress && string.IsNullOrWhiteSpace(options.HostName)) { options.HostName = Dns.GetHostName(); } if (string.IsNullOrWhiteSpace(options.InstanceId)) { options.InstanceId = configuration["spring:application:instance_id"]; } if (string.IsNullOrWhiteSpace(options.InstanceId)) { options.InstanceId = options.HostName + ":" + options.Port; } if (string.IsNullOrWhiteSpace(options.ServiceName)) { options.ServiceName = configuration["spring:application:name"]; } if (string.IsNullOrWhiteSpace(options.ServiceName)) { options.ServiceName = configuration["applicationName"]; } }); AddConsulServices(services, lifecycle); return(services); }
private static void AddEurekaServices(IServiceCollection services, IDiscoveryLifecycle lifecycle) { services.AddSingleton <EurekaApplicationInfoManager>(); services.AddSingleton <EurekaDiscoveryManager>(); services.AddSingleton <PivotalEurekaDiscoveryClient>(); if (lifecycle == null) { services.AddSingleton <IDiscoveryLifecycle, ApplicationLifecycle>(); } else { services.AddSingleton(lifecycle); } services.AddSingleton <IDiscoveryClient>((p) => p.GetService <PivotalEurekaDiscoveryClient>()); }
private static void AddDiscoveryServices( ContainerBuilder container, IServiceInfo info, IConfiguration config, IDiscoveryLifecycle lifecycle) { if (IsEurekaConfigured(config, info)) { ConfigureEurekaServices(container, config, info); AddEurekaServices(container, lifecycle); } else if (IsConsulConfigured(config, info)) { ConfigureConsulServices(container, config, info); AddConsulServices(container, config, lifecycle); } else { throw new ArgumentException("Discovery client type UNKNOWN, check configuration"); } }
private static void AddEurekaServices(IServiceCollection services, IDiscoveryLifecycle lifecycle) { services.AddSingleton <EurekaApplicationInfoManager>(); services.AddSingleton <EurekaDiscoveryManager>(); services.AddSingleton <EurekaDiscoveryClient>(); if (lifecycle == null) { services.AddSingleton <IDiscoveryLifecycle, ApplicationLifecycle>(); } else { services.AddSingleton(lifecycle); } services.AddSingleton <IDiscoveryClient>((p) => { var eurekaService = p.GetService <EurekaDiscoveryClient>(); // Wire in health checker if present if (eurekaService != null) { eurekaService.HealthCheckHandler = p.GetService <IHealthCheckHandler>(); } return(eurekaService); }); services.AddSingleton <IServiceInstanceProvider>(p => p.GetService <EurekaDiscoveryClient>()); services.AddSingleton <IHealthContributor, EurekaServerHealthContributor>(); var serviceProvider = services.BuildServiceProvider(); var certOptions = serviceProvider.GetService <IOptions <CertificateOptions> >(); var existingHandler = serviceProvider.GetService <IHttpClientHandlerProvider>(); if (certOptions != null && existingHandler is null) { services.AddSingleton <IHttpClientHandlerProvider, ClientCertificateHttpHandlerProvider>(); } }
public static IServiceCollection AddDiscoveryClient(this IServiceCollection services, Action <DiscoveryOptions> setupOptions, IDiscoveryLifecycle lifecycle = null) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (setupOptions == null) { throw new ArgumentNullException(nameof(setupOptions)); } var options = new DiscoveryOptions(); setupOptions(options); return(services.AddDiscoveryClient(options, lifecycle)); }
public static IServiceCollection AddDiscoveryClient(this IServiceCollection services, DiscoveryOptions discoveryOptions, IDiscoveryLifecycle lifecycle = null) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (discoveryOptions == null) { throw new ArgumentNullException(nameof(discoveryOptions)); } if (discoveryOptions.ClientType == DiscoveryClientType.EUREKA) { EurekaClientOptions clientOptions = discoveryOptions.ClientOptions as EurekaClientOptions; if (clientOptions == null) { throw new ArgumentException("Missing Client Options"); } services.AddSingleton <IOptionsMonitor <EurekaClientOptions> >(new OptionsMonitorWrapper <EurekaClientOptions>(clientOptions)); var regOptions = discoveryOptions.RegistrationOptions as EurekaInstanceOptions; if (regOptions == null) { clientOptions.ShouldRegisterWithEureka = false; regOptions = new EurekaInstanceOptions(); } services.AddSingleton <IOptionsMonitor <EurekaInstanceOptions> >(new OptionsMonitorWrapper <EurekaInstanceOptions>(regOptions)); AddEurekaServices(services, lifecycle); } else { throw new ArgumentException("Client type UNKNOWN"); } services.TryAddTransient <DiscoveryHttpMessageHandler>(); return(services); }
private static void AddDiscoveryServices(IServiceCollection services, IServiceInfo info, IConfiguration config, IDiscoveryLifecycle lifecycle) { var netOptions = config.GetSection(InetOptions.PREFIX).Get <InetOptions>(); if (IsEurekaConfigured(config, info)) { ConfigureEurekaServices(services, config, info, netOptions); AddEurekaServices(services, lifecycle); } else if (IsConsulConfigured(config, info)) { ConfigureConsulServices(services, config, info, netOptions); AddConsulServices(services, config, lifecycle); } else { throw new ArgumentException("Discovery client type UNKNOWN, check configuration"); } services.TryAddTransient <DiscoveryHttpMessageHandler>(); services.AddSingleton <IServiceInstanceProvider>(p => p.GetService <IDiscoveryClient>()); }
private static void AddConsulServices(IServiceCollection services, IConfiguration config, IDiscoveryLifecycle lifecycle) { services.AddSingleton((p) => { var consulOptions = p.GetRequiredService <IOptions <ConsulOptions> >(); return(ConsulClientFactory.CreateClient(consulOptions.Value)); }); services.AddSingleton <IScheduler, TtlScheduler>(); services.AddSingleton <IConsulServiceRegistry, ConsulServiceRegistry>(); services.AddSingleton <IConsulRegistration>((p) => { var opts = p.GetRequiredService <IOptions <ConsulDiscoveryOptions> >(); return(ConsulRegistration.CreateRegistration(config, opts.Value)); }); services.AddSingleton <IConsulServiceRegistrar, ConsulServiceRegistrar>(); services.AddSingleton <IDiscoveryClient, ConsulDiscoveryClient>(); services.AddSingleton <IServiceInstanceProvider, ConsulDiscoveryClient>(); services.AddSingleton <IHealthContributor, ConsulHealthContributor>(); }
internal DiscoveryClientService(IDiscoveryLifecycle applicationLifetime) { _applicationLifetime = applicationLifetime; }
/// <summary> /// Adds service discovery to your application. Uses reflection to determine which clients are available and configured. /// If no clients are available or configured, a <see cref="NoOpDiscoveryClient"/> will be configured /// </summary> /// <param name="services"><see cref="IServiceCollection"/> to configure</param> /// <param name="config">Application configuration</param> /// <param name="lifecycle">Add custom code for app shutdown events</param> public static IServiceCollection AddDiscoveryClient(this IServiceCollection services, IConfiguration config, IDiscoveryLifecycle lifecycle = null) { return(services.AddDiscoveryClient(config, null, lifecycle)); }
public static void RegisterDiscoveryClient(this ContainerBuilder container, Action <DiscoveryOptions> setupOptions, IDiscoveryLifecycle lifecycle = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (setupOptions == null) { throw new ArgumentNullException(nameof(setupOptions)); } var options = new DiscoveryOptions(); setupOptions(options); container.RegisterDiscoveryClient(options, lifecycle); }
private static void AddDiscoveryServices(IServiceCollection services, IConfiguration config, IDiscoveryLifecycle lifecycle) { var clientConfigsection = config.GetSection(EUREKA_PREFIX); int childCount = clientConfigsection.GetChildren().Count(); if (childCount > 0) { var clientSection = config.GetSection(EurekaClientOptions.EUREKA_CLIENT_CONFIGURATION_PREFIX); services.Configure <EurekaClientOptions>(clientSection); var instSection = config.GetSection(EurekaInstanceOptions.EUREKA_INSTANCE_CONFIGURATION_PREFIX); services.Configure <EurekaInstanceOptions>(instSection); services.PostConfigure <EurekaInstanceOptions>((options) => { EurekaPostConfigurer.UpdateConfiguration(config, options); }); AddEurekaServices(services, lifecycle); } else { throw new ArgumentException("Discovery client type UNKNOWN, check configuration"); } }
private static IDiscoveryClient CreateDiscoveryClient(IServiceInfo info, IConfiguration config, IDiscoveryLifecycle lifecycle) { var clientConfigsection = config.GetSection(EUREKA_PREFIX); int childCount = clientConfigsection.GetChildren().Count(); if (childCount > 0) { EurekaServiceInfo einfo = info as EurekaServiceInfo; var clientSection = config.GetSection(EurekaClientOptions.EUREKA_CLIENT_CONFIGURATION_PREFIX); EurekaClientOptions clientOptions = new EurekaClientOptions(); ConfigurationBinder.Bind(clientSection, clientOptions); if (einfo != null) { PivotalEurekaConfigurer.UpdateConfiguration(config, einfo, clientOptions); } var instSection = config.GetSection(EurekaInstanceOptions.EUREKA_INSTANCE_CONFIGURATION_PREFIX); EurekaInstanceOptions instOptions = new EurekaInstanceOptions(); ConfigurationBinder.Bind(instSection, instOptions); if (einfo != null) { PivotalEurekaConfigurer.UpdateConfiguration(config, einfo, instOptions); } var manager = new EurekaApplicationInfoManager(new OptionsMonitorWrapper <EurekaInstanceOptions>(instOptions), LoggingConfig.LoggerFactory); return(new PivotalEurekaDiscoveryClient( new OptionsMonitorWrapper <EurekaClientOptions>(clientOptions), new OptionsMonitorWrapper <EurekaInstanceOptions>(instOptions), manager, null, LoggingConfig.LoggerFactory)); } else { throw new ArgumentException("Unable to create Eureka client"); } }
public static void Register(IConfiguration configuration, IDiscoveryLifecycle discoveryLifecycle) { IServiceInfo info = GetSingletonDiscoveryServiceInfo(configuration); DiscoveryClient = CreateDiscoveryClient(info, configuration, discoveryLifecycle); }
private static void AddNacosServices(IServiceCollection services, IConfiguration config, IDiscoveryLifecycle lifecycle) { services.AddSingleton <INacosNamingClient, NacosNamingClient>(); services.AddSingleton <INacosRegistration>(c => { var opts = c.GetRequiredService <IOptions <NacosDiscoveryOptions> >(); return(NacosRegistration.CreateRegistration(config, opts.Value)); }); services.AddSingleton <INacosServiceRegistry, NacosServiceRegistry>(); services.AddSingleton <INacosServiceRegistrar, NacosServiceRegistrar>(); services.AddSingleton <IDiscoveryClient, NacosDiscoveryClient>(); if (lifecycle == null) { services.AddSingleton <IDiscoveryLifecycle, ApplicationLifecycle>(); } else { services.AddSingleton(lifecycle); } services.AddSingleton <IHealthContributor, NacosHealthContributor>(); }
private static void AddConsulServices(ContainerBuilder container, IConfiguration config, IDiscoveryLifecycle lifecycle) { container.Register(c => { var opts = c.Resolve <IOptions <ConsulOptions> >(); return(ConsulClientFactory.CreateClient(opts.Value)); }).As <IConsulClient>().SingleInstance(); container.RegisterType <TtlScheduler>().As <IScheduler>().SingleInstance(); container.RegisterType <ConsulServiceRegistry>().As <IConsulServiceRegistry>().SingleInstance(); container.Register(c => { var opts = c.Resolve <IOptions <ConsulDiscoveryOptions> >(); return(ConsulRegistration.CreateRegistration(config, opts.Value)); }).As <IConsulRegistration>().SingleInstance(); container.RegisterType <ConsulServiceRegistrar>().As <IConsulServiceRegistrar>().SingleInstance(); container.RegisterType <ConsulDiscoveryClient>().As <IDiscoveryClient>().SingleInstance(); container.RegisterType <ConsulHealthContributor>().As <IHealthContributor>().SingleInstance(); }
public static IServiceCollection AddDiscoveryClient(this IServiceCollection services, IConfiguration config, IDiscoveryLifecycle lifecycle = null) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } IServiceInfo info = GetSingletonDiscoveryServiceInfo(config); AddDiscoveryServices(services, info, config, lifecycle); return(services); }
public static void RegisterDiscoveryClient(this ContainerBuilder container, DiscoveryOptions discoveryOptions, IDiscoveryLifecycle lifecycle = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (discoveryOptions == null) { throw new ArgumentNullException(nameof(discoveryOptions)); } if (discoveryOptions.ClientType == DiscoveryClientType.EUREKA) { EurekaClientOptions clientOptions = discoveryOptions.ClientOptions as EurekaClientOptions; if (clientOptions == null) { throw new ArgumentException("Missing Client Options"); } container.RegisterInstance(new OptionsMonitorWrapper <EurekaClientOptions>(clientOptions)).As <IOptionsMonitor <EurekaClientOptions> >().SingleInstance(); var regOptions = discoveryOptions.RegistrationOptions as EurekaInstanceOptions; if (regOptions == null) { clientOptions.ShouldRegisterWithEureka = false; regOptions = new EurekaInstanceOptions(); } container.RegisterInstance(new OptionsMonitorWrapper <EurekaInstanceOptions>(regOptions)).As <IOptionsMonitor <EurekaInstanceOptions> >().SingleInstance(); AddEurekaServices(container, lifecycle); } else { throw new ArgumentException("Client type UNKNOWN"); } }
public static IServiceCollection AddDiscoveryClient(this IServiceCollection services, IConfiguration config, string serviceName, IDiscoveryLifecycle lifecycle = null) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (string.IsNullOrEmpty(serviceName)) { throw new ArgumentNullException(nameof(serviceName)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } IServiceInfo info = GetNamedDiscoveryServiceInfo(config, serviceName); AddDiscoveryServices(services, info, config, lifecycle); return(services); }
public static void RegisterDiscoveryClient(this ContainerBuilder container, IConfiguration config, IDiscoveryLifecycle lifecycle = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } IServiceInfo info = GetSingletonDiscoveryServiceInfo(config); AddDiscoveryServices(container, info, config, lifecycle); }
private static void AddDiscoveryServices(IServiceCollection services, IServiceInfo info, IConfiguration config, IDiscoveryLifecycle lifecycle) { if (IsEurekaConfigured(config, info)) { ConfigureEurekaServices(services, config, info); AddEurekaServices(services, lifecycle); } else if (IsConsulConfigured(config, info)) { ConfigureConsulServices(services, config, info); AddConsulServices(services, config, lifecycle); } else { throw new ArgumentException("Discovery client type UNKNOWN, check configuration"); } services.TryAddTransient <DiscoveryHttpMessageHandler>(); }
/// <summary> /// Adds service discovery to your application. Uses reflection to determine which clients are available and configured. /// If no clients are available or configured, a <see cref="NoOpDiscoveryClient"/> will be configured /// </summary> /// <param name="services"><see cref="IServiceCollection"/> to configure</param> /// <param name="config">Application configuration</param> /// <param name="serviceName">Specify the name of a service binding to use</param> /// <param name="lifecycle">Add custom code for app shutdown events</param> public static IServiceCollection AddDiscoveryClient(this IServiceCollection services, IConfiguration config, string serviceName = null, IDiscoveryLifecycle lifecycle = null) { Action <DiscoveryClientBuilder> builderAction = null; config ??= services.BuildServiceProvider().GetRequiredService <IConfiguration>(); var info = string.IsNullOrEmpty(serviceName) ? GetSingletonDiscoveryServiceInfo(config) : GetNamedDiscoveryServiceInfo(config, serviceName); // iterate assemblies for implementations of IDiscoveryClientExtension var implementations = new List <IDiscoveryClientExtension>(); var extensions = ReflectionHelpers.FindInterfacedTypesFromAssemblyAttribute <DiscoveryClientAssemblyAttribute>(); foreach (var clientExtension in extensions) { implementations.Add(Activator.CreateInstance(clientExtension) as IDiscoveryClientExtension); } if (implementations.Count == 1) { builderAction = builder => builder.Extensions.Add(implementations.First()); } else if (implementations.Count > 1) { // if none configured, that's ok because AddServiceDiscovery has a plan var configured = implementations.Where(client => client.IsConfigured(config, info)); if (configured.Count() == 1) { builderAction = builder => builder.Extensions.Add(configured.Single()); } else if (configured.Count() > 1) { throw new AmbiguousMatchException("Multiple IDiscoveryClient implementations have been added and configured! This is not supported, please only configure a single client type."); } } if (lifecycle != null) { services.AddSingleton(lifecycle); } return(services.AddServiceDiscovery(builderAction)); }
public DiscoveryClientService(IDiscoveryClient client, IDiscoveryLifecycle applicationLifetime = null) { _applicationLifetime = applicationLifetime; _discoveryClient = client; }