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;
}