public void CreateClient_Succeeds() { var opts = new ConsulOptions() { Host = "foobar", Datacenter = "datacenter", Token = "token", Username = "******", Password = "******", Port = 5555, Scheme = "https", WaitTime = "5s" }; var client = ConsulClientFactory.CreateClient(opts) as ConsulClient; Assert.NotNull(client); Assert.NotNull(client.Config); Assert.Equal(opts.Datacenter, client.Config.Datacenter); Assert.Equal(opts.Token, client.Config.Token); Assert.Equal(opts.Host, client.Config.Address.Host); Assert.Equal(opts.Port, client.Config.Address.Port); Assert.Equal(opts.Scheme, client.Config.Address.Scheme); Assert.Equal(new TimeSpan(0, 0, 5), client.Config.WaitTime); }
public static IServiceCollection AddConsulDiscovery(this IServiceCollection services, Uri address, Action <ConsulDiscoveryBuilder> action = null) { var builder = new ConsulDiscoveryBuilder(address); action?.Invoke(builder); if (builder.Address == null) { throw new ArgumentNullException(nameof(builder.Address)); } if (builder.CacheRefreshInterval < 5) { throw new ArgumentOutOfRangeException(nameof(builder.CacheRefreshInterval), "Must be greater than or equal to 5"); } services.AddSingleton <IServiceRegistrar>(provider => { return(new ConsulServiceRegistrar(ConsulClientFactory.Create(builder.Address))); }); services.AddSingleton <IServiceDiscovery>(provider => { return(new ConsulServiceDiscovery(ConsulClientFactory.Create(builder.Address))); }); services.AddSingleton(typeof(IServiceSelector), builder.ServiceSelectorType); services.AddSingleton <IServicePool>(provider => { var options = new ServicePoolOptions() { CacheRefreshInterval = builder.CacheRefreshInterval }; return(new ServicePool(provider.GetService <IServiceDiscovery>(), provider.GetService <IServiceSelector>(), options)); }); return(services); }
public override void Load() { Data.Clear(); using (IConsulClient client = new ConsulClientFactory().Create(_source.Options)) { string path = _source.ApplicationOptions.GetApplicationConfigurationPath("appsettings"); // TODO Convert to ASYNC. // TODO Reload. QueryResult <KVPair> result = client.KV.Get(path) .GetAwaiter() .GetResult(); if (result.StatusCode != HttpStatusCode.OK) { throw new HyperionLoadException($"Error loading configurations from consul.HttpStatusCode: {result.StatusCode}. RequestTime: {result.RequestTime}"); } string json = Encoding.UTF8.GetString(result.Response.Value, 0, result.Response.Value.Length); if (string.IsNullOrEmpty(json)) { throw new HyperionLoadException($"Could not find any configuration with the key {path}."); } Data = new JsonParser().Parse(JObject.Parse(json)); } }
public void CreateClient_Options_Override() { var datacenter = "datacenter"; var address = new Uri("http://address"); var token = "token"; var waitTime = TimeSpan.FromSeconds(30); var monitor = ConsulOptionsTestHelper.CreateOptionsMonitor( new[] { new ConfigureOptions <ConsulClientConfiguration>(options => { options.Datacenter = datacenter; options.Address = address; options.Token = token; options.WaitTime = waitTime; }) }); var factory = new ConsulClientFactory(monitor); var client = factory.CreateClient() as ConsulClient; var configuration = client.Config; Assert.Same(monitor.Get(Options.DefaultName), configuration); Assert.Equal(datacenter, configuration.Datacenter); Assert.Equal(address, configuration.Address); Assert.Equal(token, configuration.Token); Assert.Equal(waitTime, configuration.WaitTime); }
public async Task DeregisterSelfAsync() { using (var consulClient = ConsulClientFactory.Create()) { foreach (var serviceName in serviceIds.Keys) { await consulClient.Agent.ServiceDeregister(serviceIds[serviceName]); } } }
static void Register() { var consulClient = ConsulClientFactory.Create(new ConsulDiscoveryConfiguration() { Address = consulAddress }); ConsulServiceRegistrar registrar = new ConsulServiceRegistrar(consulClient); var info = registrar.RegisterServiceAsync("testServiceName", "v1.0", "192.168.0.81", 8080).Result; registrar.DeregisterServiceAsync(info.Id).Wait(); }
public async Task <CatalogService[]> GetCatalogServicesAsync(string serviceName, string serviceSpace = null, string serviceTag = null) { var scopedServiceName = GetScopedServiceName(serviceName, serviceSpace); using (var consulClient = ConsulClientFactory.Create()) { var queryResult = string.IsNullOrEmpty(serviceTag) ? await consulClient.Catalog.Service(scopedServiceName) : await consulClient.Catalog.Service(scopedServiceName, serviceTag); return(queryResult.Response); } }
public ConsulDiscoveryProvider(ILogger <ConsulDiscoveryProvider> logger, ShepherdConfiguration configuration, ConsulClientFactory consulClientFactory) { _logger = logger; _consulClientFactory = consulClientFactory; _channel = Channel.CreateBounded <VaultEvent>(new BoundedChannelOptions(64) { FullMode = BoundedChannelFullMode.DropOldest }); _consulServiceName = configuration.Discovery.Consul.ServiceName ?? throw new ArgumentException("Key 'Discovery:Consul:ServiceName' is invalid."); _consulAddress = configuration.Discovery.Consul.Address ?? throw new ArgumentException("Key 'Discovery:Consul:Address' is invalid."); _consulToken = configuration.Discovery.Consul.Token; _consulDatacenter = configuration.Discovery.Consul.Datacenter; }
public async Task <TValue> GetJsonSettingAsync <TValue>(string key, string semicolonsJoinedPropertyNames, string serviceSpace = null) { VallidateSettingKey(key); string scopedKey = GetScopedKey(key, serviceSpace); using (var consulClient = ConsulClientFactory.Create()) { var result = await consulClient.KV.Get(scopedKey); if (result.StatusCode == System.Net.HttpStatusCode.OK) { var returnValue = JsonConfigProvider.GetValueFromJson <TValue>(result.Response.Value, semicolonsJoinedPropertyNames); return(returnValue); } return(default);
public async Task <string> GetSettingAsync(string key, string serviceSpace = null) { VallidateSettingKey(key); string scopedKey = GetScopedKey(key, serviceSpace); using (var consulClient = ConsulClientFactory.Create()) { var result = await consulClient.KV.Get(scopedKey); if (result.StatusCode == System.Net.HttpStatusCode.OK) { return(Encoding.UTF8.GetString(result.Response.Value, 0, result.Response.Value.Length)); } return(null); } }
/// <summary> /// Adds the consul configuration. /// </summary> /// <param name="hostBuilder">The host builder.</param> /// <param name="convensionSetting"> /// Convention builder for setting the Consul hierarchic structure. /// Default convention is: Application, Environment, Component</param> /// <param name="address">Optional address of the console service. /// If missing will check: /// * Environment variable: consul-url /// * default (if don't find anything): http://127.0.0.1:8500 /// .</param> /// <param name="configOverride">Enable to override configuration.</param> /// <param name="httpClientOverride">Enable to override HTTP client.</param> /// <param name="httpClientHandlerOverride">Enable to override HTTP client handler.</param> /// <returns></returns> public static IHostBuilder AddConsulConfiguration( this IHostBuilder hostBuilder, Func <IConsulHierarchyBuilder, IConsulHierarchy>?hierarchyConventionSetting = null, string?address = null, Action <ConsulClientConfiguration>?configOverride = null, Action <HttpClient>?httpClientOverride = null, Action <HttpClientHandler>?httpClientHandlerOverride = null) { var options = new ConsulClientOptions(address, configOverride, httpClientOverride, httpClientHandlerOverride); IConsulFactory factory = new ConsulClientFactory(options); hostBuilder.ConfigureServices((hostContext, services) => { services.AddSingleton(factory); }); hostBuilder.ConfigureAppConfiguration( (host, builder) => { // string consoleUrl = host.Configuration["Consul:Host"]; IHostEnvironment env = host.HostingEnvironment; #region IConsulHierarchy hierarchyConvention = ... IConsulHierarchyBuilder hierarchyBuilder = new HierarchyBuilder(env); IConsulHierarchy hierarchyConvention = hierarchyConventionSetting?.Invoke(hierarchyBuilder) ?? hierarchyBuilder.ByAppName() .ByEnvironment() //.ByComponent() .Build(); #endregion // IConsulHierarchy hierarchyConvention = ... builder.SetBasePath(env.ContentRootPath); var configSource = new ConsulConfigurationSource(hierarchyConvention, factory); builder.Add(configSource); // builder.AddEnvironmentVariables(); }); return(hostBuilder); }
private static void AddConsulServices(IServiceCollection services, IConfiguration config, IDiscoveryLifecycle lifecycle) { services.AddSingleton <IConsulClient>((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 <IHealthContributor, ConsulHealthContributor>(); }
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(); }
static void RegisterAndGetServices() { var consulClient = ConsulClientFactory.Create(new ConsulDiscoveryConfiguration() { Address = consulAddress }); ConsulServiceRegistrar registrar = new ConsulServiceRegistrar(consulClient); var info = registrar.RegisterServiceAsync("testServiceName", "v1.0", "192.168.0.81", 8080).Result; var info2 = registrar.RegisterServiceAsync("testServiceName", "v1.1", "192.168.0.81", 8090).Result; var info3 = registrar.RegisterServiceAsync("testServiceName", "v1.0", "192.168.0.81", 10101).Result; ConsulServiceDiscovery discovery = new ConsulServiceDiscovery(consulClient, new ConsulDiscoveryConfiguration() { Address = consulAddress }); var services = discovery.GetServicesAsync("testServiceName").Result; var services2 = discovery.GetServicesAsync("testServiceName", "v1.0").Result; var service = discovery.GetServiceAsync("testServiceName").Result; }
public async Task <bool> PutSettingAsync(string key, string value, string serviceSpace = null) { VallidateSettingKey(key); string scopedKey = GetScopedKey(key, serviceSpace); var putPair = new KVPair(scopedKey) { Value = Encoding.UTF8.GetBytes(value) }; using (var consulClient = ConsulClientFactory.Create()) { var result = await consulClient.KV.Put(putPair); if (result.StatusCode == System.Net.HttpStatusCode.OK) { return(result.Response); } return(false); } }
public void CreateClient_ThrowsNullOptions() { Assert.Throws <ArgumentNullException>(() => ConsulClientFactory.CreateClient(null)); }
public async Task RegisterSelfAsync(Action <Dictionary <string, string> > appendMetaAction = null) { var serviceDescription = LocalServiceDescriptionProvider.Build(); var serviceSchema = serviceDescription.ServiceSchema ?? "http"; var registeringServiceAddress = $"{serviceSchema}://{serviceDescription.Host}:{serviceDescription.Port}"; var virtualDirectory = serviceDescription.VirtualDirectory.Trim('/'); var serviceMeta = new Dictionary <string, string> { { ServiceGovernanceConsts.ServiceSchema, serviceSchema } }; if (appendMetaAction != null) { appendMetaAction.Invoke(serviceMeta); } if (!string.IsNullOrEmpty(virtualDirectory)) { serviceMeta.Add(ServiceGovernanceConsts.ServiceVirtualDirectory, serviceDescription.VirtualDirectory); registeringServiceAddress = $"{registeringServiceAddress}/{serviceDescription.VirtualDirectory}"; } var serviceCheck = new AgentServiceCheck { Interval = ServiceGovernanceConfig.ServiceCheckInterval, HTTP = $"{registeringServiceAddress}/{serviceDescription.HealthCheckRoute.Trim('/') ?? string.Empty}", Timeout = ServiceGovernanceConfig.ServiceCheckTimeout, }; if (!IsDevelopmentEnvironment()) { serviceCheck.DeregisterCriticalServiceAfter = ServiceGovernanceConfig.DeregisterCriticalServiceAfter; } var serviceNames = new List <string> { serviceDescription.ServiceName }; if (serviceDescription.ServiceAliases != null && serviceDescription.ServiceAliases.Contains(",")) { foreach (var serviceAlias in serviceDescription.ServiceAliases.Split(',')) { var trimmedAlias = serviceAlias.Trim(); if (!string.IsNullOrEmpty(trimmedAlias)) { serviceNames.Add(trimmedAlias); } } } using (var consulClient = ConsulClientFactory.Create()) { foreach (var serviceName in serviceNames) { var serviceRegistration = new AgentServiceRegistration { Checks = new[] { serviceCheck }, ID = Guid.NewGuid().ToString(), Address = serviceDescription.Host, Port = serviceDescription.Port == 0 ? 80 : serviceDescription.Port, Meta = serviceMeta, }; if (string.IsNullOrEmpty(serviceDescription.ServiceSpace)) { serviceRegistration.Name = serviceName; serviceRegistration.Tags = new[] { $"urlprefix-/{serviceRegistration.Name}" }; } else { serviceRegistration.Name = $"{serviceDescription.ServiceSpace}.{serviceName}"; serviceRegistration.Tags = new[] { serviceDescription.ServiceSpace, $"urlprefix-/{serviceRegistration.Name}" }; } var existingServices = (await consulClient.Catalog.Service(serviceRegistration.Name)).Response; foreach (var service in existingServices) { var registeredServiceAddress = service.GetRegisteredServiceAddress(); if (registeredServiceAddress == registeringServiceAddress) { await consulClient.Agent.ServiceDeregister(service.ServiceID); } } var result = await consulClient.Agent.ServiceRegister(serviceRegistration); if (result.StatusCode == System.Net.HttpStatusCode.OK) { serviceIds.Add(serviceRegistration.Name, serviceRegistration.ID); } } } }