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