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