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 AgentServiceRegistration CreateRegistration(ConsulOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var serviceHost = options.ServiceHost ?? throw new ArgumentNullException(nameof(options.ServiceHost));
var servicePort = options.ServicePort ?? throw new ArgumentNullException(nameof(options.ServicePort));
var serviceName = options.ServiceName ?? throw new ArgumentNullException(nameof(options.ServiceName));
var healthCheck = options.HealthCheck ?? throw new ArgumentNullException(nameof(options.HealthCheck));
var httpCheck = new AgentServiceCheck()
{
DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(options.DeregisterCriticalServiceAfter),
Interval = TimeSpan.FromSeconds(options.Interval),
HTTP = $"{options.Scheme}{serviceHost}:{servicePort}{healthCheck}",
Timeout = TimeSpan.FromSeconds(options.Timeout)
};
var registration = new AgentServiceRegistration()
{
Checks = new[] { httpCheck },
ID = $"{serviceName}_{serviceHost}_{servicePort}",
Name = serviceName,
Address = options.Scheme + serviceHost,
Port = Convert.ToInt32(servicePort),
Tags = options.Tags,
Meta = options.Meta
};
return(registration);
}
private static ConsulClient CreateConsulClient(ConsulOptions options)
{
return(new ConsulClient(s =>
{
s.Address = new Uri($"{options.Scheme}://{options.Host}:{options.Port}");
}));
}
public static IConveyBuilder AddConsul(this IConveyBuilder builder, ConsulOptions options,
HttpClientOptions httpClientOptions)
{
builder.Services.AddSingleton(options);
if (!options.Enabled || !builder.TryRegister(RegistryName))
{
return(builder);
}
if (httpClientOptions.Type?.ToLowerInvariant() == "consul")
{
builder.Services.AddTransient <ConsulServiceDiscoveryMessageHandler>();
builder.Services.AddHttpClient <IConsulHttpClient, ConsulHttpClient>("consul-http")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
builder.RemoveHttpClient();
builder.Services.AddHttpClient <IHttpClient, ConsulHttpClient>("consul")
.AddHttpMessageHandler <ConsulServiceDiscoveryMessageHandler>();
}
builder.Services.AddTransient <IConsulServicesRegistry, ConsulServicesRegistry>();
var registration = builder.CreateConsulAgentRegistration(options);
if (registration is null)
{
return(builder);
}
builder.Services.AddSingleton(registration);
return(builder);
}
public static IDrexBuilder AddServiceClient <T>(this IDrexBuilder builder, string serviceName,
RestEaseOptions options, ConsulOptions consulOptions, FabioOptions fabioOptions,
HttpClientOptions httpClientOptions)
where T : class
{
return(builder.AddServiceClient <T>(serviceName, options,
b => b.AddFabio(fabioOptions, consulOptions, httpClientOptions)));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//add consul service
ConsulOptions consulOptions = Configuration.GetSection("ConsulOptions").Get <ConsulOptions>();
services.AddConsul(consulOptions);
services.AddControllers();
}
private static ConsulHealthCheck CreateHealthCheck(IServiceProvider sp, Action <ConsulOptions> setup, string name)
{
var options = new ConsulOptions();
setup?.Invoke(options);
var httpClientFactory = sp.GetRequiredService <IHttpClientFactory>();
return(new ConsulHealthCheck(options, () => httpClientFactory.CreateClient(name)));
}
public void Constructor_InitializesDefaults()
{
var opts = new ConsulOptions();
Assert.Null(opts.Datacenter);
Assert.Null(opts.Password);
Assert.Null(opts.Username);
Assert.Null(opts.WaitTime);
Assert.Null(opts.Token);
Assert.Equal("localhost", opts.Host);
Assert.Equal("http", opts.Scheme);
Assert.Equal(8500, opts.Port);
}
public ConsulServiceDiscoveryMessageHandler(IConsulServicesRegistry servicesRegistry,
ConsulOptions options, string serviceName = null, bool?overrideRequestUri = null)
{
if (string.IsNullOrWhiteSpace(options.Url))
{
throw new InvalidOperationException("Consul URL was not provided.");
}
_servicesRegistry = servicesRegistry;
_options = options;
_serviceName = serviceName;
_overrideRequestUri = overrideRequestUri;
}
/// <summary>
/// Add a health check for Consul services.
/// </summary>
/// <param name="builder">The <see cref="IHealthChecksBuilder"/>.</param>
/// <param name="consulHost">The Consul server hostname.</param>
/// <param name="consulPort">The Consul server port.</param>
/// <param name="name">The health check name. Optional. If <c>null</c> the type name 'consul' will be used for the name.</param>
/// <param name="failureStatus">
/// The <see cref="HealthStatus"/> that should be reported when the health check fails. Optional. If <c>null</c> then
/// the default status of <see cref="HealthStatus.Unhealthy"/> will be reported.
/// </param>
/// <param name="tags">A list of tags that can be used to filter sets of health checks. Optional.</param>
/// <returns>The <see cref="IHealthChecksBuilder"/>.</returns></param>
public static IHealthChecksBuilder AddConsul(this IHealthChecksBuilder builder, Action <ConsulOptions> setup, string name = default, HealthStatus?failureStatus = default, IEnumerable <string> tags = default)
{
var options = new ConsulOptions();
setup?.Invoke(options);
builder.Services.AddHttpClient();
var registrationName = name ?? NAME;
return(builder.Add(new HealthCheckRegistration(
registrationName,
sp => CreateHealthCheck(sp, options, registrationName),
failureStatus,
tags)));
}
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Startup>()
.UseApplicationInsights()
.Build();
var options = new ConsulOptions();
options.Host = ConsulIP;
options.HealthCheckPath = "/api/values";
var loggerFactory = new LoggerFactory();
var logger = loggerFactory.CreateLogger("logger");
var provider = new ConsulProvider(loggerFactory, Options.Create(options));
Cluster.RegisterService(new Uri(string.Format("http://{0}", Environment.MachineName)), provider, "articles", "v1", logger);
host.Run();
}
public static IServiceCollection AddConsul(this IServiceCollection services)
{
IConfiguration configuration;
using (var serviceProvider = services.BuildServiceProvider())
{
configuration = serviceProvider.GetService <IConfiguration>();
}
services.Configure <ConsulOptions>(configuration.GetSection("consul"));
ConsulOptions consulOptions = new ConsulOptions();
configuration.GetSection("consul").Bind(consulOptions);
return(services.AddSingleton <IConsulClient>(x => new ConsulClient(cfg =>
{
cfg.Address = consulOptions.ServiceDiscoveryAddress;
})));
}
static void Main(string[] args)
{
var options = new ConsulOptions()
{
NamespaceName = "Atlantis.Simple",
ServiceName = "AtlantisService",
ScanAssemblies = new string[]
{
typeof(IPersonServicer).Assembly.FullName
},
ServerName = "Atlantis.Test",
ConsulAddressUrl = "http://192.168.0.251:8500",
};
var client = new GrpcClientAgent(options);
var servicer = client.GetService <IPersonServicer>();
var message = new HelloMessage()
{
Name = "DotNet"
};
var result = servicer.HelloAsync(message).Result;
// var channel = new Channel("127.0.0.1", 3002, ChannelCredentials.Insecure);
// channel.ConnectAsync().Wait();
// AtlantisServiceClient client=new AtlantisServiceClient(channel);
//
// var result= client.Hello(message);
// // var serailizer=new ProtobufBinarySerializer();
// // var s=serailizer.Serialize(message);
// // foreach(var b in s)
// // {
// // Console.Write($" {b}");
// }
Console.WriteLine(result.Result);
}
private void RegisterService()
{
try
{
Console.WriteLine("Register Service");
var options = new ConsulOptions
{
Host = ConfigurationManager.AppSettings["consulHost"],
Port = Convert.ToInt32(ConfigurationManager.AppSettings["consulPort"])
};
var loggerFactory = new LoggerFactory();
var logger = loggerFactory.CreateLogger("logger");
var provider = new ConsulProvider(loggerFactory, Options.Create(options));
Console.WriteLine($"Connecting to consul server at: {options.Host}:{options.Port}");
Cluster.RegisterService(new Uri(_baseAddress), provider, "orders", "v1", logger, new string[] { "v1" });
AddConfiguration();
Console.WriteLine("Success!");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
/// <summary>
/// Initialize new instance of class
/// </summary>
/// <param name="consulClient"><Consul client</param>
/// <param name="opts"></param>
/// <param name="logger">Logger</param>
public ConsulRegistrator(IConsulClient consulClient, IOptions <ConsulOptions> opts, ILogger <IConsulRegistrator> logger)
{
_consulClient = consulClient ?? throw new ArgumentNullException(nameof(consulClient));
_opts = opts.Value ?? throw new ArgumentNullException(nameof(opts));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
private static ConsulHealthCheck CreateHealthCheck(IServiceProvider sp, ConsulOptions options, string name)
{
var httpClientFactory = sp.GetRequiredService <IHttpClientFactory>();
return(new ConsulHealthCheck(options, () => httpClientFactory.CreateClient(name)));
}
public static IConveyBuilder AddFabio(this IConveyBuilder builder, FabioOptions fabioOptions,
ConsulOptions consulOptions, HttpClientOptions httpClientOptions)
=> builder.AddFabio(fabioOptions, httpClientOptions, b => b.AddConsul(consulOptions, httpClientOptions));
public static IServiceCollection AddFabio(this IServiceCollection services, FabioOptions fabioOptions,
ConsulOptions consulOptions, HttpClientOptions httpClientOptions)
=> services.AddFabio(fabioOptions, httpClientOptions, b => b.AddConsul(consulOptions, httpClientOptions));
public static IDrexBuilder AddFabio(this IDrexBuilder builder, FabioOptions fabioOptions,
ConsulOptions consulOptions, HttpClientOptions httpClientOptions)
{
return(builder.AddFabio(fabioOptions, httpClientOptions,
b => b.AddConsul(consulOptions, httpClientOptions)));
}
private static ServiceRegistration CreateConsulAgentRegistration(this IConveyBuilder builder,
ConsulOptions options)
{
var enabled = options.Enabled;
var consulEnabled = Environment.GetEnvironmentVariable("CONSUL_ENABLED")?.ToLowerInvariant();
if (!string.IsNullOrWhiteSpace(consulEnabled))
{
enabled = consulEnabled is "true" or "1";
}
if (!enabled)
{
return(null);
}
if (string.IsNullOrWhiteSpace(options.Address))
{
throw new ArgumentException("Consul address can not be empty.",
nameof(options.PingEndpoint));
}
builder.Services.AddHttpClient <IConsulService, ConsulService>(c => c.BaseAddress = new Uri(options.Url));
if (builder.Services.All(x => x.ServiceType != typeof(ConsulHostedService)))
{
builder.Services.AddHostedService <ConsulHostedService>();
}
string serviceId;
using (var serviceProvider = builder.Services.BuildServiceProvider())
{
serviceId = serviceProvider.GetRequiredService <IServiceId>().Id;
}
var registration = new ServiceRegistration
{
Name = options.Service,
Id = $"{options.Service}:{serviceId}",
Address = options.Address,
Port = options.Port,
Tags = options.Tags,
Meta = options.Meta,
EnableTagOverride = options.EnableTagOverride,
Connect = options.Connect?.Enabled == true ? new Connect() : null
};
if (!options.PingEnabled)
{
return(registration);
}
var pingEndpoint = string.IsNullOrWhiteSpace(options.PingEndpoint) ? string.Empty :
options.PingEndpoint.StartsWith("/") ? options.PingEndpoint : $"/{options.PingEndpoint}";
if (pingEndpoint.EndsWith("/"))
{
pingEndpoint = pingEndpoint.Substring(0, pingEndpoint.Length - 1);
}
var scheme = options.Address.StartsWith("http", StringComparison.InvariantCultureIgnoreCase)
? string.Empty
: "http://";
var check = new ServiceCheck
{
Interval = ParseTime(options.PingInterval),
DeregisterCriticalServiceAfter = ParseTime(options.RemoveAfterInterval),
Http = $"{scheme}{options.Address}{(options.Port > 0 ? $":{options.Port}" : string.Empty)}" +
$"{pingEndpoint}"
};
registration.Checks = new[] { check };
return(registration);
}
public static IServiceCollection AddRestEaseClient <T>(this IServiceCollection builder, string serviceName,
RestEaseOptions options, ConsulOptions consulOptions, FabioOptions fabioOptions,
HttpClientOptions httpClientOptions)
where T : class
=> builder.AddRestEaseClient <T>(serviceName, options,
b => b.AddFabio(fabioOptions, consulOptions, httpClientOptions));
