ripping out flurl...sorry flurl

src/Ocelot.Library/Infrastructure/HttpClient/HttpClientWrapper.cs

@@ -0,0 +1,210 @@
+namespace Ocelot.Library.Infrastructure.HttpClient
+{
+    using System;
+    using System.IO;
+    using System.Net.Http;
+    using System.Net.Http.Headers;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    public class HttpClientWrapper : IHttpClient
+    {
+        private readonly HttpClient _httpClient;
+
+        public HttpClientWrapper(HttpClient httpClient)
+        {
+            _httpClient = httpClient;
+        }
+
+        public void Dispose()
+        {
+            _httpClient.Dispose();
+        }
+
+        public Uri BaseAddress
+        {
+            get { return _httpClient.BaseAddress; }
+            set { _httpClient.BaseAddress = value; }
+        }
+
+        public HttpRequestHeaders DefaultRequestHeaders
+        {
+            get { return _httpClient.DefaultRequestHeaders; }
+        }
+
+        public long MaxResponseContentBufferSize
+        {
+            get { return _httpClient.MaxResponseContentBufferSize; }
+            set { _httpClient.MaxResponseContentBufferSize = value; }
+        }
+
+        public TimeSpan Timeout
+        {
+            get { return _httpClient.Timeout; }
+            set { _httpClient.Timeout = value; }
+        }
+
+        public void CancelPendingRequests()
+        {
+            _httpClient.CancelPendingRequests();
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(string requestUri)
+        {
+            return await _httpClient.DeleteAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(Uri requestUri)
+        {
+            return await _httpClient.DeleteAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(Uri requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.DeleteAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(string requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.DeleteAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri)
+        {
+            return await _httpClient.GetAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri)
+        {
+            return await _httpClient.GetAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+        {
+            return await _httpClient.GetAsync(requestUri, completionOption, cancellationToken);
+        }
+
+        public async Task<byte[]> GetByteArrayAsync(string requestUri)
+        {
+            return await _httpClient.GetByteArrayAsync(requestUri);
+        }
+
+        public async Task<byte[]> GetByteArrayAsync(Uri requestUri)
+        {
+            return await _httpClient.GetByteArrayAsync(requestUri);
+        }
+
+        public async Task<Stream> GetStreamAsync(string requestUri)
+        {
+            return await _httpClient.GetStreamAsync(requestUri);
+        }
+
+        public async Task<Stream> GetStreamAsync(Uri requestUri)
+        {
+            return await _httpClient.GetStreamAsync(requestUri);
+        }
+
+        public async Task<string> GetStringAsync(string requestUri)
+        {
+            return await _httpClient.GetStringAsync(requestUri);
+        }
+
+        public async Task<string> GetStringAsync(Uri requestUri)
+        {
+            return await _httpClient.GetStringAsync(requestUri);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content)
+        {
+            return await _httpClient.PostAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content)
+        {
+            return await _httpClient.PostAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PostAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PostAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content)
+        {
+            return await _httpClient.PutAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content)
+        {
+            return await _httpClient.PutAsync(requestUri, content);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PutAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken)
+        {
+            return await _httpClient.PutAsync(requestUri, content, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request)
+        {
+            return await _httpClient.SendAsync(request);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption)
+        {
+            return await _httpClient.SendAsync(request, completionOption);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            return await _httpClient.SendAsync(request, cancellationToken);
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+        {
+            return await _httpClient.SendAsync(request, completionOption, cancellationToken);
+        }
+
+        public void Dispose(bool disposing)
+        {
+            if (!disposing)
+            {
+                _httpClient.Dispose();
+            }
+        }
+    }
+}

src/Ocelot.Library/Infrastructure/HttpClient/IHttpClient.cs

@@ -0,0 +1,49 @@
+namespace Ocelot.Library.Infrastructure.HttpClient
+{
+    using System;
+    using System.IO;
+    using System.Net.Http;
+    using System.Net.Http.Headers;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    public interface IHttpClient
+    {
+        Uri BaseAddress { get; set; }
+        HttpRequestHeaders DefaultRequestHeaders { get; }
+        long MaxResponseContentBufferSize { get; set; }
+        TimeSpan Timeout { get; set; }
+        void CancelPendingRequests();
+        Task<HttpResponseMessage> DeleteAsync(string requestUri);
+        Task<HttpResponseMessage> DeleteAsync(Uri requestUri);
+        Task<HttpResponseMessage> DeleteAsync(Uri requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> DeleteAsync(string requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(string requestUri);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri);
+        Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption);
+        Task<HttpResponseMessage> GetAsync(string requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken);
+        Task<byte[]> GetByteArrayAsync(string requestUri);
+        Task<byte[]> GetByteArrayAsync(Uri requestUri);
+        Task<Stream> GetStreamAsync(string requestUri);
+        Task<Stream> GetStreamAsync(Uri requestUri);
+        Task<string> GetStringAsync(string requestUri);
+        Task<string> GetStringAsync(Uri requestUri);
+        Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content);
+        Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content);
+        Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content);
+        Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content);
+        Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);
+        Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken);
+        void Dispose(bool disposing);
+    }
+}

src/Ocelot.Library/Infrastructure/RequestBuilder/IRequestBuilder.cs

@@ -0,0 +1,17 @@
+namespace Ocelot.Library.Infrastructure.RequestBuilder
+{
+    using System.IO;
+    using System.Net.Http;
+    using Microsoft.AspNetCore.Http;
+
+    public interface IRequestBuilder
+    {
+        HttpRequestMessage Build(string httpMethod,
+            string downstreamUrl,
+            Stream content,
+            IHeaderDictionary headers,
+            IRequestCookieCollection cookies,
+            IQueryCollection queryString,
+            string contentType);
+    }
+}

src/Ocelot.Library/Infrastructure/RequestBuilder/RequestBuilder.cs

@@ -0,0 +1,49 @@
+namespace Ocelot.Library.Infrastructure.RequestBuilder
+{
+    using System;
+    using System.IO;
+    using System.Net.Http;
+    using System.Net.Http.Headers;
+    using Microsoft.AspNetCore.Http;
+
+    public class RequestBuilder : IRequestBuilder
+    {
+        public HttpRequestMessage Build(string httpMethod, string downstreamUrl, Stream content, IHeaderDictionary headers,
+            IRequestCookieCollection cookies, IQueryCollection queryString, string contentType)
+        {
+            var method = new HttpMethod(httpMethod);
+
+            var uri = new Uri(downstreamUrl + queryString);
+
+            var httpRequestMessage = new HttpRequestMessage(method, uri)
+            {
+                Content = new StreamContent(content),
+            };
+
+            if (!string.IsNullOrEmpty(contentType))
+            {
+                var splitCt = contentType.Split(';');
+                var cT = splitCt[0];
+                httpRequestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(cT);
+            }
+
+            //todo get rid of if
+            if (headers != null)
+            {
+                headers.Remove("Content-Type");
+            }
+
+            //todo get rid of if
+            if (headers != null)
+            {
+                foreach (var header in headers)
+                {
+                    httpRequestMessage.Headers.Add(header.Key, header.Value.ToArray());
+                }
+            }
+
+            return httpRequestMessage;
+
+        }
+    }
+}

src/Ocelot.Library/Infrastructure/Requester/HttpClientHttpRequester.cs

@@ -1,53 +1,22 @@
-using System.IO;
-using System.Net.Http;
-using System.Net.Http.Headers;
+using System.Net.Http;
 using System.Threading.Tasks;
-using Flurl;
-using Flurl.Http;
-using Microsoft.AspNetCore.Http;
 
 namespace Ocelot.Library.Infrastructure.Requester
 {
+    using HttpClient;
+
     public class HttpClientHttpRequester : IHttpRequester
     {
-        public async Task<HttpResponseMessage> GetResponse(
-            string httpMethod, 
-            string downstreamUrl, 
-            Stream content,
-            IHeaderDictionary headers,
-            IRequestCookieCollection cookies,
-            IQueryCollection queryString,
-            string contentType)
+        private readonly IHttpClient _httpClient;
+
+        public HttpClientHttpRequester(IHttpClient httpClient)
         {
-            var method = new HttpMethod(httpMethod);
-            var streamContent = new StreamContent(content);
+            _httpClient = httpClient;
+        }
 
-            if (!string.IsNullOrEmpty(contentType))
-            {
-                var splitCt = contentType.Split(';');
-                var cT = splitCt[0];
-                streamContent.Headers.ContentType = new MediaTypeHeaderValue(cT);
-            }
-
-            if (headers != null)
-            {
-                headers.Remove("Content-Type");
-            }
-
-            if (content.Length > 0)
-            {
-                return await downstreamUrl
-                .SetQueryParams(queryString)
-                .WithCookies(cookies)
-                .WithHeaders(headers)
-                .SendAsync(method, streamContent);
-            }
-
-            return await downstreamUrl
-                .SetQueryParams(queryString)
-                .WithHeaders(headers)
-                .WithCookies(cookies)
-                .SendAsync(method, streamContent);
+        public async Task<HttpResponseMessage> GetResponse(HttpRequestMessage httpRequestMessage)
+        {
+            return await _httpClient.SendAsync(httpRequestMessage);
         }
     }
 }

src/Ocelot.Library/Infrastructure/Requester/IHttpRequester.cs

@@ -1,20 +1,10 @@
-using System.IO;
-using System.Net.Http;
+using System.Net.Http;
 using System.Threading.Tasks;
-using Flurl.Http;
-using Microsoft.AspNetCore.Http;
 
 namespace Ocelot.Library.Infrastructure.Requester
 {
     public interface IHttpRequester
     {
-        Task<HttpResponseMessage> GetResponse(
-            string httpMethod, 
-            string downstreamUrl, 
-            Stream content, 
-            IHeaderDictionary headers, 
-            IRequestCookieCollection cookies,
-            IQueryCollection queryString,
-            string contentType);
+        Task<HttpResponseMessage> GetResponse(HttpRequestMessage httpRequestMessage);
     }
 }

src/Ocelot.Library/Middleware/HttpRequesterMiddleware.cs

@@ -6,22 +6,27 @@ using Ocelot.Library.Infrastructure.Responder;
 
 namespace Ocelot.Library.Middleware
 {
+    using Infrastructure.RequestBuilder;
+
     public class HttpRequesterMiddleware
     {
         private readonly RequestDelegate _next;
         private readonly IHttpRequester _requester;
         private readonly IHttpResponder _responder;
         private readonly IScopedRequestDataRepository _scopedRequestDataRepository;
+        private readonly IRequestBuilder _requestBuilder;
 
         public HttpRequesterMiddleware(RequestDelegate next, 
             IHttpRequester requester, 
             IHttpResponder responder,
-            IScopedRequestDataRepository scopedRequestDataRepository)
+            IScopedRequestDataRepository scopedRequestDataRepository, 
+            IRequestBuilder requestBuilder)
         {
             _next = next;
             _requester = requester;
             _responder = responder;
             _scopedRequestDataRepository = scopedRequestDataRepository;
+            _requestBuilder = requestBuilder;
         }
 
         public async Task Invoke(HttpContext context)
@@ -34,9 +39,12 @@ namespace Ocelot.Library.Middleware
                 return;
             }
 
+            var request = _requestBuilder
+              .Build(context.Request.Method, downstreamUrl.Data, context.Request.Body,
+              context.Request.Headers, context.Request.Cookies, context.Request.Query, context.Request.ContentType);
+
             var response = await _requester
-                .GetResponse(context.Request.Method, downstreamUrl.Data, context.Request.Body, 
-                context.Request.Headers, context.Request.Cookies, context.Request.Query, context.Request.ContentType);
+                .GetResponse(request);
 
             await _responder.CreateResponse(context, response);
 

src/Ocelot.Library/project.json

@@ -1,4 +1,4 @@
-{
+{
     "version": "1.0.0-*",
 
     "dependencies": {
@@ -17,8 +17,7 @@
         "Microsoft.Extensions.Logging.Debug": "1.0.0",
         "Microsoft.Extensions.Options.ConfigurationExtensions": "1.0.0",
         "Microsoft.AspNetCore.Http": "1.0.0",
-        "YamlDotNet": "3.9.0",
-        "Flurl.Http": "1.0.1"
+        "YamlDotNet": "3.9.0"
     },
 
     "frameworks": {

src/Ocelot/Startup.cs

@@ -12,7 +12,10 @@ using Ocelot.Library.Middleware;
 
 namespace Ocelot
 {
+    using System.Net.Http;
     using Library.Infrastructure.Configuration;
+    using Library.Infrastructure.HttpClient;
+    using Library.Infrastructure.RequestBuilder;
     using Library.Infrastructure.UrlMatcher;
     using Library.Infrastructure.UrlTemplateReplacer;
 
@@ -44,6 +47,9 @@ namespace Ocelot
             services.AddSingleton<IDownstreamRouteFinder, DownstreamRouteFinder>();
             services.AddSingleton<IHttpRequester, HttpClientHttpRequester>();
             services.AddSingleton<IHttpResponder, HttpContextResponder>();
+            services.AddTransient<HttpClient>();
+            services.AddTransient<IHttpClient, HttpClientWrapper>();
+            services.AddSingleton<IRequestBuilder, RequestBuilder>();
 
             // see this for why we register this as singleton http://stackoverflow.com/questions/37371264/invalidoperationexception-unable-to-resolve-service-for-type-microsoft-aspnetc
             services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();