private static HttpActionDescriptor SelectAction(HttpRequestMessage request, IHttpRouteData routeData, HttpConfiguration config)
{
request.SetRouteData(routeData);
routeData.RemoveOptionalRoutingParameters();
HttpControllerDescriptor controllerDescriptor = config.Services.GetHttpControllerSelector().SelectController(request);
// Get the per-controller configuration
config = controllerDescriptor.Configuration;
request.SetConfiguration(config);
HttpRequestContext requestContext = request.GetRequestContext();
if (requestContext == null)
{
requestContext = new HttpRequestContext
{
Configuration = config,
RouteData = routeData,
Url = new UrlHelper(request),
VirtualPathRoot = config.VirtualPathRoot
};
}
IHttpController controller = controllerDescriptor.CreateController(request);
using (controller as IDisposable)
{
HttpControllerContext controllerContext = new HttpControllerContext(requestContext, request, controllerDescriptor, controller);
return(config.Services.GetActionSelector().SelectAction(controllerContext));
}
}
private static HttpActionDescriptor GetHttpActionDescriptorForRestierController(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor)
{
HttpActionDescriptor actionDescriptor;
var perControllerConfig = controllerDescriptor.Configuration;
request.SetConfiguration(perControllerConfig);
var requestContext = request.GetRequestContext();
requestContext.Configuration = perControllerConfig;
requestContext.RouteData = request.GetRouteData();
requestContext.Url = new UrlHelper(request);
requestContext.VirtualPathRoot = perControllerConfig.VirtualPathRoot;
var controller = controllerDescriptor.CreateController(request);
using (controller as IDisposable)
{
var controllerContext = new HttpControllerContext(requestContext, request, controllerDescriptor, controller);
try
{
actionDescriptor = perControllerConfig.Services.GetActionSelector().SelectAction(controllerContext);
}
catch (HttpResponseException ex)
{
if (ex.Response.StatusCode == HttpStatusCode.NotFound || ex.Response.StatusCode == HttpStatusCode.MethodNotAllowed)
{
actionDescriptor = null;
}
else
{
throw;
}
}
}
return actionDescriptor;
}
public override IHttpController CreateController(HttpRequestMessage request)
{
IHttpController controller = null;
_traceWriter.TraceBeginEnd(
request,
TraceCategories.ControllersCategory,
TraceLevel.Info,
_innerDescriptor.GetType().Name,
CreateControllerMethodName,
beginTrace: null,
execute: () =>
{
controller = _innerDescriptor.CreateController(request);
},
endTrace: (tr) =>
{
tr.Message = controller == null
? SRResources.TraceNoneObjectMessage
: HttpControllerTracer.ActualControllerType(controller).FullName;
},
errorTrace: null);
if (controller != null && !(controller is HttpControllerTracer))
{
return(new HttpControllerTracer(request, controller, _traceWriter));
}
return(controller);
}
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));
}
private static HttpActionDescriptor GetHttpActionDescriptorForRestierController(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor)
{
HttpActionDescriptor actionDescriptor;
var perControllerConfig = controllerDescriptor.Configuration;
request.SetConfiguration(perControllerConfig);
var requestContext = request.GetRequestContext();
requestContext.Configuration = perControllerConfig;
requestContext.RouteData = request.GetRouteData();
requestContext.Url = new UrlHelper(request);
requestContext.VirtualPathRoot = perControllerConfig.VirtualPathRoot;
var controller = controllerDescriptor.CreateController(request);
using (controller as IDisposable)
{
var controllerContext = new HttpControllerContext(requestContext, request, controllerDescriptor, controller);
try
{
actionDescriptor = perControllerConfig.Services.GetActionSelector().SelectAction(controllerContext);
}
catch (HttpResponseException ex)
{
if (ex.Response.StatusCode == HttpStatusCode.NotFound || ex.Response.StatusCode == HttpStatusCode.MethodNotAllowed)
{
actionDescriptor = null;
}
else
{
throw;
}
}
}
return(actionDescriptor);
}
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));
}
