Initial mapping of request

src/Ocelot/Middleware/OcelotMiddleware.cs

@@ -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
+        public bool PipelineError => _requestScopedDataRepository.Get<bool>("OcelotMiddlewareError").Data;
-        {
-            get
-            {
-                var response = _requestScopedDataRepository.Get<bool>("OcelotMiddlewareError");
-                return response.Data;
-            }
-        }
 
-        public List<Error> PipelineErrors
+        public List<Error> PipelineErrors => _requestScopedDataRepository.Get<List<Error>>("OcelotMiddlewareErrors").Data;
-        {
-            get
-            {
-                var response = _requestScopedDataRepository.Get<List<Error>>("OcelotMiddlewareErrors");
-                return response.Data;
-            }
-        }
 
-        public DownstreamRoute DownstreamRoute
+        public DownstreamRoute DownstreamRoute => _requestScopedDataRepository.Get<DownstreamRoute>("DownstreamRoute").Data;
-        {
-            get
-            {
-                var downstreamRoute = _requestScopedDataRepository.Get<DownstreamRoute>("DownstreamRoute");
-                return downstreamRoute.Data;
-            }
-        }
 
-        //public string DownstreamUrl
+        public Request.Request Request => _requestScopedDataRepository.Get<Request.Request>("Request").Data;
-        //{
-        //    get
-        //    {
-        //        var downstreamUrl = _requestScopedDataRepository.Get<string>("DownstreamUrl");
-        //        return downstreamUrl.Data;
-        //    }
-        //}
 
         public HttpRequestMessage DownstreamRequest => _requestScopedDataRepository.Get<HttpRequestMessage>("DownstreamRequest").Data;
 
-        public Request.Request Request
+        public HttpResponseMessage HttpResponseMessage => _requestScopedDataRepository.Get<HttpResponseMessage>("HttpResponseMessage").Data;
-        {
-            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 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);

src/Ocelot/Middleware/OcelotMiddlewareExtensions.cs

@@ -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);

src/Ocelot/Request/Builder/RequestBuilder.cs

@@ -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)
+//        {
+//            _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))
 //            {
-//                using (var memStream = new MemoryStream())
+//                AddRequestIdHeader(_requestId, httpRequestMessage);
-//                {
-//                    await stream.CopyToAsync(memStream);
-//                    return memStream.ToArray();
-//                }
 //            }
+
+//            return new Request(httpRequestMessage,_isQos, _qoSProvider);
 //        }
 //    }
 //}

src/Ocelot/Request/Mapper.cs

@@ -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)),
+                Content = await MapContent(request),
-                //Headers = request.Headers,
+                Method = MapMethod(request),
-                //Method = request.Method,
+                RequestUri = MapUri(request),
-                //Properties = request.P,
+                //Properties = null
-                //RequestUri = request.,
                 //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());
+        }
     }
 }