public override async Task VerifyQuality(
VerificationRequest request,
IServerStreamWriter <VerificationResponse> responseStream,
ServerCallContext context)
{
try
{
await StartRequest(request);
Func <ITrackCancel, ServiceCallStatus> func =
trackCancel => VerifyQualityCore(request, responseStream, trackCancel);
ServiceCallStatus result =
await GrpcServerUtils.ExecuteServiceCall(
func, context, _staThreadScheduler);
_msg.InfoFormat("Verification {0}", result);
}
catch (Exception e)
{
_msg.Error($"Error verifying quality for request {request}", e);
SendFatalException(e, responseStream);
SetUnhealthy();
}
finally
{
EndRequest();
}
}
public override async Task VerifyQuality(
VerificationRequest request,
IServerStreamWriter <VerificationResponse> responseStream,
ServerCallContext context)
{
try
{
_msg.InfoFormat("Starting verification request from {0}", request.UserName);
_msg.DebugFormat("Request details: {0}", request);
if (Checkout3DAnalyst)
{
// It must be re-checked out (but somehow it's enough to do it
// on the calling thread-pool thread!?)
Ensure3dAnalyst();
}
Func <ITrackCancel, ServiceCallStatus> func =
trackCancel => VerifyQualityCore(request, responseStream, trackCancel);
ServiceCallStatus result =
await GrpcServerUtils.ExecuteServiceCall(
func, context, _singleStaThreadScheduler);
_msg.InfoFormat("Verification {0}", result);
}
catch (Exception e)
{
_msg.Error($"Error verifying quality for request {request}", e);
SendFatalException(e, responseStream);
SetUnhealthy();
}
}
public override async Task VerifyStandaloneXml(
StandaloneVerificationRequest request,
IServerStreamWriter <StandaloneVerificationResponse> responseStream,
ServerCallContext context)
{
try
{
_msg.InfoFormat("Starting stand-alone verification request from {0}",
context.Peer);
_msg.DebugFormat("Request details: {0}", request);
Action <LoggingEvent> action =
SendInfoLogAction(responseStream, ServiceCallStatus.Running);
using (MessagingUtils.TemporaryRootAppender(new ActionAppender(action)))
{
Func <ITrackCancel, ServiceCallStatus> func =
trackCancel => VerifyStandaloneXmlCore(request, responseStream,
trackCancel);
ServiceCallStatus result =
await GrpcServerUtils.ExecuteServiceCall(
func, context, _singleStaThreadScheduler);
_msg.InfoFormat("Verification {0}", result);
}
}
catch (Exception e)
{
_msg.Error($"Error verifying quality for request {request}", e);
SendFatalException(e, responseStream);
SetUnhealthy();
}
}
private static Grpc.Core.Server StartServer([NotNull] MicroserverArguments arguments,
out IServiceHealth health)
{
// TODO: Move to ProSuite
var healthService = new HealthServiceImpl();
health = null; // new ServiceHealth(healthService);
int maxThreadCount = arguments.MaxParallel;
if (maxThreadCount <= 0)
{
maxThreadCount = Environment.ProcessorCount - 1;
}
var taskScheduler = new StaTaskScheduler(maxThreadCount);
var removeOverlapsServiceImpl = new RemoveOverlapsGrpcImpl(taskScheduler)
{
//Health = health
};
var advancedReshapeServiceImpl = new AdvancedReshapeGrpcImpl(taskScheduler);
var changeAlongServiceImpl = new ChangeAlongGrpcImpl(taskScheduler);
//health.SetStatus(removeOverlapsServiceImpl.GetType(), true);
ServerCredentials serverCredentials =
GrpcServerUtils.GetServerCredentials(arguments.Certificate,
arguments.PrivateKeyFile);
var oneGb = (int)Math.Pow(1024, 3);
IList <ChannelOption> channelOptions = GrpcServerUtils.CreateChannelOptions(oneGb);
var server =
new Grpc.Core.Server(channelOptions)
{
Services =
{
RemoveOverlapsGrpc.BindService(removeOverlapsServiceImpl),
ReshapeGrpc.BindService(advancedReshapeServiceImpl),
ChangeAlongGrpc.BindService(changeAlongServiceImpl)
//Health.BindService(healthService)
},
Ports =
{
new ServerPort(arguments.HostName, arguments.Port, serverCredentials)
}
};
server.Start();
_msg.InfoFormat("Service is listening on host {0}, port {1}.", arguments.HostName,
arguments.Port);
return(server);
}
private Server StartLoadBalancerService([NotNull] ServiceRegistry serviceRegistry,
[NotNull] LoadBalancerConfig loadBalancerConfig)
{
ServerCredentials serverCredentials =
GrpcServerUtils.GetServerCredentials(loadBalancerConfig.Certificate,
loadBalancerConfig.PrivateKeyFile,
loadBalancerConfig.EnforceMutualTls);
var serviceDiscoveryGrpcImpl = new ServiceDiscoveryGrpcImpl(serviceRegistry)
{
RemoveUnhealthyServices = !_keyValueStoreIsLocal,
WorkerResponseTimeoutSeconds = loadBalancerConfig.ServiceResponseTimeoutSeconds,
RecentlyUsedServiceTimeoutSeconds = loadBalancerConfig.RecentlyUsedTimeoutSeconds
};
var health = new HealthServiceImpl();
serviceDiscoveryGrpcImpl.Health = health;
// General status:
health.SetStatus(string.Empty, HealthCheckResponse.Types.ServingStatus.Serving);
// Specifically the LB service:
health.SetStatus(serviceDiscoveryGrpcImpl.ServiceName,
HealthCheckResponse.Types.ServingStatus.Serving);
_logger.LogInformation("Starting load-balancer service at {host}:{port}",
loadBalancerConfig.HostName, loadBalancerConfig.Port);
var server =
new Server
{
Services =
{
ServiceDiscoveryGrpc.BindService(serviceDiscoveryGrpcImpl),
Health.BindService(health)
},
Ports =
{
new ServerPort(loadBalancerConfig.HostName, loadBalancerConfig.Port,
serverCredentials)
}
};
server.Start();
string protocol = serverCredentials == ServerCredentials.Insecure
? "http"
: "https";
_logger.LogInformation(
"Load balancer service is serving at {protocol}://{host}:{port}",
protocol, loadBalancerConfig.HostName, loadBalancerConfig.Port);
return(server);
}
public override async Task VerifyDataQuality(
IAsyncStreamReader <DataVerificationRequest> requestStream,
IServerStreamWriter <DataVerificationResponse> responseStream,
ServerCallContext context)
{
VerificationRequest request = null;
try
{
Assert.True(await requestStream.MoveNext(), "No request");
//while (await requestStream.MoveNext())
DataVerificationRequest initialrequest =
Assert.NotNull(requestStream.Current, "No request");
request = initialrequest.Request;
_msg.InfoFormat("Starting verification request from {0}", request);
_msg.DebugFormat("Request details: {0}", request);
if (Checkout3DAnalyst)
{
// It must be re-checked out (but somehow it's enough to do it
// on the calling thread-pool thread!?)
Ensure3dAnalyst();
}
Func <DataVerificationResponse, DataVerificationRequest> moreDataRequest =
delegate(DataVerificationResponse r)
{
return(Task.Run(async() =>
await RequestMoreDataAsync(
requestStream, responseStream, context, r)
.ConfigureAwait(false))
.Result);
};
Func <ITrackCancel, ServiceCallStatus> func =
trackCancel =>
VerifyDataQualityCore(initialrequest, moreDataRequest, responseStream,
trackCancel);
ServiceCallStatus result =
await GrpcServerUtils.ExecuteServiceCall(
func, context, _singleStaThreadScheduler);
_msg.InfoFormat("Verification {0}", result);
}
catch (Exception e)
{
_msg.Error($"Error verifying quality for request {request}", e);
SendFatalException(e, responseStream);
SetUnhealthy();
}
}
public override async Task StopAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Stopping Service");
if (_server != null)
{
GrpcServerUtils.GracefullyStop(_server);
}
await base.StopAsync(cancellationToken);
}
public override async Task VerifyDataQuality(
IAsyncStreamReader <DataVerificationRequest> requestStream,
IServerStreamWriter <DataVerificationResponse> responseStream,
ServerCallContext context)
{
VerificationRequest request = null;
try
{
Assert.True(await requestStream.MoveNext(), "No request");
DataVerificationRequest initialRequest =
Assert.NotNull(requestStream.Current, "No request");
request = initialRequest.Request;
await StartRequest(request);
Func <DataVerificationResponse, DataVerificationRequest> moreDataRequest =
delegate(DataVerificationResponse r)
{
return(Task.Run(async() =>
await RequestMoreDataAsync(
requestStream, responseStream, context, r)
.ConfigureAwait(false))
.Result);
};
Func <ITrackCancel, ServiceCallStatus> func =
trackCancel =>
VerifyDataQualityCore(initialRequest, moreDataRequest, responseStream,
trackCancel);
ServiceCallStatus result =
await GrpcServerUtils.ExecuteServiceCall(
func, context, _staThreadScheduler);
_msg.InfoFormat("Verification {0}", result);
}
catch (Exception e)
{
_msg.Error($"Error verifying quality for request {request}", e);
SendFatalException(e, responseStream);
SetUnhealthy();
}
finally
{
EndRequest();
}
}
public override async Task <ShapeMsg> GetOpenJawReshapeLineReplaceEndPoint(
OpenJawReshapeLineReplacementRequest request,
ServerCallContext context)
{
Func <ITrackCancel, ShapeMsg> func =
trackCancel => AdvancedReshapeServiceUtils.GetOpenJawReshapeReplaceEndPoint(
request, trackCancel);
ShapeMsg response =
await GrpcServerUtils.ExecuteServiceCall(func, context, _staTaskScheduler, true) ??
new ShapeMsg();
return(response);
}
public override async Task <AdvancedReshapeResponse> AdvancedReshape(
AdvancedReshapeRequest request, ServerCallContext context)
{
Stopwatch watch = _msg.DebugStartTiming();
Func <ITrackCancel, AdvancedReshapeResponse> func =
trackCancel => AdvancedReshapeServiceUtils.Reshape(request);
AdvancedReshapeResponse response =
await GrpcServerUtils.ExecuteServiceCall(func, context, _staTaskScheduler, true) ??
new AdvancedReshapeResponse();
_msg.DebugStopTiming(watch, "Reshaped for peer {0} ({1} source features)",
context.Peer, request.Features.Count);
return(response);
}
static void Main(string[] args)
{
try
{
IServiceHealth health;
Grpc.Core.Server server = Run(args, out health);
_msg.Info("Type Q(uit) to stop the server.");
while (true)
{
// Avoid mindless spinning
Thread.Sleep(100);
if (System.Console.KeyAvailable)
{
if (System.Console.ReadKey(true).Key == ConsoleKey.Q)
{
_msg.Warn("Shutting down due to user input");
break;
}
}
// TODO: Uncomment after next pull
//if (health.IsAnyServiceUnhealthy())
//{
// _msg.Warn("Shutting down due to service state NOT_SERVING");
// break;
//}
}
if (server != null)
{
GrpcServerUtils.GracefullyStop(server);
}
}
catch (Exception ex)
{
_msg.Error("An error occurred in microservice.", ex);
Environment.ExitCode = -1;
}
finally
{
_msg.Debug("License released, shutting down...");
}
}
public override async Task <RemoveOverlapsResponse> RemoveOverlaps(
RemoveOverlapsRequest request, ServerCallContext context)
{
Stopwatch watch = _msg.DebugStartTiming();
Func <ITrackCancel, RemoveOverlapsResponse> func =
trackCancel => RemoveOverlapsServiceUtils.RemoveOverlaps(request, trackCancel);
RemoveOverlapsResponse response =
await GrpcServerUtils.ExecuteServiceCall(func, context, _staTaskScheduler, true) ??
new RemoveOverlapsResponse();
_msg.DebugStopTiming(watch, "Removed overlaps for peer {0} ({1} source features)",
context.Peer, request.SourceFeatures.Count);
return(response);
}
public override async Task <CalculateReshapeLinesResponse> CalculateReshapeLines(
[NotNull] CalculateReshapeLinesRequest request,
[NotNull] ServerCallContext context)
{
Stopwatch watch = _msg.DebugStartTiming();
Func <ITrackCancel, CalculateReshapeLinesResponse> func =
trackCancel =>
ChangeAlongServiceUtils.CalculateReshapeLines(request, trackCancel);
CalculateReshapeLinesResponse response =
await GrpcServerUtils.ExecuteServiceCall(func, context, _staTaskScheduler, true) ??
new CalculateReshapeLinesResponse();
_msg.DebugStopTiming(
watch,
"Calculated reshape lines for peer {0} ({1} source features, {2}, target features)",
context.Peer, request.SourceFeatures.Count, request.TargetFeatures.Count);
return(response);
}
