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");
}
