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();
}
}
private static Action <LoggingEvent> SendInfoLogAction(
[NotNull] IServerStreamWriter <StandaloneVerificationResponse> responseStream,
ServiceCallStatus callStatus)
{
Action <LoggingEvent> action =
e =>
{
if (e.Level.Value < Level.Info.Value)
{
return;
}
var response = new StandaloneVerificationResponse
{
Message = new LogMsg
{
Message = e.RenderedMessage,
MessageLevel = e.Level.Value
},
ServiceCallStatus = (int)callStatus
};
MessagingUtils.TrySendResponse(responseStream, response);
};
return(action);
}
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 ServiceCallStatus SendFinalResponse(
[CanBeNull] QualityVerification verification,
[CanBeNull] string qaServiceCancellationMessage,
ConcurrentBag <IssueMsg> issues,
List <GdbObjRefMsg> deletableAllowedErrors,
[CanBeNull] IEnvelope verifiedPerimeter,
Action <VerificationResponse> writeAction)
{
var response = new VerificationResponse();
while (issues.TryTake(out IssueMsg issue))
{
response.Issues.Add(issue);
}
response.ObsoleteExceptions.AddRange(deletableAllowedErrors);
ServiceCallStatus finalStatus =
GetFinalCallStatus(verification, qaServiceCancellationMessage);
response.ServiceCallStatus = (int)finalStatus;
if (!string.IsNullOrEmpty(qaServiceCancellationMessage))
{
response.Progress = new VerificationProgressMsg
{
Message = qaServiceCancellationMessage
};
}
PackVerification(verification, response);
if (verifiedPerimeter != null)
{
response.VerifiedPerimeter =
ProtobufGeometryUtils.ToShapeMsg(verifiedPerimeter);
}
_msg.DebugFormat(
"Sending final message with {0} errors back to client...",
issues.Count);
try
{
writeAction(response);
}
catch (InvalidOperationException ex)
{
// For example: System.InvalidOperationException: Only one write can be pending at a time
_msg.Warn(
"Error sending progress to the client. Retrying the last response in 1s...",
ex);
// Re-try (only for final message)
Task.Delay(1000);
writeAction(response);
}
return(finalStatus);
}
private ServiceCallStatus VerifyQualityCore(
VerificationRequest request,
IServerStreamWriter <VerificationResponse> responseStream,
ITrackCancel trackCancel)
{
SetupUserNameProvider(request);
void SendResponse(VerificationResponse r) => responseStream.WriteAsync(r);
BackgroundVerificationService qaService = null;
List <GdbObjRefMsg> deletableAllowedErrorRefs = new List <GdbObjRefMsg>();
QualityVerification verification = null;
var issueCollection = new ConcurrentBag <IssueMsg>();
string cancellationMessage = null;
try
{
// TODO: Separate long-lived objects, such as datasetLookup, domainTransactions (add to this class) from
// short-term objects (request) -> add to background verification inputs
IBackgroundVerificationInputs backgroundVerificationInputs =
_verificationInputsFactoryMethod(request);
qaService = CreateVerificationService(backgroundVerificationInputs, issueCollection,
SendResponse, trackCancel);
int maxParallelRequested = request.MaxParallelProcessing;
if (backgroundVerificationInputs.WorkerClient != null &&
maxParallelRequested > 1)
{
// allow directly adding issues found by client processes:
qaService.DistributedTestRunner = new DistributedTestRunner(
backgroundVerificationInputs.WorkerClient, request, issueCollection);
}
verification = qaService.Verify(backgroundVerificationInputs, trackCancel);
deletableAllowedErrorRefs.AddRange(
GetDeletableAllowedErrorRefs(request.Parameters, qaService));
}
catch (Exception e)
{
_msg.Error($"Error checking quality for request {request}", e);
cancellationMessage = $"Server error: {e.Message}";
if (!EnvironmentUtils.GetBooleanEnvironmentVariableValue(
"PROSUITE_QA_SERVER_KEEP_SERVING_ON_ERROR"))
{
SetUnhealthy();
}
}
ServiceCallStatus result = SendFinalResponse(
verification, cancellationMessage ?? qaService.CancellationMessage, issueCollection,
deletableAllowedErrorRefs, qaService?.VerifiedPerimeter, SendResponse);
return(result);
}
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();
}
}
private void MediaService_GetMediaListCompleted(ServiceCallStatus status)
{
IList<Media> mediaList =
_mediaService.GetMediaList(status);
Write("GetMediaList Response:");
foreach (Media media in mediaList)
{
Write("Media: " + media.Id + ", " + media.Name + ", " + media.Type + ", " + media.Description);
}
}
private void MediaService_GetMediaListCompleted(ServiceCallStatus status)
{
IList <Media> mediaList =
_mediaService.GetMediaList(status);
Write("GetMediaList Response:");
foreach (Media media in mediaList)
{
Write("Media: " + media.Id + ", " + media.Name + ", " + media.Type + ", " + media.Description);
}
}
private void MediaService_CreateCompleted(ServiceCallStatus status)
{
try
{
_lastCreatedMedia = _mediaService.Create(status);
Write("Media created: " + _lastCreatedMedia.Name + " (" + _lastCreatedMedia.Id + ")");
_test4.IsEnabled = true;
}
catch (DuplicationException de)
{
Write("Attempt to create duplicate Media: " + de.DuplicateValue + " (" + de.DuplicateId + ")");
}
}
private void MediaService_CreateCompleted(ServiceCallStatus status)
{
try
{
_lastCreatedMedia = _mediaService.Create(status);
Write("Media created: " + _lastCreatedMedia.Name + " (" + _lastCreatedMedia.Id + ")");
_test4.IsEnabled = true;
}
catch (DuplicationException de)
{
Write("Attempt to create duplicate Media: " + de.DuplicateValue + " (" + de.DuplicateId + ")");
}
}
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();
}
}
private void MasterWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
ServiceCallStatus arg = e.UserState as ServiceCallStatus;
DataGridViewRow row = dataGridView1.Rows[arg.Row];
row.Cells[0].Value = arg.Status;
if (arg.Data is Exception)
{
addToTag(row, (arg.Data as Exception).Message);
}
else if (arg.Data is string)
{
addToTag(row, arg.Data as string);
}
}
private void InvokeServicesWorker_DoWork(object threadContext)
{
ServiceCallStatus call = threadContext as ServiceCallStatus;
SADIService service = call.Data as SADIService;
try
{
call.Status = "Assembling input";
MasterWorker.ReportProgress(1, call);
MemoryStore input = assembleInput(SelectedNodes, service);
call.Status = "Calling service";
call.Data = "Assembled input:\r\n" + SemWebHelper.storeToString(input);
MasterWorker.ReportProgress(33, call);
Store output = service.invokeService(input);
call.Status = "Storing output";
call.Data = "Received output:\r\n" + SemWebHelper.storeToString(output);
MasterWorker.ReportProgress(66, call);
ICollection <IStatement> statements = KE.Import(output);
showNewStatements(statements);
call.Status = "Done";
call.Data = service;
MasterWorker.ReportProgress(100, call);
}
catch (Exception err)
{
SADIHelper.error("ServiceCall", "error calling service", service, err);
call.Status = "Error";
call.Data = "Error:\r\n" + err.Message;
MasterWorker.ReportProgress(100, call);
}
finally
{
Interlocked.Decrement(ref NumWorkers);
}
}
private ServiceCallStatus VerifyDataQualityCore(
[NotNull] DataVerificationRequest initialRequest,
Func <DataVerificationResponse, DataVerificationRequest> moreDataRequest,
IServerStreamWriter <DataVerificationResponse> responseStream,
ITrackCancel trackCancel)
{
var request = initialRequest.Request;
SetupUserNameProvider(request);
void SendResponse(VerificationResponse r) => responseStream.WriteAsync(
new DataVerificationResponse {
Response = r
});
BackgroundVerificationService qaService = null;
List <GdbObjRefMsg> deletableAllowedErrorRefs = new List <GdbObjRefMsg>();
QualityVerification verification = null;
var issueCollection = new ConcurrentBag <IssueMsg>();
string cancellationMessage = null;
try
{
// TODO: Separate long-lived objects, such as datasetLookup, domainTransactions (add to this class) from
// short-term objects (request) -> add to background verification inputs
IBackgroundVerificationInputs backgroundVerificationInputs =
_verificationInputsFactoryMethod(request);
if (initialRequest.Schema != null)
{
backgroundVerificationInputs.SetGdbSchema(
ProtobufConversionUtils.CreateSchema(initialRequest.Schema.ClassDefinitions,
initialRequest
.Schema.RelclassDefinitions,
moreDataRequest));
}
else if (moreDataRequest != null)
{
backgroundVerificationInputs.SetRemoteDataAccess(moreDataRequest);
}
qaService = CreateVerificationService(backgroundVerificationInputs, issueCollection,
SendResponse, trackCancel);
verification = qaService.Verify(backgroundVerificationInputs, trackCancel);
deletableAllowedErrorRefs.AddRange(
GetDeletableAllowedErrorRefs(request.Parameters, qaService));
}
catch (Exception e)
{
_msg.Error($"Error checking quality for request {request}", e);
cancellationMessage = $"Server error: {e.Message}";
SetUnhealthy();
}
ServiceCallStatus result = SendFinalResponse(
verification, cancellationMessage ?? qaService.CancellationMessage, issueCollection,
deletableAllowedErrorRefs, qaService?.VerifiedPerimeter, SendResponse);
return(result);
}
private ServiceResult(ServiceCallStatus status, string message)
: this(status, new[] { message })
{
}
private void MediaService_ModifyCompleted(ServiceCallStatus status)
{
throw new NotImplementedException();
}
private void MediaService_ModifyCompleted(ServiceCallStatus status)
{
throw new NotImplementedException();
}
private ServiceResult(ServiceCallStatus status, IEnumerable <string> messages = null)
{
Status = status;
Messages = messages ?? Enumerable.Empty <string>();
}
internal ServiceResult(TValue value, ServiceCallStatus status, IEnumerable <string> messages = null)
{
Value = value;
Status = status;
Messages = messages ?? Enumerable.Empty <string>();
}
internal ServiceResult(TValue value, ServiceCallStatus status, string message)
: this(value, status, new[] { message })
{
}
