private static async Task <DataVerificationRequest> RequestMoreDataAsync(
IAsyncStreamReader <DataVerificationRequest> requestStream,
IServerStreamWriter <DataVerificationResponse> responseStream,
ServerCallContext context,
DataVerificationResponse r)
{
DataVerificationRequest resultData = null;
Task responseReaderTask = Task.Run(
async() =>
{
while (resultData == null)
{
while (await requestStream.MoveNext().ConfigureAwait(false))
{
resultData = requestStream.Current;
break;
}
}
});
await responseStream.WriteAsync(r).ConfigureAwait(false);
await responseReaderTask.ConfigureAwait(false);
return(resultData);
}
private static bool SatisfyDataRequest(
[NotNull] DataVerificationResponse arg,
[NotNull] IVerificationDataProvider verificationDataProvider,
[NotNull] IClientStreamWriter <DataVerificationRequest> callRequestStream)
{
DataVerificationRequest result = new DataVerificationRequest();
try
{
if (arg.SchemaRequest != null)
{
result.Schema = verificationDataProvider.GetGdbSchema(arg.SchemaRequest);
}
else if (arg.DataRequest != null)
{
result.Data = verificationDataProvider
.GetData(arg.DataRequest).FirstOrDefault();
}
callRequestStream.WriteAsync(result);
return(true);
}
catch (Exception e)
{
_msg.Debug("Error handling data request", e);
// Send an empty message to make sure the server does not wait forever:
callRequestStream.WriteAsync(result);
throw;
}
}
public void InitializeSchema(ICollection <Dataset> datasets)
{
if (_dataRequestFunc == null)
{
return;
}
if (_virtualWorkspaces != null)
{
return;
}
var dataRequest = new DataVerificationResponse
{
SchemaRequest = new SchemaRequest()
};
dataRequest.SchemaRequest.DatasetIds.AddRange(datasets.Select(d => d.Id));
DataVerificationRequest dataResponse = _dataRequestFunc(dataRequest);
SetGdbSchema(ProtobufConversionUtils.CreateSchema(
dataResponse.Schema.ClassDefinitions,
dataResponse.Schema.RelclassDefinitions, _dataRequestFunc));
}
private async Task <bool> ProvideDataToServer(
[NotNull] DataVerificationResponse serverResponseMsg,
[NotNull] IClientStreamWriter <DataVerificationRequest> dataStream,
[NotNull] CancellationTokenSource cancellationSource)
{
if (_msg.IsVerboseDebugEnabled)
{
_msg.DebugFormat("Sending verification data for {0}...", serverResponseMsg);
}
Assert.NotNull(VerificationDataProvider, "No verification data provider available.");
Func <bool> getDataFunc = () => SatisfyDataRequest(
serverResponseMsg, VerificationDataProvider, dataStream);
bool result =
await Task.Factory.StartNew(
() =>
TryExecute(getDataFunc, cancellationSource.Token,
"SatisfyDataRequest"),
cancellationSource.Token,
TaskCreationOptions.LongRunning, StaTaskScheduler);
if (result)
{
_msg.DebugFormat("Successfully provided verification data for to the server.");
}
return(result);
}
public override IRow GetRow(int id)
{
Assert.True(_schema.HasOID, "The table {0} has no OID", DatasetUtils.GetName(_schema));
Assert.False(string.IsNullOrEmpty(_schema.OIDFieldName),
"The table {0} has no OID Field Name", DatasetUtils.GetName(_schema));
DataVerificationResponse response =
new DataVerificationResponse
{
DataRequest = new DataRequest
{
WhereClause = $"{_schema.OIDFieldName} = {id}"
}
};
if (_queryDefinition != null)
{
response.DataRequest.RelQueryDef = _queryDefinition;
}
else
{
response.DataRequest.ClassDef = Assert.NotNull(_classDefinition);
}
DataVerificationRequest moreData = GetData(response);
foreach (GdbObjectMsg gdbObjMsg in moreData.Data.GdbObjects)
{
return(ProtobufConversionUtils.FromGdbObjectMsg(gdbObjMsg, _schema));
}
// or better: COMException?
return(null);
}
private ITable GetRemoteQueryTable([NotNull] string relationshipClassName,
[NotNull] Model model,
[NotNull] IList <ITable> tables,
JoinType joinType,
[CanBeNull] string whereClause)
{
var dataRequest = new DataVerificationResponse
{
SchemaRequest = new SchemaRequest()
};
RelationshipClassQuery relClassQueryMsg =
new RelationshipClassQuery
{
RelationshipClassName = relationshipClassName,
WorkspaceHandle = model.Id,
JoinType = (int)joinType,
};
relClassQueryMsg.Tables.AddRange(tables.Select(DatasetUtils.GetName));
if (!string.IsNullOrEmpty(whereClause))
{
relClassQueryMsg.WhereClause = whereClause;
}
dataRequest.SchemaRequest.RelationshipClassQueries.Add(relClassQueryMsg);
DataVerificationRequest dataResponse = _dataRequestFunc(dataRequest);
GdbWorkspace gdbWorkspace =
Assert.NotNull(_virtualWorkspaces).First(w => w.WorkspaceHandle == model.Id);
ObjectClassMsg queryTableMsg = dataResponse.Schema.RelclassDefinitions.First();
Func <ITable, BackingDataset> createBackingDataset = null;
if (_dataRequestFunc != null)
{
createBackingDataset = (t) =>
new RemoteDataset(t, _dataRequestFunc, null, relClassQueryMsg);
}
// It is cached on the client side, in case various tests utilize the same definition.
// TODO: Test!
return(ProtobufConversionUtils.FromObjectClassMsg(queryTableMsg, gdbWorkspace,
createBackingDataset));
}
public override int GetRowCount(IQueryFilter filter)
{
DataRequest dataRequest = CreateDataRequest(filter);
dataRequest.CountOnly = true;
DataVerificationResponse response =
new DataVerificationResponse
{
DataRequest = dataRequest
};
DataVerificationRequest moreData = GetData(response);
if (moreData == null)
{
throw new IOException(
$"No data provided by the client for data request {response.DataRequest}");
}
return(moreData.Data.GdbObjectCount);
}
public override IEnumerable <IRow> Search(IQueryFilter filter, bool recycling)
{
DataRequest dataRequest = CreateDataRequest(filter);
DataVerificationResponse response =
new DataVerificationResponse
{
DataRequest = dataRequest
};
DataVerificationRequest moreData = GetData(response);
if (moreData == null)
{
throw new IOException(
$"No data provided by the client for data request {response.DataRequest}");
}
foreach (GdbObjectMsg gdbObjMsg in moreData.Data.GdbObjects)
{
yield return(ProtobufConversionUtils.FromGdbObjectMsg(gdbObjMsg, _schema));
}
}
