/// <inheritdoc/>
public void SetStatus(IConsulRegistration registration, string status)
{
Task.Run(async() =>
{
await SetStatusAsync(registration, status);
}).Wait();
}
public static IConsulRegistration AddHttpHealthCheckEndpoint(this IConsulRegistration registration, int healthCheckPort)
{
var responseBody = Encoding.UTF8.GetBytes("OK");
var address = $"http://*:{healthCheckPort}/";
var listener = new HttpListener
{
Prefixes = { address }
};
listener.Start();
Task.Run(() =>
{
while (true)
{
var context = listener.GetContext();
var response = context.Response;
response.OutputStream.Write(responseBody, 0, responseBody.Length);
response.OutputStream.Close();
}
});
return(registration);
}
/// <inheritdoc/>
public async Task RegisterAsync(IConsulRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
_logger?.LogInformation("Registering service with consul {serviceId} ", registration.ServiceId);
try
{
await _client.Agent.ServiceRegister(registration.Service);
if (Options.IsHeartBeatEnabled && _scheduler != null)
{
_scheduler.Add(registration.InstanceId);
}
}
catch (Exception e)
{
if (Options.FailFast)
{
_logger?.LogError(e, "Error registering service with consul {serviceId} ", registration.ServiceId);
throw;
}
_logger?.LogWarning(e, "Failfast is false. Error registering service with consul {serviceId} ", registration.ServiceId);
}
}
/// <inheritdoc/>
public void Deregister(IConsulRegistration registration)
{
Task.Run(async() =>
{
await DeregisterAsync(registration);
}).Wait();
}
/// <inheritdoc/>
public S GetStatus <S>(IConsulRegistration registration)
where S : class
{
var result = GetStatusAsync(registration).GetAwaiter().GetResult();
return((S)result);
}
/// <inheritdoc/>
public Task <object> GetStatusAsync(IConsulRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
return(GetStatusAsyncInternal(registration));
}
/// <inheritdoc/>
public Task RegisterAsync(IConsulRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
return(RegisterAsyncInternal(registration));
}
/// <inheritdoc/>
public Task SetStatusAsync(IConsulRegistration registration, string status)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
return(SetStatusAsyncInternal(registration, status));
}
public ThisServiceInstance(IConsulRegistration registration)
{
ServiceId = registration.Service.Name;
Host = registration.Service.Address;
IsSecure = registration.IsSecure;
Port = registration.Port;
Metadata = registration.Metadata;
Uri = registration.Uri;
}
/// <inheritdoc/>
public S GetStatus <S>(IConsulRegistration registration)
where S : class
{
var result = Task.Run(async() =>
{
return(await GetStatusAsync(registration));
}).Result;
return((S)result);
}
private async Task DeregisterAsyncInternal(IConsulRegistration registration)
{
if (Options.IsHeartBeatEnabled && _scheduler != null)
{
_scheduler.Remove(registration.InstanceId);
}
_logger?.LogInformation("Deregistering service with consul {instanceId} ", registration.InstanceId);
await _client.Agent.ServiceDeregister(registration.InstanceId).ConfigureAwait(false);
}
private Task SetStatusAsyncInternal(IConsulRegistration registration, string status)
{
if (OUT_OF_SERVICE.Equals(status, StringComparison.OrdinalIgnoreCase))
{
return(_client.Agent.EnableServiceMaintenance(registration.InstanceId, OUT_OF_SERVICE));
}
if (UP.Equals(status, StringComparison.OrdinalIgnoreCase))
{
return(_client.Agent.DisableServiceMaintenance(registration.InstanceId));
}
throw new ArgumentException($"Unknown status: {status}");
}
private async Task SetStatusAsyncInternal(IConsulRegistration registration, string status)
{
if (OUT_OF_SERVICE.Equals(status, StringComparison.OrdinalIgnoreCase))
{
await _client.Agent.EnableServiceMaintenance(registration.InstanceId, OUT_OF_SERVICE).ConfigureAwait(false);
}
else if (UP.Equals(status, StringComparison.OrdinalIgnoreCase))
{
await _client.Agent.DisableServiceMaintenance(registration.InstanceId).ConfigureAwait(false);
}
else
{
throw new ArgumentException($"Unknown status: {status}");
}
}
public static IConsulRegistration AddTTLCheck(this IConsulRegistration registration, TimeSpan ttl, TimeSpan interval, TimeSpan deregisterFailedAfter)
{
var ttlCheck = new AgentCheckRegistration
{
DockerContainerID = Environment.MachineName,
DeregisterCriticalServiceAfter = deregisterFailedAfter,
Interval = interval,
TTL = ttl,
Name = $"TTL check"
};
registration.AddHealthCheck(ttlCheck);
return(registration);
}
/// <inheritdoc/>
public async Task DeregisterAsync(IConsulRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
if (Options.IsHeartBeatEnabled && _scheduler != null)
{
_scheduler.Remove(registration.InstanceId);
}
_logger?.LogInformation("Deregistering service with consul {instanceId} ", registration.InstanceId);
await _client.Agent.ServiceDeregister(registration.InstanceId);
}
public static IConsulRegistration AddHttpCheck(this IConsulRegistration registration, int port, string relativePath, TimeSpan interval, TimeSpan deregisterFailedAfter)
{
var url = $"{registration.Address}:{port}{relativePath}";
var httpCheck = new AgentCheckRegistration
{
DockerContainerID = Environment.MachineName,
DeregisterCriticalServiceAfter = deregisterFailedAfter,
Interval = interval,
HTTP = url,
Name = $"HTTP GET {url} check"
};
registration.AddHealthCheck(httpCheck);
return(registration);
}
public async Task <object> GetStatusAsyncInternal(IConsulRegistration registration)
{
var response = await _client.Health.Checks(registration.ServiceId, QueryOptions.Default).ConfigureAwait(false);
var checks = response.Response;
foreach (HealthCheck check in checks)
{
if (check.ServiceID.Equals(registration.InstanceId) && check.Name.Equals("Service Maintenance Mode", StringComparison.OrdinalIgnoreCase))
{
return(OUT_OF_SERVICE);
}
}
return(UP);
}
/// <inheritdoc/>
public async Task SetStatusAsync(IConsulRegistration registration, string status)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
if (OUT_OF_SERVICE.Equals(status, StringComparison.OrdinalIgnoreCase))
{
await _client.Agent.EnableServiceMaintenance(registration.InstanceId, OUT_OF_SERVICE);
}
else if (UP.Equals(status, StringComparison.OrdinalIgnoreCase))
{
await _client.Agent.DisableServiceMaintenance(registration.InstanceId);
}
else
{
throw new ArgumentException($"Unknown status: {status}");
}
}
/// <inheritdoc/>
public async Task <object> GetStatusAsync(IConsulRegistration registration)
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
var response = await _client.Health.Checks(registration.ServiceId, QueryOptions.Default);
var checks = response.Response;
foreach (HealthCheck check in checks)
{
if (check.ServiceID.Equals(registration.InstanceId))
{
if (check.Name.Equals("Service Maintenance Mode", StringComparison.OrdinalIgnoreCase))
{
return(OUT_OF_SERVICE);
}
}
}
return(UP);
}
private async Task RegisterAsyncInternal(IConsulRegistration registration)
{
_logger?.LogInformation("Registering service with consul {serviceId} ", registration.ServiceId);
try
{
await _client.Agent.ServiceRegister(registration.Service).ConfigureAwait(false);
if (Options.IsHeartBeatEnabled && _scheduler != null)
{
_scheduler.Add(registration.InstanceId);
}
}
catch (Exception e)
{
if (Options.FailFast)
{
_logger?.LogError(e, "Error registering service with consul {serviceId} ", registration.ServiceId);
throw;
}
_logger?.LogWarning(e, "Failfast is false. Error registering service with consul {serviceId} ", registration.ServiceId);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsulServiceRegistrar"/> class.
/// </summary>
/// <param name="registry">the Consul service registry to use when doing registrations</param>
/// <param name="options">configuration options to use</param>
/// <param name="registration">the registration to register with Consul</param>
/// <param name="logger">optional logger</param>
public ConsulServiceRegistrar(IConsulServiceRegistry registry, ConsulDiscoveryOptions options, IConsulRegistration registration, ILogger <ConsulServiceRegistrar> logger = null)
{
_registry = registry ?? throw new ArgumentNullException(nameof(registry));
_options = options ?? throw new ArgumentNullException(nameof(options));
Registration = registration ?? throw new ArgumentNullException(nameof(registration));
_logger = logger;
}
public static IConsulRegistration AddHttpCheck(this IConsulRegistration registration, int port, TimeSpan interval, TimeSpan deregisterFailedAfter)
{
return(registration.AddHttpCheck(port, string.Empty, interval, deregisterFailedAfter));
}
/// <inheritdoc/>
public void SetStatus(IConsulRegistration registration, string status)
{
SetStatusAsync(registration, status).GetAwaiter().GetResult();
}
public static IConsulRegistration AddHttpCheck(this IConsulRegistration registration, string relativePath, TimeSpan interval, TimeSpan deregisterFailedAfter)
{
return(registration.AddHttpCheck(registration.Port, relativePath, interval, deregisterFailedAfter));
}
/// <inheritdoc/>
public void Deregister(IConsulRegistration registration)
{
DeregisterAsync(registration).GetAwaiter().GetResult();
}
