/// <inheritdoc />
/// <summary>
/// Executes an action.
/// </summary>
/// <param name="controllerContext">Controller context.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>Response message.</returns>
public Task <HttpResponseMessage> ExecuteAsync(
HttpControllerContext controllerContext,
CancellationToken cancellationToken)
{
if (_controller == null)
{
var request = controllerContext.Request;
if (request
.GetDependencyScope()
.GetService(typeof(IUnityContainer)) is IUnityContainer container)
{
container.RegisterInstance(controllerContext);
container.RegisterInstance(request);
container.RegisterInstance(cancellationToken);
UnityTypesRegistrator.RegisterTypes(container);
}
_controller = Activator.Create(
request,
controllerContext.ControllerDescriptor,
ControllerType);
}
controllerContext.Controller = _controller;
return(_controller.ExecuteAsync(controllerContext, cancellationToken));
}
internal async Task <HttpResponseMessage> SendFluentApiAsync(HttpRequestMessage request, CancellationToken cancellationToken, HttpControllerDescriptor controllerDescriptor)
{
ExceptionDispatchInfo exceptionInfo;
HttpControllerContext controllerContext = null;
try
{
IHttpController controller = controllerDescriptor.CreateController(request);
if (controller == null)
{
var httpError = new HttpError(string.Format(CultureInfo.CurrentCulture, "No HTTP resource was found that matches the request URI '{0}'.", request.RequestUri));
if (request.ShouldIncludeErrorDetail())
{
httpError.Add(HttpErrorKeys.MessageDetailKey, "No controller was created to handle this request.");
}
return(request.CreateErrorResponse(HttpStatusCode.NotFound, httpError));
}
controllerContext = CreateControllerContext(request, controllerDescriptor, controller);
return(await controller.ExecuteAsync(controllerContext, cancellationToken));
}
catch (OperationCanceledException)
{
// Propogate the canceled task without calling exception loggers or handlers.
throw;
}
catch (HttpResponseException httpResponseException)
{
return(httpResponseException.Response);
}
catch (Exception exception)
{
exceptionInfo = ExceptionDispatchInfo.Capture(exception);
}
Debug.Assert(exceptionInfo.SourceException != null);
ExceptionContext exceptionContext = new ExceptionContext(
exceptionInfo.SourceException,
ExceptionCatchBlocks.HttpControllerDispatcher,
request)
{
ControllerContext = controllerContext,
};
await ExceptionLogger.LogAsync(exceptionContext, cancellationToken);
HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext, cancellationToken);
if (response == null)
{
exceptionInfo.Throw();
}
return(response);
}
private Task <HttpResponseMessage> SendAsyncInternal(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
if (_disposed)
{
throw Error.ObjectDisposed(SRResources.HttpMessageHandlerDisposed, typeof(HttpControllerDispatcher).Name);
}
// Lookup route data, or if not found as a request property then we look it up in the route table
IHttpRouteData routeData;
if (!request.Properties.TryGetValue(HttpPropertyKeys.HttpRouteDataKey, out routeData))
{
routeData = _configuration.Routes.GetRouteData(request);
if (routeData != null)
{
request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData);
}
else
{
// TODO, 328927, add an error message in the response body
return(TaskHelpers.FromResult(request.CreateResponse(HttpStatusCode.NotFound)));
}
}
RemoveOptionalRoutingParameters(routeData.Values);
HttpControllerDescriptor httpControllerDescriptor = ControllerSelector.SelectController(request);
if (httpControllerDescriptor == null)
{
// TODO, 328927, add an error message in the response body
return(TaskHelpers.FromResult(request.CreateResponse(HttpStatusCode.NotFound)));
}
IHttpController httpController = httpControllerDescriptor.CreateController(request);
if (httpController == null)
{
// TODO, 328927, add an error message in the response body
return(TaskHelpers.FromResult(request.CreateResponse(HttpStatusCode.NotFound)));
}
// Create context
HttpControllerContext controllerContext = new HttpControllerContext(_configuration, routeData, request);
controllerContext.Controller = httpController;
controllerContext.ControllerDescriptor = httpControllerDescriptor;
return(httpController.ExecuteAsync(controllerContext, cancellationToken));
}
private Task <HttpResponseMessage> SendAsyncInternal(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
IHttpRouteData routeData = request.GetRouteData();
Contract.Assert(routeData != null);
HttpControllerDescriptor httpControllerDescriptor = ControllerSelector.SelectController(request);
if (httpControllerDescriptor == null)
{
return(TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerSelected)));
}
IHttpController httpController = httpControllerDescriptor.CreateController(request);
if (httpController == null)
{
return(TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerCreated)));
}
// Set the controller configuration on the request properties
HttpConfiguration requestConfig = request.GetConfiguration();
if (requestConfig == null)
{
request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, httpControllerDescriptor.Configuration);
}
else
{
if (requestConfig != httpControllerDescriptor.Configuration)
{
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = httpControllerDescriptor.Configuration;
}
}
// Create context
HttpControllerContext controllerContext = new HttpControllerContext(httpControllerDescriptor.Configuration, routeData, request);
controllerContext.Controller = httpController;
controllerContext.ControllerDescriptor = httpControllerDescriptor;
return(httpController.ExecuteAsync(controllerContext, cancellationToken));
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
IHttpRouteData routeData = request.GetRouteData();
IHttpControllerSelector ControllerSelector = mConfiguration.Services.GetHttpControllerSelector();
HttpControllerDescriptor httpControllerDescriptor = ControllerSelector.SelectController(request);
IHttpController httpController = httpControllerDescriptor.CreateController(request);
request.Method = new HttpMethod(mVerbChange);
// Create context
HttpControllerContext controllerContext = new HttpControllerContext(mConfiguration, routeData, request);
controllerContext.Controller = httpController;
controllerContext.ControllerDescriptor = httpControllerDescriptor;
return(httpController.ExecuteAsync(controllerContext, cancellationToken));
}
Task <HttpResponseMessage> IHttpController.ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerController.GetType().Name,
ExecuteAsyncMethodName,
beginTrace: null,
execute: () =>
{
// Critical to allow wrapped controller to have itself in ControllerContext
controllerContext.Controller = ActualController(controllerContext.Controller);
return _innerController.ExecuteAsync(controllerContext, cancellationToken)
.Finally(() =>
{
IDisposable disposable = _innerController as IDisposable;
if (disposable != null)
{
// Need to remove the original controller from the disposables list, if it's
// there, and put ourselves in there instead, so we can trace the dispose.
// This currently knows a little too much about how RegisterForDispose works,
// but that's unavoidable unless we want to offer UnregisterForDispose.
IList <IDisposable> disposables;
if (_request.Properties.TryGetValue(HttpPropertyKeys.DisposableRequestResourcesKey, out disposables))
{
disposables.Remove(disposable);
disposables.Add(this);
}
}
});
},
endTrace: (tr, response) =>
{
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: null));
}
Task <HttpResponseMessage> IHttpController.ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
return(_traceWriter.TraceBeginEndAsync <HttpResponseMessage>(
controllerContext.Request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerController.GetType().Name,
ExecuteAsyncMethodName,
beginTrace: null,
execute: () =>
{
// Critical to allow wrapped controller to have itself in ControllerContext
controllerContext.Controller = ActualController(controllerContext.Controller);
return _innerController.ExecuteAsync(controllerContext, cancellationToken);
},
endTrace: (tr, response) =>
{
if (response != null)
{
tr.Status = response.StatusCode;
}
},
errorTrace: null));
}
/// <summary>
/// Executes an action.
/// </summary>
/// <param name="controllerContext">Controller context.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>Response message.</returns>
public Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
if (controller == null)
{
var request = controllerContext.Request;
var container = request.GetDependencyScope().GetService(typeof(IUnityContainer)) as IUnityContainer;
if (container != null)
{
container.RegisterInstance <HttpControllerContext>(controllerContext);
container.RegisterInstance <HttpRequestMessage>(request);
container.RegisterInstance <CancellationToken>(cancellationToken);
}
controller = activator.Create(
request,
controllerContext.ControllerDescriptor,
controllerType);
}
controllerContext.Controller = controller;
return(controller.ExecuteAsync(controllerContext, cancellationToken));
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
ExceptionDispatchInfo exceptionInfo;
HttpControllerContext controllerContext = null;
try
{
HttpControllerDescriptor controllerDescriptor = ControllerSelector.SelectController(request);
if (controllerDescriptor == null)
{
return(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerSelected));
}
IHttpController controller = controllerDescriptor.CreateController(request);
if (controller == null)
{
return(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerCreated));
}
controllerContext = CreateControllerContext(request, controllerDescriptor, controller);
return(await controller.ExecuteAsync(controllerContext, cancellationToken));
}
catch (OperationCanceledException)
{
// Propogate the canceled task without calling exception loggers or handlers.
throw;
}
catch (HttpResponseException httpResponseException)
{
return(httpResponseException.Response);
}
catch (Exception exception)
{
exceptionInfo = ExceptionDispatchInfo.Capture(exception);
}
Debug.Assert(exceptionInfo.SourceException != null);
ExceptionContext exceptionContext = new ExceptionContext(
exceptionInfo.SourceException,
ExceptionCatchBlocks.HttpControllerDispatcher,
request)
{
ControllerContext = controllerContext,
};
await ExceptionLogger.LogAsync(exceptionContext, cancellationToken);
HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext, cancellationToken);
if (response == null)
{
exceptionInfo.Throw();
}
return(response);
}
private Task <HttpResponseMessage> SendAsyncCore(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
IHttpRouteData routeData = request.GetRouteData();
Contract.Assert(routeData != null);
HttpControllerDescriptor httpControllerDescriptor = ControllerSelector.SelectController(request);
if (httpControllerDescriptor == null)
{
return(TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerSelected)));
}
IHttpController httpController = httpControllerDescriptor.CreateController(request);
if (httpController == null)
{
return(TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerCreated)));
}
HttpConfiguration controllerConfiguration = httpControllerDescriptor.Configuration;
// Set the controller configuration on the request properties
HttpConfiguration requestConfig = request.GetConfiguration();
if (requestConfig == null)
{
request.SetConfiguration(controllerConfiguration);
}
else
{
if (requestConfig != controllerConfiguration)
{
request.SetConfiguration(controllerConfiguration);
}
}
HttpRequestContext requestContext = request.GetRequestContext();
// if the host doesn't create the context we will fallback to creating it.
if (requestContext == null)
{
requestContext = new RequestBackedHttpRequestContext(request)
{
// we are caching controller configuration to support per controller configuration.
Configuration = controllerConfiguration,
};
// if the host did not set a request context we will also set it back to the request.
request.SetRequestContext(requestContext);
}
// Create context
HttpControllerContext controllerContext = new HttpControllerContext(requestContext, request,
httpControllerDescriptor, httpController);
return(httpController.ExecuteAsync(controllerContext, cancellationToken));
}
private Task <HttpResponseMessage> SendAsyncCore(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
IHttpRouteData routeData = request.GetRouteData();
Contract.Assert(routeData != null);
HttpControllerDescriptor httpControllerDescriptor = ControllerSelector.SelectController(request);
if (httpControllerDescriptor == null)
{
return(TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerSelected)));
}
IHttpController httpController = httpControllerDescriptor.CreateController(request);
if (httpController == null)
{
return(TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerCreated)));
}
HttpConfiguration controllerConfiguration = httpControllerDescriptor.Configuration;
// Set the controller configuration on the request properties
HttpConfiguration requestConfig = request.GetConfiguration();
if (requestConfig == null)
{
request.SetConfiguration(controllerConfiguration);
}
else
{
if (requestConfig != controllerConfiguration)
{
request.SetConfiguration(controllerConfiguration);
}
}
HttpRequestContext requestContext = request.GetRequestContext();
if (requestContext == null)
{
requestContext = new HttpRequestContext
{
Configuration = controllerConfiguration,
RouteData = routeData,
Url = new UrlHelper(request),
VirtualPathRoot = controllerConfiguration != null ? controllerConfiguration.VirtualPathRoot : null
};
}
// Create context
HttpControllerContext controllerContext = new HttpControllerContext(requestContext, request,
httpControllerDescriptor, httpController);
return(httpController.ExecuteAsync(controllerContext, cancellationToken));
}
