private IDriverDataEnumerator CreatePseudoEnumeratorForInsertValues(RequestExecutionContext context)
{
// generate a single logical entry and break
// actual values are computed as part of universal insert/update routine
return(new SourcedEnumerator(
DriverRowData.DeriveRepresentationType(context.ParsedRequest.TargetEntityPkField.DbType)));
}
public void CompressionCheck(RequestExecutionContext context)
{
if (context.Result is IList list)
{
context.CanCompress = list.Count > _min;
}
}
/// <inheritdoc />
public override Task HandleRequest(HttpContext context)
{
var requestContext = new RequestExecutionContext(context, this, Configuration.SuccessStatusCode)
{
Parameters = EmptyParameters.Instance
};
if (ActivationFunc == null)
{
SetupMethod();
}
try
{
requestContext.ServiceInstance = ActivationFunc(requestContext);
}
catch (Exception e)
{
return(Services.ErrorHandler.HandleException(requestContext, e));
}
var state = _startingState;
return(NextStep(ref state, ref requestContext));
}
public void BeforeExecute(RequestExecutionContext context)
{
Assert.Equal(3, context.Parameters.ParameterCount);
Assert.Equal(3, context.Parameters.ParameterInfos.Count);
var count = 0;
foreach (var rpcParameterInfo in context.Parameters.ParameterInfos)
{
if (context.Parameters.TryGetParameter(rpcParameterInfo.Name, out var value))
{
if (value is int intValue)
{
if (!context.Parameters.TrySetParameter(rpcParameterInfo.Name, intValue + 5))
{
throw new Exception("TrySetParameter returned false");
}
}
else
{
throw new Exception($"Value was not int rather some other type {value.GetType().FullName}");
}
count++;
}
else
{
throw new Exception($"Could not find parameter {rpcParameterInfo.Name} in parameters");
}
}
Assert.Equal(3, count);
}
/// <inheritdoc />
public override async ValueTask <T> DeserializeFromRequest <T>(RequestExecutionContext context)
{
var fileReader = new FileBufferingReadStream(context.HttpContext.Request.Body, _memoryThreshold);
context.HttpContext.Response.RegisterForDispose(fileReader);
try
{
await fileReader.DrainAsync(context.HttpContext.RequestAborted);
fileReader.Seek(0L, SeekOrigin.Begin);
using var textReader = new StreamReader(fileReader);
using var xmlReader = new XmlTextReader(textReader);
var serializer = GetSerializer(typeof(T));
return((T)serializer.Deserialize(xmlReader));
}
finally
{
await fileReader.DisposeAsync();
}
}
public async Task Execute(RequestExecutionContext context)
{
var validators = context.HttpContext.RequestServices.GetServices <IValidator <T> >();
var value = (T)context.Parameters[_position];
foreach (var validator in validators)
{
var validationContext = new ValidationContext <T>(value);
ValidationResult result;
if (ShouldValidateAsynchronously(validator, validationContext))
{
result = await validator.ValidateAsync(validationContext, context.HttpContext.RequestAborted);
}
else
{
result = validator.Validate(validationContext);
}
if (!result.IsValid)
{
SetErrorMessage(context, result);
}
}
}
public void BeforeExecute(RequestExecutionContext context)
{
Assert.Equal(3, context.Parameters.ParameterCount);
Assert.Equal(3, context.Parameters.ParameterInfos.Count);
var count = 0;
foreach (var rpcParameterInfo in context.Parameters.ParameterInfos)
{
var value = context.Parameters[rpcParameterInfo.Position];
switch (rpcParameterInfo.Name)
{
case nameof(x):
Assert.Equal(x, value);
break;
case nameof(y):
Assert.Equal(y, value);
break;
case nameof(z):
Assert.Equal(z, value);
break;
default:
throw new Exception($"Unknown parameter {rpcParameterInfo.Name}");
}
count++;
}
Assert.Equal(3, count);
}
protected virtual Task NobodyResponseHandler(RequestExecutionContext context)
{
if (context.Result == null ||
(context.Result is bool boolResult && !boolResult))
{
context.HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
}
/// <inheritdoc />
public void AfterExecute(RequestExecutionContext context)
{
var viewActionResult = new ViewActionResult(_executor, _modelMetadataProvider, _tempDataProvider, _viewName, _isMainPage, _contentType, context.Result, context.HttpStatusCode);
// swap the result and it will be executed later in the pipeline if all filters succeed
context.Result = viewActionResult;
}
/// <inheritdoc />
public Task HandleMatchedPath(HttpContext httpContext, RequestDelegate next, IEndPointMethodHandler[] methods)
{
var response = new StringBuilder("OPTIONS");
foreach (var endPointMethodHandler in methods)
{
response.Append(", ");
response.Append(endPointMethodHandler.HttpMethod);
}
var headers = httpContext.Response.Headers;
headers.TryAdd(_optionsConfig.AllowHeader, response.ToString());
httpContext.Response.StatusCode = (int)HttpStatusCode.NoContent;
if (_optionsConfig.Headers.Count > 0)
{
var requestContext = new RequestExecutionContext(httpContext, methods[0], 204);
foreach (var optionsConfigHeader in _optionsConfig.Headers)
{
optionsConfigHeader.ApplyHeader(requestContext, headers);
}
}
return(Task.CompletedTask);
}
public void BeforeExecute(RequestExecutionContext context)
{
Assert.Equal(3, context.Parameters.ParameterCount);
Assert.Equal(3, context.Parameters.ParameterInfos.Count);
var count = 0;
foreach (var rpcParameterInfo in context.Parameters.ParameterInfos)
{
var value = context.Parameters[rpcParameterInfo.Name];
if (value is int intValue)
{
context.Parameters[rpcParameterInfo.Name] = intValue + 5;
}
else
{
throw new Exception($"Value should be int but is {value.GetType().FullName}");
}
count++;
}
Assert.Equal(3, count);
}
public void BeginExecution(RequestExecutionContext context)
{
CheckDisposed();
m_utcLastUsedAt = DateTime.UtcNow;
if (m_activeProcessors.ContainsKey(context))
{
throw new InvalidOperationException("This context is marked as being executed now");
}
var task = new Task(
() => ProducerThreadMethod(context),
TaskCreationOptions.LongRunning);
if (!m_activeProcessors.TryAdd(context, task))
{
throw new Exception("Could not register executing task for this context");
}
try
{
task.Start();
}
catch
{
m_activeProcessors.TryRemove(context, out task);
throw;
}
}
private Task CreateFilters(ref RequestState state, ref RequestExecutionContext requestContext)
{
try
{
var filterFuncList = Configuration.Filters;
var filterList = new List <IRequestFilter> {
Capacity = filterFuncList.Count
};
foreach (var filterFunc in filterFuncList)
{
var filter = filterFunc(requestContext);
if (filter != null)
{
filterList.Add(filter);
}
}
if (filterFuncList.Count > 0)
{
requestContext.CallFilters = filterList;
}
return(NextStep(ref state, ref requestContext));
}
catch (Exception e)
{
return(Services.ErrorHandler.HandleException(requestContext, e));
}
}
public async Task BeforeExecuteAsync(RequestExecutionContext context)
{
foreach (var validator in _validators)
{
await validator.Execute(context);
}
}
/// <inheritdoc />
public Task SerializeToResponse(RequestExecutionContext context)
{
if (context.Result is IActionResult actionResult)
{
return(_actionResultExecutor.Execute(context, actionResult));
}
if (context.Result != null &&
context.ContentSerializer != null)
{
return(context.ContentSerializer.SerializeToResponse(context));
}
if (context.Result == null)
{
return(NullResult(context));
}
if (_serializer != null &&
_serializer.IsDefault)
{
return(_serializer.SerializeToResponse(context));
}
return(NegotiateSerialization(context));
}
/// <inheritdoc />
public override async Task SerializeToResponse(RequestExecutionContext context)
{
var fileWriteStream = new FileBufferingWriteStream();
SetStatusAndContent(context, _contentType);
try
{
using var textWriter = new StreamWriter(fileWriteStream);
using var xmlWriter = new XmlTextWriter(textWriter);
var serializer = GetSerializer(context.Result.GetType());
serializer.Serialize(xmlWriter, context.Result);
xmlWriter.Flush();
textWriter.Flush();
await fileWriteStream.DrainBufferAsync(context.HttpContext.Response.Body, context.HttpContext.RequestAborted);
}
finally
{
await fileWriteStream.DisposeAsync();
}
}
/// <summary>
/// Enumerates through data for a particular SELECT query.
/// Inside MoveNext() imlementation, MUST populate the same instance of row data, pointed to by <see cref="RequestExecutionContext.DriverOutputBuffer"/>.
/// Yields dummy true value, its value and data type are reserved for future use.
/// </summary>
public IDriverDataEnumerator GetData(RequestExecutionContext context)
{
CheckInitialized();
var data = m_dataContainer.RequireDocumentContainer(context.ParsedRequest.TargetEntity.DocumentType);
if (context.ParsedRequest.IsBulk)
{
// engine expects us to use the bulk input data iterator to fetch data rows
return(data.GetBulkUpdateEnumerator(
context.ParsedRequest.BaseDataset.BaseFields,
context.DriverOutputBuffer,
context.InputDataEnumerator));
}
if (context.ParsedRequest.BaseDataset.OrderClauseFields.Count == 0)
{
return(data.GetUnorderedEnumerator(
context.ParsedRequest.BaseDataset.BaseFields,
context.ParsedRequest.BaseDataset.BaseFieldsMainCount,
context.DriverOutputBuffer));
}
if (context.ParsedRequest.BaseDataset.OrderClauseFields.Count > 1)
{
throw new InvalidOperationException("Sorting by more than one field is not supported yet");
}
return(data.GetOrderedEnumerator(
context.ParsedRequest.BaseDataset.BaseFields,
context.ParsedRequest.BaseDataset.BaseFieldsMainCount,
context.DriverOutputBuffer,
context.ParsedRequest.BaseDataset.OrderClauseFields[0].Item1,
context.ParsedRequest.BaseDataset.OrderClauseFields[0].Item2));
}
/// <inheritdoc />
public async Task <bool> AsyncAuthorize(RequestExecutionContext context)
{
var authService = context.HttpContext.RequestServices.GetRequiredService <IAuthorizationService>();
var result = await authService.AuthorizeAsync(context.HttpContext.User, _policy);
return(result.Succeeded);
}
/// <summary>
/// Generate an action context for execution
/// </summary>
/// <param name="context"></param>
/// <param name="actionResult"></param>
/// <returns></returns>
protected virtual ActionContext GenerateActionContext(RequestExecutionContext context, IActionResult actionResult)
{
var routeData = GenerateRouteData(context, actionResult);
var actionDescription = GenerateActionDescriptor(context, actionResult);
return(new ActionContext(context.HttpContext, routeData, actionDescription));
}
/// <inheritdoc />
public void BeforeExecute(RequestExecutionContext context)
{
if (context.Parameters.ParameterCount > 0 &&
context.Parameters[0] is SomeClass someClass)
{
someClass.TestValue = 20;
}
}
public static void StringCompressionCheck(RequestExecutionContext context)
{
if (context.Result is string stringResult &&
stringResult.Length > 1400)
{
context.CanCompress = true;
}
}
/// <inheritdoc />
public override async ValueTask <T> DeserializeFromRequest <T>(RequestExecutionContext context)
{
if (!context.HttpContext.Request.Headers.TryGetValue("Content-Encoding", out var encoding))
{
return(await DeserializeStream <T>(context, context.HttpContext.Request.Body));
}
return(await HandleContentEncoding <T>(context, encoding));
}
/// <inheritdoc />
public Task SerializeToResponse(RequestExecutionContext context)
{
var response = context.HttpContext.Response;
response.ContentType = ContentType;
response.StatusCode = context.HttpStatusCode;
return(MsgPack.MessagePackSerializer.SerializeAsync(response.Body, context.Result, _options, context.HttpContext.RequestAborted));
}
private void ReadRequest(RequestExecutionContext context)
{
Serializer.MergeWithLengthPrefix(context.RequestMessage.Stream, context.Request, PrefixStyle.Base128);
if (context.Request.PrepareOnly)
{
// prevent any ambiguities
context.Request.ReturnDataset = false;
}
if (context.Request.HaveParameters)
{
context.ParsedRequest.HaveParametersDataInput = true;
Serializer.MergeWithLengthPrefix(context.RequestMessage.Stream, context.RequestParameters, PrefixStyle.Base128);
ReadParametersDataInput(context);
}
if (context.Request.HaveRequestBulk)
{
context.ParsedRequest.IsBulk = true;
Serializer.MergeWithLengthPrefix(context.RequestMessage.Stream, context.RequestBulk, PrefixStyle.Base128);
// after this point in stream, bulk input data will be read by instance of InputDataStreamEnumerator
// e.g. we're not yet done reading the request stream here
}
if (m_tracer.IsInfoEnabled)
{
var cmdText = context.Request.CommandText;
if (string.IsNullOrEmpty(cmdText) && context.Request.HaveRequestBulk)
{
cmdText = string.Format("Bulk {0} with {2} items on {1}", context.RequestBulk.DbStatementType, context.RequestBulk.EntityName, context.RequestBulk.InputItemsCount);
}
m_tracer.Info("Received command: " + cmdText);
}
// bring up cache record
var cacheKey = ParsedRequestCache.GetRequestHash(context.Request, context.RequestBulk, context.RequestParameters);
var cacheInfo = m_parsedRequestCache.AddOrGetExisting(cacheKey, context.Request.HaveParameters);
context.AttachCachedInfo(cacheInfo);
// populate cache record
if (!cacheInfo.HaveRequestHeaders)
{
lock (cacheInfo)
{
cacheInfo.CheckIsError();
if (!cacheInfo.HaveRequestHeaders)
{
cacheInfo.ReadRequestHeaders(context.Request, context.RequestParameters, context.RequestBulk, context.ParsedRequest);
}
}
}
}
private Task BindParameters(ref RequestState state, ref RequestExecutionContext requestContext)
{
var bindResult = BindParametersDelegate(requestContext);
if (bindResult.IsCompletedSuccessfully)
{
return(NextStep(ref state, ref requestContext));
}
return(AsyncBindParameter(this, state, requestContext, bindResult, Services.ErrorHandler));
/// <inheritdoc />
public object WrapError(RequestExecutionContext context, Exception e)
{
_errorWrapperCreator ??= CreateWrapperFunction();
var wrapper = _errorWrapperCreator();
wrapper.Message = e.Message;
return(wrapper);
}
/// <inheritdoc />
public override ValueTask <T> DeserializeFromRequest <T>(RequestExecutionContext context)
{
if (!context.HttpContext.Request.Headers.TryGetValue("Content-Encoding", out var encoding))
{
return(JsonSerializer.DeserializeAsync <T>(context.HttpContext.Request.Body, _serializerOptions,
context.HttpContext.RequestAborted));
}
return(HandleContentEncoding <T>(context, encoding));
}
private Stream GetOutputStream(RequestExecutionContext context)
{
if (!context.CanCompress ||
!context.HttpContext.Request.Headers.TryGetValue("Accept-Encoding", out var encoding))
{
return(context.HttpContext.Response.Body);
}
return(EncodeOutputStream(context, encoding));
}
private static void AssertSerializationResult(LgoLeagueGameRetrievalConfiguration retrievalConfiguration, string expectedJson)
{
var requestContext = new RequestExecutionContext.Builder().With(retrievalConfiguration).Build();
RequestExecutionContext.ExecuteWith(requestContext, () =>
{
var actualJson = JsonConvert.SerializeObject(Game, Formatting.Indented);
Assert.AreEqual(expectedJson, actualJson);
});
}
private void SetErrorMessage(RequestExecutionContext requestExecutionContext, ValidationResult result)
{
requestExecutionContext.Result ??= _errorWrappingService.GetErrorWrapper();
if (requestExecutionContext.Result is IErrorWrapper errorWrapper)
{
errorWrapper.Message += result.ToString();
requestExecutionContext.HttpStatusCode = (int)HttpStatusCode.UnprocessableEntity;
}
}
