public void RequestSet_UpdatesRequest() { // Arrange using (HttpRequestMessage expectedRequest = CreateRequest()) { RequestBackedHttpRequestContext context = CreateProductUnderTest(); // Act context.Request = expectedRequest; // Assert Assert.Same(expectedRequest, context.Request); } }
public void RequestGet_ReturnsInstanceProvidedInConstructorWithRequest() { // Arrange using (HttpRequestMessage expectedRequest = CreateRequest()) { RequestBackedHttpRequestContext context = CreateProductUnderTest(expectedRequest); // Act HttpRequestMessage request = context.Request; // Assert Assert.Same(expectedRequest, request); } }
private async Task ProcessRequest(MessageContext restbusContext, CancellationToken cancellationToken) { //NOTE: This method is called on a background thread and must be protected by an outer big-try catch HttpRequestMessage requestMsg; HttpResponseMessage responseMsg = null; if (!restbusContext.Request.TryGetHttpRequestMessage(appVirtualPath ?? (appVirtualPath = System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath), out requestMsg)) { responseMsg = new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = "Bad Request" }; } if (disposed) { responseMsg = requestMsg.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, "The server is no longer available."); } else { requestHandler.EnsureInitialized(); // Add current synchronization context to request parameter SynchronizationContext syncContext = SynchronizationContext.Current; if (syncContext != null) { requestMsg.SetSynchronizationContext(syncContext); } // Add HttpConfiguration to request parameter requestMsg.SetConfiguration(config); // Ensure we have a principal, even if the host didn't give us one IPrincipal originalPrincipal = Thread.CurrentPrincipal; if (originalPrincipal == null) { Thread.CurrentPrincipal = anonymousPrincipal.Value; } // Ensure we have a principal on the request context (if there is a request context). HttpRequestContext requestContext = requestMsg.GetRequestContext(); if (requestContext == null) { requestContext = new RequestBackedHttpRequestContext(requestMsg); // if the host did not set a request context we will also set it back to the request. requestMsg.SetRequestContext(requestContext); } try { try { responseMsg = await requestHandler.SendMessageAsync(requestMsg, cancellationToken); } catch (HttpResponseException exception) { responseMsg = exception.Response; } catch (NullReferenceException exception) { // There is a bug in older versions of HttpRoutingDispatcher which causes a null reference exception when // a route could not be found // This bug can be triggered by sending a request for a url that doesn't have a route // This commit fixes the bug https://github.com/ASP-NET-MVC/aspnetwebstack/commit/6a0c03f9e549966a7f806f8b696ec4cb2ec272e6#diff-c89c7bee3d225a037a6d04e8e4447460 if (exception.TargetSite != null && exception.TargetSite.DeclaringType != null && exception.TargetSite.DeclaringType.FullName == "System.Web.Http.Dispatcher.HttpRoutingDispatcher" && exception.TargetSite.Name == "SendAsync") { //This is the bug, so send a 404 instead const string NoRouteMatchedHttpPropertyKey = "MS_NoRouteMatched"; requestMsg.Properties.Add(NoRouteMatchedHttpPropertyKey, true); responseMsg = requestMsg.CreateErrorResponse( HttpStatusCode.NotFound, String.Format("No HTTP resource was found that matches the request URI '{0}'.", requestMsg.RequestUri)); } else { responseMsg = CreateResponseMessageFromException(exception); } } catch (Exception exception) { responseMsg = CreateResponseMessageFromException(exception); } if (responseMsg == null) { //TODO: Not good, Log this //TODO: derive exception from RestBus.Exceptions class responseMsg = CreateResponseMessageFromException(new ApplicationException("Unable to get response")); } } finally { Thread.CurrentPrincipal = originalPrincipal; } } //Send Response try { //TODO: Why can't the subscriber append the subscriber id itself from within sendresponse subscriber.SendResponse(restbusContext, CreateResponsePacketFromMessage(responseMsg, subscriber)); } catch { //TODO: Log SendResponse error } }
private static HttpControllerContext CreateControllerContext( HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, IHttpController controller) { Contract.Assert(request != null); Contract.Assert(controllerDescriptor != null); Contract.Assert(controller != null); HttpConfiguration controllerConfiguration = controllerDescriptor.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); } return new HttpControllerContext(requestContext, request, controllerDescriptor, controller); }
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw Error.ArgumentNull("request"); } if (_disposed) { return request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, SRResources.HttpServerDisposed); } // The first request initializes the server EnsureInitialized(); // Capture current synchronization context and add it as a parameter to the request SynchronizationContext context = SynchronizationContext.Current; if (context != null) { request.SetSynchronizationContext(context); } // Add HttpConfiguration object as a parameter to the request request.SetConfiguration(_configuration); // Ensure we have a principal, even if the host didn't give us one IPrincipal originalPrincipal = Thread.CurrentPrincipal; if (originalPrincipal == null) { Thread.CurrentPrincipal = _anonymousPrincipal; } // Ensure we have a principal on the request context (if there is a request context). HttpRequestContext requestContext = request.GetRequestContext(); if (requestContext == null) { requestContext = new RequestBackedHttpRequestContext(request); // if the host did not set a request context we will also set it back to the request. request.SetRequestContext(requestContext); } try { ExceptionDispatchInfo exceptionInfo; try { return await base.SendAsync(request, cancellationToken); } catch (OperationCanceledException) { // Propogate the canceled task without calling exception loggers or handlers. throw; } catch (HttpResponseException exception) { return exception.Response; } catch (Exception exception) { exceptionInfo = ExceptionDispatchInfo.Capture(exception); } Debug.Assert(exceptionInfo.SourceException != null); ExceptionContext exceptionContext = new ExceptionContext(exceptionInfo.SourceException, ExceptionCatchBlocks.HttpServer, request); await ExceptionLogger.LogAsync(exceptionContext, cancellationToken); HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext, cancellationToken); if (response == null) { exceptionInfo.Throw(); } return response; } finally { Thread.CurrentPrincipal = originalPrincipal; } }
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); }
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw Error.ArgumentNull("request"); } if (_disposed) { return request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, SRResources.HttpServerDisposed); } // The first request initializes the server EnsureInitialized(); // Capture current synchronization context and add it as a parameter to the request SynchronizationContext context = SynchronizationContext.Current; if (context != null) { request.SetSynchronizationContext(context); } // Add HttpConfiguration object as a parameter to the request request.SetConfiguration(_configuration); // Ensure we have a principal, even if the host didn't give us one IPrincipal originalPrincipal = Thread.CurrentPrincipal; if (originalPrincipal == null) { Thread.CurrentPrincipal = _anonymousPrincipal; } // Ensure we have a principal on the request context (if there is a request context). HttpRequestContext requestContext = request.GetRequestContext(); if (requestContext == null) { requestContext = new RequestBackedHttpRequestContext(request); // if the host did not set a request context we will also set it back to the request. request.SetRequestContext(requestContext); } try { return await base.SendAsync(request, cancellationToken); } catch (HttpResponseException exception) { return exception.Response; } catch (Exception exception) { return request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception); } finally { Thread.CurrentPrincipal = originalPrincipal; } }