private HttpContent ContentFor(HttpRequestMessage request, SwaggerDocument swaggerDoc) { var negotiator = request.GetConfiguration().Services.GetContentNegotiator(); var result = negotiator.Negotiate(typeof(SwaggerDocument), request, GetSupportedSwaggerFormatters()); return new ObjectContent(typeof(SwaggerDocument), swaggerDoc, result.Formatter, result.MediaType); }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { //得到描述目标Action的HttpActionDescriptor HttpMethod originalMethod = request.Method; bool isPreflightRequest = request.IsPreflightRequest(); if (isPreflightRequest) { string method = request.Headers.GetValues("Access-Control-Request-Method").First(); request.Method = new HttpMethod(method); } HttpConfiguration configuration = request.GetConfiguration(); HttpControllerDescriptor controllerDescriptor = configuration.Services.GetHttpControllerSelector().SelectController(request); HttpControllerContext controllerContext = new HttpControllerContext(request.GetConfiguration(), request.GetRouteData(), request) { ControllerDescriptor = controllerDescriptor }; HttpActionDescriptor actionDescriptor = configuration.Services.GetActionSelector().SelectAction(controllerContext); //根据HttpActionDescriptor得到应用的CorsAttribute特性 CorsAttribute corsAttribute = actionDescriptor.GetCustomAttributes<CorsAttribute>().FirstOrDefault() ?? controllerDescriptor.GetCustomAttributes<CorsAttribute>().FirstOrDefault(); if (null == corsAttribute) { return base.SendAsync(request, cancellationToken); } //利用CorsAttribute实施授权并生成响应报头 IDictionary<string, string> headers; request.Method = originalMethod; bool authorized = corsAttribute.TryEvaluate(request, out headers); HttpResponseMessage response; if (isPreflightRequest) { if (authorized) { response = new HttpResponseMessage(HttpStatusCode.OK); } else { response = request.CreateErrorResponse(HttpStatusCode.BadRequest, corsAttribute.ErrorMessage); } } else { response = base.SendAsync(request, cancellationToken).Result; } //添加响应报头 if (headers != null && headers.Any()) foreach (var item in headers) response.Headers.Add(item.Key, item.Value); return Task.Factory.StartNew(() => response); //only .net4.5 supports Task.FromResult //return Task.FromResult<HttpResponseMessage>(response); }
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType) { if (_viewLocator == null || _viewParser == null) { var config = request.GetConfiguration(); if (config != null) { IViewLocator viewLocator = null; IViewParser viewParser = null; var resolver = config.DependencyResolver; if (_viewLocator == null) viewLocator = (IViewLocator) resolver.GetService(typeof (IViewLocator)); if (_viewParser == null) viewParser = (IViewParser) resolver.GetService(typeof (IViewParser)); return new HtmlMediaTypeViewFormatter(_siteRootPath, viewLocator, viewParser); } } return base.GetPerRequestFormatterInstance(type, request, mediaType); }
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { HttpResponseMessage response = await base.SendAsync(request, cancellationToken); Collection<IResponseEnricher> enrichers = request.GetConfiguration().GetResponseEnrichers(); return enrichers.Where(e => e.CanEnrich(response)) .Aggregate(response, (resp, enricher) => enricher.Enrich(response)); }
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { HttpConfiguration config = request.GetConfiguration(); IHostPrincipalService principalService = config.Services.GetHostPrincipalService(); IPrincipal principal = principalService.GetCurrentPrincipal(request); if (!principal.Identity.IsAuthenticated || !SuppressIfAlreadyAuthenticated) { if (request.Headers.Authorization != null && request.Headers.Authorization.Scheme == _httpBasicSchemeName) { string username, password; if (TryExtractBasicAuthCredentialsFromHeader(request.Headers.Authorization.Parameter, out username, out password)) { IPrincipal returnedPrincipal = await AuthenticateUserAsync(request, username, password, cancellationToken); // Check if the user has been authenticated successfully if (returnedPrincipal != null) { principalService.SetCurrentPrincipal(returnedPrincipal, request); return await base.SendAsync(request, cancellationToken); } } } } // Request is not authanticated. Handle unauthenticated request. return await HandleUnauthenticatedRequestImpl(request, cancellationToken); }
/// <inheritdoc/> public override async Task<HttpResponseMessage> ProcessBatchAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw Error.ArgumentNull("request"); } ValidateRequest(request); IList<ODataBatchRequestItem> subRequests = await ParseBatchRequestsAsync(request, cancellationToken); string preferHeader = RequestPreferenceHelpers.GetRequestPreferHeader(request); if ((preferHeader != null && preferHeader.Contains(PreferenceContinueOnError)) || (!request.GetConfiguration().HasEnabledContinueOnErrorHeader())) { ContinueOnError = true; } else { ContinueOnError = false; } try { IList<ODataBatchResponseItem> responses = await ExecuteRequestMessagesAsync(subRequests, cancellationToken); return await CreateResponseMessageAsync(responses, request, cancellationToken); } finally { foreach (ODataBatchRequestItem subRequest in subRequests) { request.RegisterForDispose(subRequest.GetResourcesForDisposal()); request.RegisterForDispose(subRequest); } } }
public virtual ICorsPolicyProvider GetCorsPolicyProvider(HttpRequestMessage request) { if (request == null) { throw new ArgumentNullException("request"); } CorsRequestContext corsRequestContext = request.GetCorsRequestContext(); HttpActionDescriptor actionDescriptor = null; if (corsRequestContext.IsPreflight) { HttpRequestMessage targetRequest = new HttpRequestMessage(new HttpMethod(corsRequestContext.AccessControlRequestMethod), request.RequestUri); request.RegisterForDispose(targetRequest); try { foreach (var property in request.Properties) { // The RouteData and HttpContext from the preflight request properties contain information // relevant to the preflight request and not the actual request, therefore we need to exclude them. if (property.Key != HttpPropertyKeys.HttpRouteDataKey && property.Key != HttpContextBaseKey) { targetRequest.Properties.Add(property.Key, property.Value); } } HttpConfiguration config = request.GetConfiguration(); if (config == null) { throw new InvalidOperationException(SRResources.NoConfiguration); } IHttpRouteData routeData = config.Routes.GetRouteData(request); if (routeData == null) { // No route data found for selecting action with EnableCorsAttribute, thus no ICorsPolicyProvider is returned // and let the CorsMessageHandler flow the request to the normal Web API pipeline. return null; } actionDescriptor = SelectAction(targetRequest, routeData, config); } catch { if (DefaultPolicyProvider != null) { return DefaultPolicyProvider; } throw; } } else { actionDescriptor = request.GetActionDescriptor(); } return GetCorsPolicyProvider(actionDescriptor); }
internal static bool LegacyShouldIncludeErrorDetail(this HttpRequestMessage request) { HttpConfiguration configuration = request.GetConfiguration(); IncludeErrorDetailPolicy includeErrorDetailPolicy = IncludeErrorDetailPolicy.Default; if (configuration != null) { includeErrorDetailPolicy = configuration.IncludeErrorDetailPolicy; } switch (includeErrorDetailPolicy) { case IncludeErrorDetailPolicy.Default: Lazy <bool> includeErrorDetail = request.GetProperty <Lazy <bool> >(HttpPropertyKeys.IncludeErrorDetailKey); if (includeErrorDetail != null) { // If we are on webhost and the user hasn't changed the IncludeErrorDetailPolicy // look up into the Request's property bag else default to LocalOnly. return(includeErrorDetail.Value); } goto case IncludeErrorDetailPolicy.LocalOnly; case IncludeErrorDetailPolicy.LocalOnly: return(request.IsLocal()); case IncludeErrorDetailPolicy.Always: return(true); case IncludeErrorDetailPolicy.Never: default: return(false); } }
/// <summary> /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided /// <paramref name="value"/>. The given <paramref name="mediaType"/> is used to find an instance of <see cref="MediaTypeFormatter"/>. /// </summary> /// <typeparam name="T">The type of the value.</typeparam> /// <param name="request">The request.</param> /// <param name="statusCode">The status code of the created response.</param> /// <param name="value">The value to wrap. Can be <c>null</c>.</param> /// <param name="mediaType">The media type used to look up an instance of <see cref="MediaTypeFormatter"/>.</param> /// <exception cref="InvalidOperationException">Thrown if the <paramref name="request"/> does not have an associated /// <see cref="HttpConfiguration"/> instance or if the configuration does not have a formatter matching <paramref name="mediaType"/>.</exception> /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns> public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeHeaderValue mediaType) { if (request == null) { throw Error.ArgumentNull("request"); } if (mediaType == null) { throw Error.ArgumentNull("mediaType"); } HttpConfiguration configuration = request.GetConfiguration(); if (configuration == null) { throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoConfiguration); } MediaTypeFormatter formatter = configuration.Formatters.FindWriter(typeof(T), mediaType); if (formatter == null) { throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoMatchingFormatter, mediaType, typeof(T).Name); } return(request.CreateResponse(statusCode, value, formatter, mediaType)); }
internal static string[] GetMappedModelProperties(HttpRequestMessage request, Type modelType) { return(MappedModelProperties.GetOrAdd(modelType, type => { try { return type.GetProperties() .Where(p => p.GetCustomAttribute <NotMappedAttribute>() == null) .Select(p => p.Name).ToArray(); } catch (Exception ex) { HttpConfiguration config = request.GetConfiguration(); if (config != null) { ITraceWriter writer = config.Services.GetTraceWriter(); if (writer != null) { writer.Error(TResources.TableController_NoProperties.FormatForUser(type.Name, ex.Message), ex, request, ServiceLogCategories.TableControllers); } } return new string[0]; } })); }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request.Method == HttpMethod.Options) { var apiExplorer = request.GetConfiguration().Services.GetApiExplorer(); var controllerRequested = request.GetRouteData().Values["controller"] as string; var supportedMethods = apiExplorer.ApiDescriptions .Where(d => { var controller = d.ActionDescriptor.ControllerDescriptor.ControllerName; return string.Equals( controller, controllerRequested, StringComparison.OrdinalIgnoreCase); }) .Select(d => d.HttpMethod.Method) .Distinct(); if (!supportedMethods.Any()) { return Task.FromResult(request.CreateResponse(HttpStatusCode.NotFound)); } var response = new HttpResponseMessage(HttpStatusCode.OK); response.Headers.Add("Access-Control-Allow-Origin", "*"); response.Headers.Add("Access-Control-Allow-Methods", string.Join(",", supportedMethods)); return Task.FromResult(response); } return base.SendAsync(request, cancellationToken); }
/// <summary> /// /// </summary> /// <returns></returns> internal static string DefaultRootUrlResolver(HttpRequestMessage request) { string text = request.GetConfiguration().VirtualPathRoot.TrimEnd(new char[] { '/' }); Uri requestUri = request.RequestUri; return string.Format(CultureInfo.InvariantCulture, "{0}://{1}:{2}{3}", new object[] { requestUri.Scheme, requestUri.Host, requestUri.Port, text }); }
public HttpControllerDescriptor SelectController(HttpRequestMessage request) { // Uses the current State key to create the Web Api Controller Type return new HttpControllerDescriptor { Configuration = request.GetConfiguration(), ControllerType = Type.GetType("NavigationEdgeApi.Controllers." + request.Properties["key"] + "Controller", true, true) }; }
public static string DefaultRootUrlResolver(HttpRequestMessage request) { var scheme = GetHeaderValue(request, "X-Forwarded-Proto") ?? request.RequestUri.Scheme; var host = GetHeaderValue(request, "X-Forwarded-Host") ?? request.RequestUri.Host; var port = GetHeaderValue(request, "X-Forwarded-Port") ?? request.RequestUri.Port.ToString(CultureInfo.InvariantCulture); var httpConfiguration = request.GetConfiguration(); var virtualPathRoot = httpConfiguration.VirtualPathRoot.TrimEnd('/'); return string.Format("{0}://{1}:{2}{3}", scheme, host, port, virtualPathRoot); }
internal static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, string messageDetail) { HttpError error = new HttpError(message); HttpConfiguration config = request.GetConfiguration(); if (config != null && ShouldIncludeErrorDetail(config, request)) { error.Add(MessageDetailKey, messageDetail); } return(request.CreateErrorResponse(statusCode, error)); }
private async Task<HttpResponseMessage> HandleOptionsRequestAsync(HttpRequestMessage request) { var apis = GetMatchingApis(request.GetConfiguration().Routes, request).ToList(); if (!apis.Any()) return await Task.FromResult(request.CreateResponse(HttpStatusCode.NotFound)); var supportedMethods = apis.Select(i => i.Method) .Distinct() .ToList(); var resp = new HttpResponseMessage(HttpStatusCode.OK); resp.Headers.Add("Access-Control-Allow-Methods", string.Join(",", supportedMethods)); var neg = request.GetConfiguration().Services.GetContentNegotiator(); var res = neg.Negotiate(typeof (IEnumerable<SimpleApiDescription>), request, request.GetConfiguration().Formatters); resp.Content = new ObjectContent(typeof(IEnumerable<SimpleApiDescription>), apis, res.Formatter); return await Task.FromResult(resp); }
public void GetConfiguration() { // Arrange _request.Properties[HttpPropertyKeys.HttpConfigurationKey] = _config; // Act HttpConfiguration afterConfig = _request.GetConfiguration(); // Assert Assert.Same(_config, afterConfig); }
/// <inheritdoc/> protected async override Task<HttpResponseMessage> SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw Error.ArgumentNull("request"); } HttpConfiguration configuration = request.GetConfiguration(); if (configuration == null) { throw Error.InvalidOperation(SRResources.RequestMustContainConfiguration); } HttpResponseMessage response = await base.SendAsync(request, cancellationToken); // Do not interfere with null responses, we want to buble it up to the top. // Do not handle 204 responses as the spec says a 204 response must not include an ETag header // unless the request's representation data was saved without any transformation applied to the body // (i.e., the resource's new representation data is identical to the representation data received in the // PUT request) and the ETag value reflects the new representation. // Even in that case returning an ETag is optional and it requires access to the original object which is // not possible with the current architecture, so if the user is interested he can set the ETag in that // case by himself on the response. if (response == null || !response.IsSuccessStatusCode || response.StatusCode == HttpStatusCode.NoContent) { return response; } ODataPath path = request.ODataProperties().Path; IEdmModel model = request.ODataProperties().Model; IEdmEntityType edmType = GetSingleEntityEntityType(path); object value = GetSingleEntityObject(response); IEdmEntityTypeReference typeReference = GetTypeReference(model, edmType, value); if (typeReference != null) { EntityInstanceContext context = CreateInstanceContext(typeReference, value); context.EdmModel = model; context.NavigationSource = path.NavigationSource; IETagHandler etagHandler = configuration.GetETagHandler(); EntityTagHeaderValue etag = CreateETag(context, etagHandler); if (etag != null) { response.Headers.ETag = etag; } } return response; }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { return base.SendAsync(request, cancellationToken) .ContinueWith(task => { var response = task.Result; var enrichers = request.GetConfiguration().GetResponseEnrichers(); return enrichers.Where(e => e.CanEnrich(response)) .Aggregate(response, (resp, enricher) => enricher.Enrich(response)); }); }
/// <summary> /// Configure the JsonFormatter to only serialize the requested properties /// </summary> /// <param name="request"></param> /// <param name="includedTypeProperties"></param> private void ConfigureFormatter(HttpRequestMessage request, Dictionary<Type, List<string>> includedTypeProperties) { var jsonFormatter = request.GetConfiguration().Formatters.JsonFormatter; var settings = jsonFormatter.SerializerSettings; settings.Formatting = Formatting.Indented; //settings.Error = delegate(object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args) //{ // logger.Error(args.ErrorContext.Error.Message); // args.ErrorContext.Handled = true; //}; settings.ContractResolver = new NHIncludingContractResolver(NHEagerFetch.sessionFactory, includedTypeProperties); }
private IEnumerable<HttpMethod> GetSupportedMethods(HttpRequestMessage request) { var routeData = request.GetRouteData() // Workaround for OWIN support ?? request.GetConfiguration().Routes.GetRouteData(request); if (routeData == null) return Enumerable.Empty<HttpMethod>(); else if (routeData.Values.ContainsKey("controller")) { var apiExplorer = request.GetConfiguration().Services.GetApiExplorer(); return apiExplorer.ApiDescriptions .Where(x => x.ActionDescriptor.ControllerDescriptor.ControllerName.Equals( routeData.Values["controller"] as string, StringComparison.OrdinalIgnoreCase)) .Select(d => d.HttpMethod) .Distinct(); } else if (routeData.Values.ContainsKey("MS_SubRoutes")) { return routeData.GetSubRoutes() .SelectMany(x => (HttpActionDescriptor[]) x.Route.DataTokens["actions"]) .SelectMany(x => x.SupportedHttpMethods).Distinct(); } else return Enumerable.Empty<HttpMethod>(); }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) throw new ArgumentNullException("request"); var formatters = request.GetConfiguration().Formatters; var contentType = request.Content.Headers.ContentType; Func<HttpResponseMessage> unsupportedMediaType = () => new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType); return contentType == null || formatters.Any(f => f.SupportedMediaTypes.Contains(contentType)) ? base.SendAsync(request, cancellationToken) : Task<HttpResponseMessage>.Factory.StartNew(unsupportedMediaType); }
public void GetConfiguration_ReturnsConfigurationFromProperty_WhenOnlyPropertyIsPresent() { // Arrange using (HttpRequestMessage request = CreateRequest()) using (HttpConfiguration expectedConfiguration = CreateConfiguration()) { request.Properties[HttpPropertyKeys.HttpConfigurationKey] = expectedConfiguration; // Act HttpConfiguration configuration = request.GetConfiguration(); // Assert Assert.Same(expectedConfiguration, configuration); } }
internal HttpVirtualPathData GenerateLinkDirectly(HttpRequestMessage request, string odataPath) { HttpConfiguration configuration = request.GetConfiguration(); if (configuration == null || !_canGenerateDirectLink) { return null; } string dataSource = request.Properties[Constants.ODataDataSource] as string; string link = CombinePathSegments(RoutePrefix, dataSource); link = CombinePathSegments(link, odataPath); link = UriEncode(link); return new HttpVirtualPathData(this, link); }
/// <summary> /// Submits the change through Entity Framework while logging any exceptions /// and produce appropriate <see cref="HttpResponseMessage"/> instances. /// </summary> /// <returns>A <see cref="Task"/> representing the operation.</returns> public static async Task<int> SubmitChangesAsync(DbContext context, HttpRequestMessage request, Func<DbUpdateConcurrencyException, object> getOriginalValue) { HttpConfiguration config = request.GetConfiguration(); ITraceWriter traceWriter = config.Services.GetTraceWriter(); try { int result = await context.SaveChangesAsync(); return result; } catch (DbEntityValidationException ex) { string validationDescription = EntityUtils.GetValidationDescription(ex); string validationError = EFResources.DomainManager_ValidationError.FormatForUser(validationDescription); traceWriter.Debug(validationError, request, LogCategories.TableControllers); HttpResponseMessage invalid = request.CreateErrorResponse(HttpStatusCode.BadRequest, validationError, ex); throw new HttpResponseException(invalid); } catch (DbUpdateConcurrencyException ex) { string conflictError = EFResources.DomainManager_ChangeConflict.FormatForUser(ex.Message); traceWriter.Info(conflictError, request, LogCategories.TableControllers); var content = getOriginalValue != null ? getOriginalValue(ex) : conflictError; HttpStatusCode statusCode = GetConflictStatusCode(request); HttpResponseMessage conflict = request.CreateResponse(statusCode, content); throw new HttpResponseException(conflict); } catch (DbUpdateException ex) { HttpResponseMessage error; Exception baseEx = ex.GetBaseException(); SqlException sqlException = baseEx as SqlException; if (sqlException != null && sqlException.Number == SqlUniqueConstraintViolationError) { string message = CommonResources.DomainManager_Conflict.FormatForUser(sqlException.Message); error = request.CreateErrorResponse(HttpStatusCode.Conflict, message); traceWriter.Info(message, request, LogCategories.TableControllers); } else { string message = EFResources.DomainManager_InvalidOperation.FormatForUser(baseEx.Message); error = request.CreateErrorResponse(HttpStatusCode.BadRequest, message); traceWriter.Error(message, request, LogCategories.TableControllers); } throw new HttpResponseException(error); } }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { MediaTypeHeaderValue contentType = request.Content.Headers.ContentType; MediaTypeFormatterCollection formatters = request.GetConfiguration().Formatters; bool hasFormetterForContentType = formatters // .Any(formatter => formatter.SupportedMediaTypes.Contains(contentType)); if (!hasFormetterForContentType) { return Task<HttpResponseMessage>.Factory // .StartNew(() => new HttpResponseMessage(HttpStatusCode.UnsupportedMediaType)); } return base.SendAsync(request, cancellationToken); }
public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, HttpConfiguration configuration) { if (request == null) { throw Error.ArgumentNull("request"); } configuration = configuration ?? request.GetConfiguration(); if (configuration == null) { throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoConfiguration); } IContentNegotiator contentNegotiator = configuration.Services.GetContentNegotiator(); if (contentNegotiator == null) { throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator).FullName); } IEnumerable <MediaTypeFormatter> formatters = configuration.Formatters; // Run content negotiation ContentNegotiationResult result = contentNegotiator.Negotiate(typeof(T), request, formatters); if (result == null) { // no result from content negotiation indicates that 406 should be sent. return(new HttpResponseMessage { StatusCode = HttpStatusCode.NotAcceptable, RequestMessage = request, }); } else { MediaTypeHeaderValue mediaType = result.MediaType; return(new HttpResponseMessage { // At this point mediaType should be a cloned value (the content negotiator is responsible for returning a new copy) Content = new ObjectContent <T>(value, result.Formatter, mediaType), StatusCode = statusCode, RequestMessage = request }); } }
protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { //根据当前请求创建CorsRequestContext CorsRequestContext context = request.CreateCorsRequestContext(); //针对非预检请求:将请求传递给消息处理管道后续部分继续处理,并得到响应 HttpResponseMessage response = null; if (!context.IsPreflight) { response = await base.SendAsync(request, cancellationToken); } //利用注册的CorsPolicyProviderFactory得到对应的CorsPolicyProvider //借助于CorsPolicyProvider得到表示CORS资源授权策略的CorsPolicy HttpConfiguration configuration = request.GetConfiguration(); CorsPolicy policy = await configuration.GetCorsPolicyProviderFactory().GetCorsPolicyProvider(request).GetCorsPolicyAsync(request, cancellationToken); //获取注册的CorsEngine //利用CorsEngine对请求实施CORS资源授权检验,并得到表示检验结果的CorsResult对象 ICorsEngine engine = configuration.GetCorsEngine(); CorsResult result = engine.EvaluatePolicy(context, policy); //针对预检请求 //如果请求通过授权检验,返回一个状态为“200, OK”的响应并添加CORS报头 //如果授权检验失败,返回一个状态为“400, Bad Request”的响应并指定授权失败原因 if (context.IsPreflight) { if (result.IsValid) { response = new HttpResponseMessage(HttpStatusCode.OK); response.AddCorsHeaders(result); } else { response = request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join(" |", result.ErrorMessages.ToArray())); } } //针对非预检请求 //CORS报头只有在通过授权检验情况下才会被添加到响应报头集合中 else if (result.IsValid) { response.AddCorsHeaders(result); } return response; }
/// <summary> /// Gets the dependency resolver scope associated with this <see cref="HttpRequestMessage"/>. /// Services which are retrieved from this scope will be released when the request is /// cleaned up by the framework. /// </summary> /// <param name="request">The HTTP request.</param> /// <returns>The <see cref="IDependencyScope"/> for the given request.</returns> public static IDependencyScope GetDependencyScope(this HttpRequestMessage request) { if (request == null) { throw Error.ArgumentNull("request"); } IDependencyScope result; if (!request.Properties.TryGetValue <IDependencyScope>(HttpPropertyKeys.DependencyScope, out result)) { result = request.GetConfiguration().DependencyResolver.BeginScope(); request.Properties[HttpPropertyKeys.DependencyScope] = result; request.RegisterForDispose(result); } return(result); }
/// <summary> /// Selects the controller to handle the request. /// </summary> /// <param name="path">The OData path of the request.</param> /// <param name="request">The incoming request.</param> /// <returns>The name of the controller.</returns> protected override string SelectControllerName(ODataPath path, HttpRequestMessage request) { var controllers = request.GetConfiguration().Services.GetHttpControllerSelector().GetControllerMapping(); foreach (var routingConvention in RoutingConventions) { var controllerName = routingConvention.SelectController(path, request); if (controllerName != null) { HttpControllerDescriptor descriptor; if (controllers.TryGetValue(controllerName, out descriptor) && descriptor != null) { return controllerName; } } } return null; }
private HttpResponseMessage CreateErrorResponse(HttpRequestMessage request, Exception ex, HttpStatusCode statusCode) { HttpConfiguration configuration = request.GetConfiguration(); HttpError error = new HttpError(ex, request.ShouldIncludeErrorDetail()); string lastId = _coreLastReferenceIdManager.GetLastReferenceId(); if (!String.IsNullOrEmpty(lastId)) error.Add("Reference", lastId); // CreateErrorResponse should never fail, even if there is no configuration associated with the request // In that case, use the default HttpConfiguration to con-neg the response media type if (configuration == null) { using (HttpConfiguration defaultConfig = new HttpConfiguration()) { return request.CreateResponse(statusCode, error, defaultConfig); } } return request.CreateResponse(statusCode, error, configuration); }
public void GetConfiguration_ReturnsConfigurationFromContext_WhenOnlyContextIsPresent() { // Arrange using (HttpRequestMessage request = CreateRequest()) using (HttpConfiguration expectedConfiguration = CreateConfiguration()) { request.SetRequestContext(new HttpRequestContext { Configuration = expectedConfiguration }); // Act HttpConfiguration configuration = request.GetConfiguration(); // Assert Assert.Same(expectedConfiguration, configuration); } }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var swaggerProvider = GetSwaggerProvider(request.GetConfiguration()); var basePath = _config.ResolveBasePath(request); var version = _config.ResolveTargetVersion(request); object resourceName; request.GetRouteData().Values.TryGetValue("resourceName", out resourceName); var content = (resourceName == null) ? ContentFor(swaggerProvider.GetListing(basePath, version)) : ContentFor(swaggerProvider.GetDeclaration(basePath, version, resourceName.ToString())); return Task.Factory.StartNew(() => new HttpResponseMessage(HttpStatusCode.OK) { Content = content }); }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var routeData = request.GetConfiguration().Routes.GetRouteData(request); if (routeData != null && routeData.Values.ContainsKey("MS_SubRoutes")) { var route = ((IHttpRouteData[])routeData.Values["MS_SubRoutes"]).First(); if (route.Values.ContainsKey("tenantid")) { string tenant = route.Values["tenantid"].ToString(); _logger.DebugFormat("Request {0} -> Tenant {1}", request.RequestUri, tenant); TenantContext.Enter(new TenantId(tenant)); } } var result = base.SendAsync(request, cancellationToken); return result; }
private static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, Func <bool, HttpError> errorCreator) { HttpConfiguration configuration = request.GetConfiguration(); HttpError error = errorCreator(request.ShouldIncludeErrorDetail()); // CreateErrorResponse should never fail, even if there is no configuration associated with the request // In that case, use the default HttpConfiguration to con-neg the response media type if (configuration == null) { using (HttpConfiguration defaultConfig = new HttpConfiguration()) { return(request.CreateResponse <HttpError>(statusCode, error, defaultConfig)); } } else { return(request.CreateResponse <HttpError>(statusCode, error, configuration)); } }
public void GetConfiguration_ReturnsConfigurationFromContext_WhenBothContextAndPropertyArePresent() { // Arrange using (HttpRequestMessage request = CreateRequest()) using (HttpConfiguration expectedConfiguration = CreateConfiguration()) using (HttpConfiguration otherConfiguration = CreateConfiguration()) { request.Properties[HttpPropertyKeys.HttpConfigurationKey] = otherConfiguration; request.SetRequestContext(new HttpRequestContext { Configuration = expectedConfiguration }); // Act HttpConfiguration configuration = request.GetConfiguration(); // Assert Assert.Same(expectedConfiguration, configuration); } }
public static HttpResponseMessage CreateODataErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, ODataError oDataError) { HttpConfiguration config = request.GetConfiguration(); if (config != null && ShouldIncludeErrorDetail(config, request)) { return(request.CreateResponse(statusCode, oDataError)); } else { return(request.CreateResponse( statusCode, new ODataError() { ErrorCode = oDataError.ErrorCode, Message = oDataError.Message, MessageLanguage = oDataError.MessageLanguage })); } }
/// <inheritdoc /> public override async Task<HttpResponseMessage> ReceiveAsync(string id, HttpRequestContext context, HttpRequestMessage request) { if (id == null) { throw new ArgumentNullException(nameof(id)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (request == null) { throw new ArgumentNullException(nameof(request)); } if (request.Method != HttpMethod.Post) { return CreateBadMethodResponse(request); } // Ensure that we use https and have a valid code parameter await EnsureValidCode(request, id); // Read the request entity body JObject jsonBody = await ReadAsJsonAsync(request); // Read the action from body JToken action; string actionAsString; if (!jsonBody.TryGetValue(EventTypeTokenName, out action)) { request.GetConfiguration().DependencyResolver.GetLogger().Error(VstsReceiverResources.Receiver_NoEventType); return request.CreateErrorResponse(HttpStatusCode.BadRequest, VstsReceiverResources.Receiver_NoEventType); } else { actionAsString = action.Value<string>(); } return await ExecuteWebHookAsync(id, context, request, new[] { actionAsString }, jsonBody); }
private async Task from_body(HttpRequestMessage request, CancellationToken cancellationToken) { var body = await request.Content.ReadAsByteArrayAsync(); var buffer = new MemoryStream(body); var formatters = request.GetConfiguration().Formatters; var reader = formatters.FindReader(typeof(ConnectionIdentity), request.Content.Headers.ContentType) ?? formatters.FormUrlEncodedFormatter; var connection_identity = await reader.ReadFromStreamAsync(typeof(ConnectionIdentity), buffer, request.Content, new DoNothingFormatterLogger(), cancellationToken) as ConnectionIdentity; update_last_seen(connection_identity); }
/// <summary> /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance /// of <see cref="ObjectContent{T}"/> as the content if a formatter can be found. If no formatter is found, this /// method returns a response with status 406 NotAcceptable. /// </summary> /// <remarks> /// This method will use the provided <paramref name="configuration"/> or it will get the /// <see cref="HttpConfiguration"/> instance associated with <paramref name="request"/>. /// </remarks> /// <typeparam name="T">The type of the value.</typeparam> /// <param name="request">The request.</param> /// <param name="statusCode">The status code of the created response.</param> /// <param name="value">The value to wrap. Can be <c>null</c>.</param> /// <param name="configuration">The configuration to use. Can be <c>null</c>.</param> /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns> public static HttpResponseMessage CreateResponse <T>( this HttpRequestMessage request, HttpStatusCode statusCode, T value, HttpConfiguration configuration ) { if (request == null) { throw Error.ArgumentNull("request"); } configuration = configuration ?? request.GetConfiguration(); if (configuration == null) { throw Error.InvalidOperation( SRResources.HttpRequestMessageExtensions_NoConfiguration ); } IContentNegotiator contentNegotiator = configuration.Services.GetContentNegotiator(); if (contentNegotiator == null) { throw Error.InvalidOperation( SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator).FullName ); } IEnumerable <MediaTypeFormatter> formatters = configuration.Formatters; return(NegotiatedContentResult <T> .Execute( statusCode, value, contentNegotiator, request, formatters )); }
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) { HttpConfiguration controllerConfig; if (_cache.TryGetValue(controllerType, out controllerConfig)) { controllerDescriptor.Configuration = controllerConfig; } else { var configMap = request.GetConfiguration().GetControllerConfigurationMap(); if (configMap != null && configMap.ContainsKey(controllerType)) { controllerDescriptor.Configuration = controllerDescriptor.Configuration.Copy(configMap[controllerType]); _cache.TryAdd(controllerType, controllerDescriptor.Configuration); } } var result = _innerActivator.Create(request, controllerDescriptor, controllerType); return result; }
public HttpResponseMessage Get(HttpRequestMessage request) { var config = request.GetConfiguration(); // The IContentNegotiator instance is registered with // the HttpConfiguration. By default, it uses an instance // of DefaultContentNegotiator. IContentNegotiator negotiator = config.Services.GetContentNegotiator(); // Negotiate takes the type, the request, and the formatters you // wish to use. By default, Web API inserts the JsonMediaTypeFormatter // and XmlMediaTypeFormatter, in that order. ContentNegotiationResult result = negotiator.Negotiate(typeof(Helpers.FILL_ME_IN), request, config.Formatters); var person = new Person { FirstName = "Ryan", LastName = "Riley" }; // Use the ContentNegotiationResult with an ObjectContent to format the object. var content = new ObjectContent<Person>(person, result.Formatter, result.MediaType); return new HttpResponseMessage { Content = content }; }
/// <summary> /// Gets the dependency resolver scope associated with this <see cref="HttpRequestMessage"/>. /// Services which are retrieved from this scope will be released when the request is /// cleaned up by the framework. /// </summary> /// <param name="request">The HTTP request.</param> /// <returns>The <see cref="IDependencyScope"/> for the given request.</returns> public static IDependencyScope GetDependencyScope(this HttpRequestMessage request) { if (request == null) { throw Error.ArgumentNull("request"); } IDependencyScope result; if (!request.Properties.TryGetValue <IDependencyScope>(HttpPropertyKeys.DependencyScope, out result)) { IDependencyResolver dependencyResolver = request.GetConfiguration().DependencyResolver; result = dependencyResolver.BeginScope(); if (result == null) { throw Error.InvalidOperation(SRResources.DependencyResolver_BeginScopeReturnsNull, dependencyResolver.GetType().Name); } request.Properties[HttpPropertyKeys.DependencyScope] = result; request.RegisterForDispose(result); } return(result); }
/// <summary> /// Sends an HTTP request to the inner handler to send to the server as an asynchronous operation. /// </summary> /// <param name="request">The HTTP request message to send to the server.</param> /// <param name="cancellationToken">A cancellation token to cancel operation.</param> /// <returns> /// Returns <see cref="T:System.Threading.Tasks.Task`1" />. The task object representing the asynchronous operation. /// </returns> protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var owinContext = request.GetOwinContext(); if (owinContext == null) return base.SendAsync(request, cancellationToken); var routes = request.GetConfiguration().Routes; if (routes == null) return base.SendAsync(request, cancellationToken); var routeData = routes.GetRouteData(request); if (routeData == null) return base.SendAsync(request, cancellationToken); var subRoutes = routeData.Values["MS_SubRoutes"] as IHttpRouteData[]; if (subRoutes == null) return base.SendAsync(request, cancellationToken); var routeTemplate = subRoutes[0].Route.RouteTemplate; owinContext.Environment.Add("metrics-net.routetemplate", routeTemplate); return base.SendAsync(request, cancellationToken); }
public void GetConfigurationThrowsOnNull() { HttpRequestMessage request = null; Assert.ThrowsArgumentNull(() => request.GetConfiguration(), "request"); }