tk/Ocelot
1
0
Fork 0
mirror of https://github.com/nsnail/Ocelot.git synced 2025-04-22 14:02:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

Initial mapping of request

Browse Source
This commit is contained in:
Philip Wood 2017-04-18 10:13:10 +01:00
parent eeb8f691c7
commit da922c0e04
4 changed files with 137 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/Ocelot/Middleware/OcelotMiddleware.cs
View File

@ -3,7 +3,6 @@ using System.Net.Http;
using Ocelot.DownstreamRouteFinder;
using Ocelot.Errors;
using Ocelot.Infrastructure.RequestData;
using Ocelot.Values;
namespace Ocelot.Middleware
{
@ -19,96 +18,33 @@ namespace Ocelot.Middleware
public string MiddlwareName { get; }
public bool PipelineError
{
get
{
var response = _requestScopedDataRepository.Get<bool>("OcelotMiddlewareError");
return response.Data;
}
}
public bool PipelineError => _requestScopedDataRepository.Get<bool>("OcelotMiddlewareError").Data;
public List<Error> PipelineErrors
{
get
{
var response = _requestScopedDataRepository.Get<List<Error>>("OcelotMiddlewareErrors");
return response.Data;
}
}
public List<Error> PipelineErrors => _requestScopedDataRepository.Get<List<Error>>("OcelotMiddlewareErrors").Data;
public DownstreamRoute DownstreamRoute
{
get
{
var downstreamRoute = _requestScopedDataRepository.Get<DownstreamRoute>("DownstreamRoute");
return downstreamRoute.Data;
}
}
public DownstreamRoute DownstreamRoute => _requestScopedDataRepository.Get<DownstreamRoute>("DownstreamRoute").Data;
//public string DownstreamUrl
//{
// get
// {
// var downstreamUrl = _requestScopedDataRepository.Get<string>("DownstreamUrl");
// return downstreamUrl.Data;
// }
//}
public Request.Request Request => _requestScopedDataRepository.Get<Request.Request>("Request").Data;
public HttpRequestMessage DownstreamRequest => _requestScopedDataRepository.Get<HttpRequestMessage>("DownstreamRequest").Data;
public Request.Request Request
{
get
{
var request = _requestScopedDataRepository.Get<Request.Request>("Request");
return request.Data;
}
}
public HttpResponseMessage HttpResponseMessage
{
get
{
var request = _requestScopedDataRepository.Get<HttpResponseMessage>("HttpResponseMessage");
return request.Data;
}
}
//public HostAndPort HostAndPort
//{
// get
// {
// var hostAndPort = _requestScopedDataRepository.Get<HostAndPort>("HostAndPort");
// return hostAndPort.Data;
// }
//}
//public void SetHostAndPortForThisRequest(HostAndPort hostAndPort)
//{
// _requestScopedDataRepository.Add("HostAndPort", hostAndPort);
//}
public void SetDownstreamRequest(HttpRequestMessage request)
{
_requestScopedDataRepository.Add("DownstreamRequest", request);
}
public HttpResponseMessage HttpResponseMessage => _requestScopedDataRepository.Get<HttpResponseMessage>("HttpResponseMessage").Data;
public void SetDownstreamRouteForThisRequest(DownstreamRoute downstreamRoute)
{
_requestScopedDataRepository.Add("DownstreamRoute", downstreamRoute);
}
//public void SetDownstreamUrlForThisRequest(string downstreamUrl)
//{
// _requestScopedDataRepository.Add("DownstreamUrl", downstreamUrl);
//}
public void SetUpstreamRequestForThisRequest(Request.Request request)
{
_requestScopedDataRepository.Add("Request", request);
}
public void SetDownstreamRequest(HttpRequestMessage request)
{
_requestScopedDataRepository.Add("DownstreamRequest", request);
}
public void SetHttpResponseMessageThisRequest(HttpResponseMessage responseMessage)
{
_requestScopedDataRepository.Add("HttpResponseMessage", responseMessage);

2
src/Ocelot/Middleware/OcelotMiddlewareExtensions.cs
View File

@ -72,7 +72,7 @@ namespace Ocelot.Middleware
builder.UseRateLimiting();
// Now we can look for the requestId
builder.UseRequestIdMiddleware();
builder.UseRequestIdMiddleware(); //obsolete?
// Allow pre authentication logic. The idea being people might want to run something custom before what is built in.
builder.UseIfNotNull(middlewareConfiguration.PreAuthenticationMiddleware);

128
src/Ocelot/Request/Builder/RequestBuilder.cs
View File

@ -25,12 +25,16 @@
// private bool _isQos;
// private IQoSProvider _qoSProvider;
// ---- sets Method
// public RequestBuilder WithHttpMethod(string httpMethod)
// {
// _method = new HttpMethod(httpMethod);
// return this;
// }
// ---- sets RequestUri
// public RequestBuilder WithDownstreamUrl(string downstreamUrl)
// {
// _downstreamUrl = downstreamUrl;
@ -43,6 +47,14 @@
// return this;
// }
// private Uri CreateUri()
// {
// var uri = new Uri(string.Format("{0}{1}", _downstreamUrl, _queryString.ToUriComponent()));
// return uri;
// }
// ---- Content and ContentType
// public RequestBuilder WithContent(Stream content)
// {
// _content = content;
@ -55,56 +67,6 @@
// return this;
// }
// public RequestBuilder WithHeaders(IHeaderDictionary headers)
// {
// _headers = headers;
// return this;
// }
// public RequestBuilder WithRequestId(RequestId.RequestId requestId)
// {
// _requestId = requestId;
// return this;
// }
// public RequestBuilder WithIsQos(bool isqos)
// {
// _isQos = isqos;
// return this;
// }
// public RequestBuilder WithQos(IQoSProvider qoSProvider)
// {
// _qoSProvider = qoSProvider;
// return this;
// }
// public async Task<Request> Build()
// {
// var uri = CreateUri();
// var httpRequestMessage = new HttpRequestMessage(_method, uri);
// await AddContentToRequest(httpRequestMessage);
// AddContentTypeToRequest(httpRequestMessage);
// AddHeadersToRequest(httpRequestMessage);
// if (ShouldAddRequestId(_requestId, httpRequestMessage.Headers))
// {
// AddRequestIdHeader(_requestId, httpRequestMessage);
// }
// return new Request(httpRequestMessage,_isQos, _qoSProvider);
// }
// private Uri CreateUri()
// {
// var uri = new Uri(string.Format("{0}{1}", _downstreamUrl, _queryString.ToUriComponent()));
// return uri;
// }
// private async Task AddContentToRequest(HttpRequestMessage httpRequestMessage)
// {
// if (_content != null)
@ -113,6 +75,18 @@
// }
// }
// private async Task<byte[]> ToByteArray(Stream stream)
// {
// using (stream)
// {
// using (var memStream = new MemoryStream())
// {
// await stream.CopyToAsync(memStream);
// return memStream.ToArray();
// }
// }
// }
// private void AddContentTypeToRequest(HttpRequestMessage httpRequestMessage)
// {
// if (!string.IsNullOrEmpty(_contentType))
@ -122,6 +96,14 @@
// }
// }
// ---- Headers
// public RequestBuilder WithHeaders(IHeaderDictionary headers)
// {
// _headers = headers;
// return this;
// }
// private void AddHeadersToRequest(HttpRequestMessage httpRequestMessage)
// {
// if (_headers != null)
@ -144,6 +126,14 @@
// return !_unsupportedHeaders.Contains(header.Key.ToLower());
// }
// ---- Request ID
// public RequestBuilder WithRequestId(RequestId.RequestId requestId)
// {
// _requestId = requestId;
// return this;
// }
// private void AddRequestIdHeader(RequestId.RequestId requestId, HttpRequestMessage httpRequestMessage)
// {
// httpRequestMessage.Headers.Add(requestId.RequestIdKey, requestId.RequestIdValue);
@ -162,16 +152,40 @@
// && !RequestIdInHeaders(requestId, headers);
// }
// private async Task<byte[]> ToByteArray(Stream stream)
// ---- QoS
// public RequestBuilder WithIsQos(bool isqos)
// {
// using (stream)
// _isQos = isqos;
// return this;
// }
// public RequestBuilder WithQos(IQoSProvider qoSProvider)
// {
// using (var memStream = new MemoryStream())
// _qoSProvider = qoSProvider;
// return this;
// }
// ----
// public async Task<Request> Build()
// {
// await stream.CopyToAsync(memStream);
// return memStream.ToArray();
// }
// }
// var uri = CreateUri();
// var httpRequestMessage = new HttpRequestMessage(_method, uri);
// await AddContentToRequest(httpRequestMessage);
// AddContentTypeToRequest(httpRequestMessage);
// AddHeadersToRequest(httpRequestMessage);
// if (ShouldAddRequestId(_requestId, httpRequestMessage.Headers))
// {
// AddRequestIdHeader(_requestId, httpRequestMessage);
// }
// return new Request(httpRequestMessage,_isQos, _qoSProvider);
// }
// }
//}

61
src/Ocelot/Request/Mapper.cs
View File

@ -1,4 +1,10 @@
using System.IO;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.Extensions.Primitives;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
@ -6,21 +12,57 @@ namespace Ocelot.Request
{
public class Mapper
{
public async Task<HttpRequestMessage> Map(Microsoft.AspNetCore.Http.HttpRequest request)
private readonly string[] _unsupportedHeaders = { "host" };
public async Task<HttpRequestMessage> Map(HttpRequest request)
{
var requestMessage = new HttpRequestMessage()
{
Content = new ByteArrayContent(await ToByteArray(request.Body)),
//Headers = request.Headers,
//Method = request.Method,
//Properties = request.P,
//RequestUri = request.,
Content = await MapContent(request),
Method = MapMethod(request),
RequestUri = MapUri(request),
//Properties = null
//Version = null
};
MapHeaders(request, requestMessage);
return requestMessage;
}
private async Task<HttpContent> MapContent(HttpRequest request)
{
if (request.Body == null)
{
return null;
}
return new ByteArrayContent(await ToByteArray(request.Body));
}
private HttpMethod MapMethod(HttpRequest request)
{
return new HttpMethod(request.Method);
}
private Uri MapUri(HttpRequest request)
{
return new Uri(request.GetEncodedUrl());
}
private void MapHeaders(HttpRequest request, HttpRequestMessage requestMessage)
{
foreach (var header in request.Headers)
{
//todo get rid of if..
if (IsSupportedHeader(header))
{
requestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray());
}
}
}
private async Task<byte[]> ToByteArray(Stream stream)
{
using (stream)
@ -32,6 +74,11 @@ namespace Ocelot.Request
}
}
}
private bool IsSupportedHeader(KeyValuePair<string, StringValues> header)
{
return !_unsupportedHeaders.Contains(header.Key.ToLower());
}
}
}