/// <summary>
/// Determines whether the specified endpoint is connected to the specified service
/// that responds with health status 'Serving' .
/// </summary>
/// <param name="healthClient"></param>
/// <param name="serviceName"></param>
/// <param name="statusCode">Status code from the RPC call</param>
/// <returns></returns>
public static bool IsServing([NotNull] Health.HealthClient healthClient,
[NotNull] string serviceName,
out StatusCode statusCode)
{
statusCode = StatusCode.Unknown;
try
{
HealthCheckResponse healthResponse =
healthClient.Check(new HealthCheckRequest()
{
Service = serviceName
});
statusCode = StatusCode.OK;
return(healthResponse.Status == HealthCheckResponse.Types.ServingStatus.Serving);
}
catch (RpcException rpcException)
{
_msg.Debug($"Error checking health of service {serviceName}", rpcException);
statusCode = rpcException.StatusCode;
}
catch (Exception e)
{
_msg.Debug($"Error checking health of service {serviceName}", e);
return(false);
}
return(false);
}
static void Main(string[] args)
{
var httpHandler = new HttpClientHandler();
// Return `true` to allow certificates that are untrusted/invalid
httpHandler.ServerCertificateCustomValidationCallback =
HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
var channel = GrpcChannel.ForAddress("https://localhost:50051",
new GrpcChannelOptions {
HttpHandler = httpHandler
});
// var client = new Greet.GreeterClient(channel);
//
//
// var channelTarget = $"{DefaultHost}:{Port}";
//
// var channel = new Channel(channelTarget, ChannelCredentials.Insecure);
Health.HealthClient cc = new Health.HealthClient(channel);
var c = cc.Check(new HealthCheckRequest());
Console.WriteLine(c.Status);
// Create a channel
// Hello.HelloClient client = new Hello.HelloClient(channel);
//
// for (int i = 0; i < 10; i++)
// {
// var reply = client.SayHello(new HelloRequest{Name = "Vincent"});
//
// Console.WriteLine(reply.Message);
// }
}
private async static Task HealthCheck(GrpcChannel channel)
{
var client = new Health.HealthClient(channel);
Console.WriteLine("Watching health status");
Console.WriteLine("Press any key to exit...");
var cts = new CancellationTokenSource();
using var call = client.Watch(new HealthCheckRequest { Service = "HealthCheck" }, cancellationToken: cts.Token);
var watchTask = Task.Run(async() =>
{
try
{
await foreach (var message in call.ResponseStream.ReadAllAsync())
{
Console.WriteLine($"{DateTime.Now}: Service is {message.Status}");
}
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Cancelled)
{
Console.WriteLine(ex.Status.Detail);
}
});
Console.ReadKey();
Console.WriteLine("Finished");
cts.Cancel();
await watchTask;
}
static async Task Main(string[] args)
{
AppContext.SetSwitch(
"System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
Channel channel = new Channel("healthchecker:5000",
ChannelCredentials.Insecure);
Health.HealthClient client = new Health.HealthClient(channel);
while (true)
{
try
{
var watch = System.Diagnostics.Stopwatch.StartNew();
HealthCheckResponse response = await client.CheckAsync(new HealthCheckRequest()
{
Service = "healthchecker"
});
watch.Stop();
Console.WriteLine("gRPC call to Healthchecker Server took " + watch.ElapsedMilliseconds + "ms");
response.Status.ToString();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + " " + ex.StackTrace);
}
System.Threading.Thread.Sleep(1000);
}
}
static async Task Main(string[] args)
{
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Health.HealthClient(channel);
Console.WriteLine("Watching health status");
Console.WriteLine("Press any key to exit...");
var cts = new CancellationTokenSource();
using var call = client.Watch(new HealthCheckRequest { Service = "" }, cancellationToken: cts.Token);
var watchTask = Task.Run(async() =>
{
try
{
await foreach (var message in call.ResponseStream.ReadAllAsync())
{
Console.WriteLine($"{DateTime.Now}: Service is {message.Status}");
}
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.Cancelled)
{
// Handle cancellation exception.
}
});
Console.ReadKey();
Console.WriteLine("Finished");
cts.Cancel();
await watchTask;
}
private static void Main(string[] args)
{
var channel = new Channel(ServerAddress, ChannelCredentials.Insecure);
var healthCheckClient = new Health.HealthClient(channel);
var healthCheckResponse = healthCheckClient.Check(new HealthCheckRequest {
Service = ServiceName
});
Console.WriteLine($"Service: '{ServiceName}' has a health status: {healthCheckResponse.Status.ToString()}");
try
{
healthCheckClient.Check(new HealthCheckRequest {
Service = "Bad Name"
});
}
catch (RpcException ex)
{
Console.WriteLine($"Service: 'Bad Name' has a health status: {ex.Status.StatusCode.ToString()}");
}
var bookClient = new BookService.BookServiceClient(channel);
var book = bookClient.GetBookById(new GetBookByIdRequest {
Id = 1
});
Console.WriteLine($"Retrieved book: {book.Name}");
channel.ShutdownAsync().GetAwaiter().GetResult();
Console.WriteLine("Press key to shut down ... .. .");
Console.ReadKey();
}
protected void OpenChannel(bool useTls,
string clientCertificate = null,
bool assumeLoadBalancer = false)
{
if (string.IsNullOrEmpty(HostName))
{
_msg.Debug("Host name is null or empty. No channel opened.");
return;
}
ChannelCredentials credentials =
GrpcUtils.CreateChannelCredentials(useTls, clientCertificate);
var enoughForLargeGeometries = (int)Math.Pow(1024, 3);
Channel channel = GrpcUtils.CreateChannel(
HostName, Port, credentials, enoughForLargeGeometries);
if (assumeLoadBalancer)
{
ChannelIsLoadBalancer =
IsServingLoadBalancerEndpoint(channel, credentials, ServiceName,
enoughForLargeGeometries);
}
Channel = channel;
_msg.DebugFormat("Created grpc channel to {0} on port {1}", HostName, Port);
_healthClient = new Health.HealthClient(Channel);
ChannelOpenedCore(Channel);
}
/// <summary>
/// Determines whether the specified endpoint is connected to the specified service
/// that responds with health status 'Serving' .
/// </summary>
/// <param name="healthClient"></param>
/// <param name="serviceName"></param>
/// <returns>StatusCode.OK if the service is healthy.</returns>
public static async Task <StatusCode> IsServingAsync(
[NotNull] Health.HealthClient healthClient,
[NotNull] string serviceName)
{
StatusCode statusCode = StatusCode.Unknown;
try
{
HealthCheckResponse healthResponse =
await healthClient.CheckAsync(new HealthCheckRequest()
{
Service = serviceName
});
statusCode =
healthResponse.Status == HealthCheckResponse.Types.ServingStatus.Serving
? StatusCode.OK
: StatusCode.ResourceExhausted;
}
catch (RpcException rpcException)
{
_msg.Debug($"Error checking health of service {serviceName}", rpcException);
statusCode = rpcException.StatusCode;
}
catch (Exception e)
{
_msg.Debug($"Error checking health of service {serviceName}", e);
return(statusCode);
}
return(statusCode);
}
static void Main(string[] args)
{
Console.WriteLine("Press any key to start the check.");
Console.ReadKey(true);
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Health.HealthClient(channel);
var req = new HealthCheckRequest
{
Service = "Liveness"
};
try
{
var res = client.Check(req);
Console.WriteLine(res.Status);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey(true);
}
public void HealthCheck()
{
var client = new Health.HealthClient(_channel);
var response = client.Check(new HealthCheckRequest
{
Service = ""
});
Console.WriteLine(response.Status);
}
private void DoCheck(object state)
{
using var channel = GrpcChannel.ForAddress("https://localhost:8001");;
var client = new Health.HealthClient(channel);
client.Check(new HealthCheckRequest()
{
Service = "https://localhost:8001"
});
}
public async Task <IActionResult> HealthOrdering([FromServices] Health.HealthClient healthClient, [FromServices] IOrderingServiceClient orderingServiceClient)
{
await Mediator.Send(new FindProductsQuery());
var a = await orderingServiceClient.SayHello(new HelloRequest());
//var result = await healthClient.CheckAsync(new HealthCheckRequest());
return(Ok(new { a }));
}
private void OpenChannel()
{
if (string.IsNullOrEmpty(HostName))
{
throw new ArgumentNullException(nameof(HostName));
}
Channel = GrpcUtils.CreateChannel(HostName, Port, _credentials);
_logger.LogDebug("Created grpc channel to {HostName} on port {Port}", HostName, Port);
_healthClient = new Health.HealthClient(Channel);
}
private static async Task Main()
{
using var channel = GrpcChannel.ForAddress("https://localhost:5005");
var healthClient = new Health.HealthClient(channel);
var health = await healthClient.CheckAsync(new HealthCheckRequest { Service = "Weather" });
Console.WriteLine($"Health Status: {health.Status}");
Console.WriteLine("Press a key to exit");
Console.ReadKey();
}
private static async Task Main(string[] args)
{
GrpcChannel channel = GrpcChannel.ForAddress("https://localhost:45679");
var httpsClientTicker = new Ticker.TickerClient(channel);
GrpcChannel authChannel = GrpcChannel.ForAddress("https://localhost:56790");
var httpsClient = new Auth.AuthClient(authChannel);
var interceptorHttps = channel.Intercept(new HeaderLoggerInterceptor());
var healthChecker = new Health.HealthClient(interceptorHttps);
string serviceName = "Ticker";
var result = await healthChecker.CheckAsync(new HealthCheckRequest { Service = serviceName });
Console.WriteLine(result?.Status);
/* var reply = await httpsClient.LogInAsync(new LogInRequest { Username = "******", Password = "******" });
* var replyUser = await httpsClient.LogInAsync(new LogInRequest { Username = "******", Password = "******" });
*
* var tokenAdmin =
* await Authenticate(reply.Role);
*
* var tokenUser = await Authenticate(replyUser.Role);
*
*
* Console.WriteLine(tokenAdmin);
* Console.WriteLine(tokenUser);
*
* await ClientStreaming(httpsClientTicker, 1, tokenUser);
*
*
*
* /*await UpdateTickHandling(httpsClient,
* new TickToAdd
* {
* InstrumentId = 1,
* Close = (DecimalValue)5.6234m,
* Open = (DecimalValue)5.6225m,
* High = (DecimalValue)5.6238m,
* Low = (DecimalValue)5.6224m,
* Symbol = 2
* });
* await GetTicksForQuota(httpsClient, 1);*/
//await ClientStreaming(httpsClient, 1);
Console.WriteLine("Press any key to close app...");
Console.ReadLine();
}
private static async Task Main(string[] args)
{
Channel channel = new Channel("localhost:5000", ChannelCredentials.Insecure);
var healthClient = new Health.HealthClient(channel);
var healthResponse = await healthClient.CheckAsync(new HealthCheckRequest());
Console.WriteLine($"Server is: {healthResponse.Status}");
healthResponse = await healthClient.CheckAsync(new HealthCheckRequest { Service = CustomerService.Descriptor.Name });
Console.WriteLine($"CustomerService is: {healthResponse.Status}");
var customerClient = new CustomerService.CustomerServiceClient(channel);
var customerResponse = await customerClient.GetCustomerByIdAsync(
new GetCustomerByIdRequest { Id = 1 },
new CallOptions(new Metadata {
{ "correlation-id", Guid.NewGuid().ToString() }
})).ResponseAsync.ConfigureAwait(false);
Console.WriteLine($"Customer: {customerResponse.Customer.Id} retrieved.");
customerResponse = await customerClient.GetCustomerById2Async(
new GetCustomerByIdRequest { Id = 1 },
new CallOptions(new Metadata {
{ "correlation-id", Guid.NewGuid().ToString() }
})).ResponseAsync.ConfigureAwait(false);
Console.WriteLine($"Customer: {customerResponse.Customer.Id} retrieved.");
var customerResponse2 = customerClient.DeleteCustomerById(new DeleteCustomerByIdRequest {
Id = 1
});
var customerResponse3 = customerClient.ListCustomers(new CustomerSearch {
FirstName = "test"
});
while (await customerResponse3.ResponseStream.MoveNext(CancellationToken.None))
{
var response = customerResponse3.ResponseStream.Current;
}
await channel.ShutdownAsync().ConfigureAwait(false);
Console.ReadKey();
}
private static bool IsServingLoadBalancerEndpoint(
[NotNull] Channel channel,
[NotNull] ChannelCredentials credentials,
string serviceName,
int enoughForLargeGeometries)
{
var channelHealth = new Health.HealthClient(channel);
bool isServingEndpoint = GrpcUtils.IsServing(channelHealth, serviceName, out _);
if (isServingEndpoint)
{
return(false);
}
bool isLoadBalancer = GrpcUtils.IsServing(channelHealth, nameof(ServiceDiscoveryGrpc),
out StatusCode lbStatusCode);
if (isLoadBalancer)
{
_msg.DebugFormat("{0} is a load balancer address.", channel.ResolvedTarget);
Channel suggestedLocation =
TryGetChannelFromLoadBalancer(channel, credentials, serviceName,
enoughForLargeGeometries);
if (suggestedLocation != null)
{
_msg.DebugFormat("Using serving load balancer at {0}", channel.ResolvedTarget);
return(true);
}
// Assumption: A load balancer is never also serving real requests -> lets not use it at all!
_msg.Debug(
"The load balancer has no service locations available. It will not be used.");
return(false);
}
_msg.DebugFormat("No {0} service and no serving load balancer at {1}. Error code: {2}",
serviceName, channel.ResolvedTarget, lbStatusCode);
return(false);
}
private bool TryGetHealthClient(out Health.HealthClient healthClient)
{
healthClient = null;
if (Port < 0)
{
// Avoid waiting for the timeout of the health check, if possible.
return(false);
}
if (_healthClient == null)
{
return(false);
}
healthClient = _healthClient;
return(true);
}
private async Task <bool> IsHealthy(ServiceLocation serviceLocation, Channel channel,
TimeSpan workerResponseTimeout)
{
Health.HealthClient healthClient = new Health.HealthClient(channel);
StatusCode healthStatus = await TaskUtils.TimeoutAfter(
GrpcUtils.IsServingAsync(healthClient, serviceLocation.ServiceName),
workerResponseTimeout);
if (healthStatus != StatusCode.OK)
{
_logger.LogDebug(
"Service location {serviceLocation} is unhealthy and will not be used.",
serviceLocation);
return(false);
}
return(true);
}
public async Task GrpcService_Exec_Test()
{
var locator = new GrpcLocator();
Console.WriteLine("Testing in {0}", locator.ServiceDomain);
GrpcService svc = await locator.Locate("alpha-users", ChannelCredentials.Insecure);
Assert.IsNotNull(svc);
HealthCheckResponse reply = await svc.Execute(async channel =>
{
var client = new Health.HealthClient(channel);
return(await client.CheckAsync(new HealthCheckRequest {
Service = "users"
}));
}, TimeSpan.FromSeconds(2));
Assert.AreEqual(HealthCheckResponse.Types.ServingStatus.Serving, reply.Status);
}
protected void OpenChannel(bool useTls, string clientCertificate = null)
{
if (string.IsNullOrEmpty(HostName))
{
_msg.Debug("Host name is null or empty. No channel opened.");
return;
}
var enoughForLargeGeometries = (int)Math.Pow(1024, 3);
ChannelCredentials credentials =
GrpcUtils.CreateChannelCredentials(useTls, clientCertificate);
Channel = GrpcUtils.CreateChannel(
HostName, Port, credentials, enoughForLargeGeometries);
_msg.DebugFormat("Created grpc channel to {0} on port {1}", HostName, Port);
_healthClient = new Health.HealthClient(Channel);
ChannelOpenedCore(Channel);
}
public async Task Run()
{
var host = config.GetValue("GRPC_HOST", "localhost");
var port = config.GetValue("GRPC_PORT", "50051");
this.Context.Logger.LogInformation($"connect to the server. {host}:{port}");
Channel channel = new Channel($"{host}:{port}", ChannelCredentials.Insecure);
this.Context.Logger.LogInformation($"* Begin Greet Check");
var greeter = new Greeter.GreeterClient(channel);
String user = "******";
var greet = greeter.SayHello(new HelloRequest {
Name = user
});
this.Context.Logger.LogInformation("Greeting: " + greet.Message);
this.Context.Logger.LogInformation($"* Begin Version Check");
var myversion = new MyVersionInfo.MyVersionInfoClient(channel);
var v = myversion.Get(new MyVersionInfoRequest
{
Message = "hoge",
});
this.Context.Logger.LogInformation(v.Version + $"({v.Guid})");
this.Context.Logger.LogInformation($"* Begin Health Check");
var health = new Health.HealthClient(channel);
var response = health.Check(new HealthCheckRequest
{
Service = "Check"
});
this.Context.Logger.LogInformation($"Health Checked: {response.Status}");
channel.ShutdownAsync().Wait();
}
static async Task RunAsync(string endpoint, string prefix)
{
// The port number(5001) must match the port of the gRPC server.
var handler = new SocketsHttpHandler();
if (endpoint.StartsWith("https://"))
{
handler.SslOptions = new SslClientAuthenticationOptions
{
RemoteCertificateValidationCallback = (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => true,
};
}
using var channel = GrpcChannel.ForAddress(endpoint, new GrpcChannelOptions
{
HttpHandler = handler,
});
// health
var healthClient = new Health.HealthClient(channel);
var health = await healthClient.CheckAsync(new HealthCheckRequest
{
Service = "",
});
Console.WriteLine($"Health Status: {health.Status}");
// unary
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(new HelloRequest { Name = $"{prefix} GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
// duplex
var requestHeaders = new Metadata
{
{ "x-host-port", "10-0-0-10" },
};
using var streaming = client.StreamingBothWays(requestHeaders);
var readTask = Task.Run(async() =>
{
await foreach (var response in streaming.ResponseStream.ReadAllAsync())
{
Console.WriteLine(response.Message);
}
});
var i = 0;
while (i++ < 100)
{
await streaming.RequestStream.WriteAsync(new HelloRequest
{
Name = $"{prefix} {i}",
});
await Task.Delay(TimeSpan.FromMilliseconds(10));
}
await streaming.RequestStream.CompleteAsync();
await readTask;
}
static HealthCheckServiceClient()
{
_channel = new Channel("127.0.0.1:23333", ChannelCredentials.Insecure);
_client = new Health.HealthClient(_channel);
}
