public void Add(List <AddHeader> addHeaders, DownstreamResponse response)
{
foreach (var add in addHeaders)
{
if (add.Value.StartsWith('{') && add.Value.EndsWith('}'))
{
var value = _placeholders.Get(add.Value);
if (value.IsError)
{
_logger.LogWarning($"Unable to add header to response {add.Key}: {add.Value}");
continue;
}
response.Headers.Add(new Header(add.Key, new List <string> {
value.Data
}));
}
else
{
response.Headers.Add(new Header(add.Key, new List <string> {
add.Value
}));
}
}
}
private void WhenICallTheMiddlewareMultipleTimes(int times, Ocelot.DownstreamRouteFinder.DownstreamRouteHolder downstreamRoute)
{
var httpContexts = new List <HttpContext>();
for (int i = 0; i < times; i++)
{
var httpContext = new DefaultHttpContext();
httpContext.Response.Body = new FakeStream();
httpContext.Items.UpsertDownstreamRoute(downstreamRoute.Route.DownstreamRoute[0]);
httpContext.Items.UpsertTemplatePlaceholderNameAndValues(downstreamRoute.TemplatePlaceholderNameAndValues);
httpContext.Items.UpsertDownstreamRoute(downstreamRoute);
var clientId = "ocelotclient1";
var request = new HttpRequestMessage(new HttpMethod("GET"), _url);
httpContext.Items.UpsertDownstreamRequest(new DownstreamRequest(request));
httpContext.Request.Headers.TryAdd("ClientId", clientId);
httpContexts.Add(httpContext);
}
foreach (var httpContext in httpContexts)
{
_middleware.Invoke(httpContext).GetAwaiter().GetResult();
var ds = httpContext.Items.DownstreamResponse();
_downstreamResponse = ds;
}
}
public async Task <DownstreamResponse> Aggregate(List <DownstreamResponse> responses)
{
var aggregatedResponseContentAsString = string.Empty;
aggregatedResponseContentAsString += "{";
var contentList = responses.Select(async e => await e.Content.ReadAsStringAsync());
for (int i = 0; i < responses.Count; i++)
{
if (i != 0)
{
aggregatedResponseContentAsString += ",";
}
aggregatedResponseContentAsString += $"\"DownStreamResponse_{(i + 1).ToString()}\" : {await contentList.ElementAtOrDefault(i)}";
}
//aggregatedResponseContentAsString += string.Join(",", contentList
// .Select(c => $" \"DownStreamResponse\" : {c.ConfigureAwait(false).GetAwaiter().GetResult()}"));
aggregatedResponseContentAsString += "}";
var aggregatedResponse = new DownstreamResponse(new StringContent(aggregatedResponseContentAsString, System.Text.Encoding.UTF8, "application/json")
, (responses.Where(s => s.StatusCode != HttpStatusCode.OK).Any() ? HttpStatusCode.InternalServerError : HttpStatusCode.OK)
, responses.FirstOrDefault().Headers, responses.FirstOrDefault().ReasonPhrase);
return(aggregatedResponse);
}
public async Task SetResponseOnHttpContext(HttpContext context, DownstreamResponse response)
{
//_removeOutputHeaders.Remove(response.Headers);
//foreach (var httpResponseHeader in response.Headers)
//{
// AddHeaderIfDoesntExist(context, httpResponseHeader);
//}
foreach (var httpResponseHeader in response.Content.Headers)
{
AddHeaderIfDoesntExist(context, new Header(httpResponseHeader.Key, httpResponseHeader.Value));
}
var content = await response.Content.ReadAsStreamAsync();
AddHeaderIfDoesntExist(context, new Header("Content-Length", new[] { content.Length.ToString() }));
context.Response.OnStarting(state =>
{
var httpContext = (HttpContext)state;
httpContext.Response.StatusCode = (int)response.StatusCode;
return(Task.CompletedTask);
}, context);
using (content)
{
if (response.StatusCode != HttpStatusCode.NotModified && context.Response.ContentLength != 0)
{
await content.CopyToAsync(context.Response.Body);
}
}
}
public async Task SetResponseOnHttpContext(HttpContext context, DownstreamResponse response)
{
_removeOutputHeaders.Remove(response.Headers);
foreach (var httpResponseHeader in response.Headers)
{
AddHeaderIfDoesntExist(context, httpResponseHeader);
}
foreach (var httpResponseHeader in response.Content.Headers)
{
AddHeaderIfDoesntExist(context, new Header(httpResponseHeader.Key, httpResponseHeader.Value));
}
var content = await response.Content.ReadAsStreamAsync();
if (response.Content.Headers.ContentLength != null)
{
AddHeaderIfDoesntExist(context, new Header("Content-Length", new [] { response.Content.Headers.ContentLength.ToString() }));
}
context.Response.StatusCode = (int)response.StatusCode;
context.Response.HttpContext.Features.Get <IHttpResponseFeature>().ReasonPhrase = response.ReasonPhrase;
using (content)
{
if (response.StatusCode != HttpStatusCode.NotModified && context.Response.ContentLength != 0)
{
await content.CopyToAsync(context.Response.Body);
}
}
}
public void should_replace_downstream_base_url_with_ocelot_base_url()
{
const string downstreamUrl = "http://downstream.com/";
var request =
new HttpRequestMessage(HttpMethod.Get, "http://test.com")
{
RequestUri = new System.Uri(downstreamUrl)
};
var response = new DownstreamResponse(new StringContent(string.Empty), HttpStatusCode.Accepted,
new List <KeyValuePair <string, IEnumerable <string> > >()
{
new KeyValuePair <string, IEnumerable <string> >("Location", new List <string> {
downstreamUrl
})
}, "");
var fAndRs = new List <HeaderFindAndReplace>
{
new HeaderFindAndReplace("Location", "{DownstreamBaseUrl}", "http://ocelot.com/", 0)
};
this.Given(x => GivenTheHttpResponse(response))
.And(x => GivenTheRequestIs(request))
.And(x => GivenTheFollowingHeaderReplacements(fAndRs))
.When(x => WhenICallTheReplacer())
.Then(x => ThenTheHeaderShouldBe("Location", "http://ocelot.com/"))
.BDDfy();
}
private static void ProcessRpcError(HttpContext context, RpcException e)
{
var content = new ApiResponse
{
ResponseCode = _statusNames.GetValueOrDefault(e.StatusCode, _defaultErrorStatus)
};
try
{
content.Errors = JsonConvert.DeserializeObject <IEnumerable <ApiError> >(e.Status.Detail).ToList();
}
catch (Exception)
{
content.Errors = new[] { new ApiError(e.Status.Detail, e.InnerException?.Message) };
}
var statusCode = _statusCodes.GetValueOrDefault(e.StatusCode, _defaultErrorCode);
context.Response.ContentType = MediaTypeNames.Application.Json;
var response = new DownstreamResponse(new GrpcHttpContent(content),
statusCode,
new List <Header>
{
new Header(HeaderNames.ContentType, new [] { MediaTypeNames.Application.Json })
},
statusCode.ToString());
context.Items.UpsertDownstreamResponse(response);
}
/// <summary>
/// Aggreaget microservices response objects
/// </summary>
/// <param name="responses"></param>
/// <returns></returns>
public Task <DownstreamResponse> Aggregate(List <DownstreamContext> responses)
{
try
{
Task <string> vehiclesContent;
Task <string> customersContent;
string vehiclesKey = responses.FirstOrDefault(r => r.DownstreamReRoute.Key.ToLower().Contains("vehicle")).DownstreamReRoute.Key;
string customerKey = responses.FirstOrDefault(r => r.DownstreamReRoute.Key.ToLower().Contains("customer")).DownstreamReRoute.Key;
vehiclesContent = responses.FirstOrDefault(r => r.DownstreamReRoute.Key.Equals(vehiclesKey)).DownstreamResponse.Content.ReadAsStringAsync();
customersContent = responses.FirstOrDefault(r => r.DownstreamReRoute.Key.Equals(customerKey)).DownstreamResponse.Content.ReadAsStringAsync();
List <ComposerModel> model = CreateComposerModel(vehiclesContent, customersContent);
var stringContent = new StringContent(JsonConvert.SerializeObject(model))
{
Headers = { ContentType = new MediaTypeHeaderValue("application/json") }
};
DownstreamResponse response =
new DownstreamResponse(stringContent, HttpStatusCode.OK,
new List <KeyValuePair <string, IEnumerable <string> > >(), "OK");
return(Task.FromResult(response));
}
catch
{
DownstreamResponse response =
new DownstreamResponse(null, HttpStatusCode.BadRequest,
new List <KeyValuePair <string, IEnumerable <string> > >(), "BadRequest");
return(Task.FromResult(response));
}
}
public async Task <DownstreamResponse> Aggregate(List <DownstreamContext> responses)
{
var responseStrings = responses.Select(response => {
return(response.DownstreamResponse.Content.ReadAsStringAsync());
}).ToList();
var resp = new StringContent($"{{\"command\": {await responseStrings[0]}, \"price\": {await responseStrings[1]}}}");
var dst = new DownstreamResponse(resp, System.Net.HttpStatusCode.OK, new List <KeyValuePair <string, IEnumerable <string> > >(), "OK");
return(dst);
}
public void should_have_content_length()
{
var httpContext = new DefaultHttpContext();
var response = new DownstreamResponse(new StringContent("test"), HttpStatusCode.OK,
new List <KeyValuePair <string, IEnumerable <string> > >());
_responder.SetResponseOnHttpContext(httpContext, response).GetAwaiter().GetResult();
var header = httpContext.Response.Headers["Content-Length"];
header.First().ShouldBe("4");
}
public void should_add_reason_phrase()
{
var httpContext = new DefaultHttpContext();
var response = new DownstreamResponse(new StringContent(""), HttpStatusCode.OK,
new List <KeyValuePair <string, IEnumerable <string> > >
{
new KeyValuePair <string, IEnumerable <string> >("test", new List <string> {
"test"
})
}, "some reason");
_responder.SetResponseOnHttpContext(httpContext, response).GetAwaiter().GetResult();
httpContext.Response.HttpContext.Features.Get <IHttpResponseFeature>().ReasonPhrase.ShouldBe(response.ReasonPhrase);
}
public async Task Invoke(HttpContext context)
{
object result = null;
var errMessage = string.Empty;
var httpStatusCode = HttpStatusCode.OK;
var buildRequest = grpcRequestBuilder.BuildRequest(context);
if (buildRequest.IsError)
{
errMessage = "bad request";
httpStatusCode = HttpStatusCode.BadRequest;
Logger.LogWarning(errMessage);
}
else
{
try
{
var channel = grpcPool.GetChannel(new GrpcServiceEndpoint(context.Request.Host.Host, context.Request.Host.Port ?? 80));
var client = new GrpcMethodDescriptorClient(channel);
result = await client.InvokeAsync(buildRequest.Data.GrpcMethod, buildRequest.Data.Headers, buildRequest.Data.RequestMessage);
}
catch (GrpcException ex)
{
httpStatusCode = HttpStatusCode.InternalServerError;
errMessage = $"rpc exception.";
Logger.LogError($"{ex.StatusCode}--{ex.Message}", ex);
}
catch (Exception ex)
{
httpStatusCode = HttpStatusCode.ServiceUnavailable;
errMessage = $"error in request grpc service.";
Logger.LogError($"{errMessage}--{context.Request.Path.Value}", ex);
}
}
OkResponse <GrpcHttpContent> httpResponse;
if (string.IsNullOrEmpty(errMessage))
{
httpResponse = new OkResponse <GrpcHttpContent>(new GrpcHttpContent(result));
}
else
{
httpResponse = new OkResponse <GrpcHttpContent>(new GrpcHttpContent(errMessage));
}
context.Response.ContentType = "application/json";
var downstreamResponse = new DownstreamResponse(httpResponse.Data, httpStatusCode, httpResponse.Data.Headers,
"OcelotGrpcHttpMiddleware");
//TODO: ???
//context.Response.Write =;
}
public void should_ignore_content_if_null()
{
var httpContext = new DefaultHttpContext();
var response = new DownstreamResponse(null, HttpStatusCode.OK,
new List <KeyValuePair <string, IEnumerable <string> > >(), "some reason");
Should.NotThrow(() =>
{
_responder
.SetResponseOnHttpContext(httpContext, response)
.GetAwaiter()
.GetResult()
;
});
}
public void should_cache_content_headers()
{
var content = new StringContent("{\"Test\": 1}")
{
Headers = { ContentType = new MediaTypeHeaderValue("application/json") }
};
var response = new DownstreamResponse(content, HttpStatusCode.OK, new List <KeyValuePair <string, IEnumerable <string> > >(), "fooreason");
this.Given(x => x.GivenResponseIsNotCached(response))
.And(x => x.GivenTheDownstreamRouteIs())
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenTheContentTypeHeaderIsCached())
.BDDfy();
}
public void should_remove_transfer_encoding_header()
{
var httpContext = new DefaultHttpContext();
var response = new DownstreamResponse(new StringContent(""), HttpStatusCode.OK,
new List <KeyValuePair <string, IEnumerable <string> > >
{
new KeyValuePair <string, IEnumerable <string> >("Transfer-Encoding", new List <string> {
"woop"
})
});
_responder.SetResponseOnHttpContext(httpContext, response).GetAwaiter().GetResult();
var header = httpContext.Response.Headers["Transfer-Encoding"];
header.ShouldBeEmpty();
}
public void should_add_header()
{
var httpContext = new DefaultHttpContext();
var response = new DownstreamResponse(new StringContent(""), HttpStatusCode.OK,
new List <KeyValuePair <string, IEnumerable <string> > >
{
new KeyValuePair <string, IEnumerable <string> >("test", new List <string> {
"test"
})
}, "some reason");
_responder.SetResponseOnHttpContext(httpContext, response).GetAwaiter().GetResult();
var header = httpContext.Response.Headers["test"];
header.First().ShouldBe("test");
}
public async Task SetErrorResponseOnContext(HttpContext context, DownstreamResponse response)
{
var content = await response.Content.ReadAsStreamAsync();
if (response.Content.Headers.ContentLength != null)
{
AddHeaderIfDoesntExist(context, new Header("Content-Length", new[] { response.Content.Headers.ContentLength.ToString() }));
}
using (content)
{
if (context.Response.ContentLength != 0)
{
await content.CopyToAsync(context.Response.Body);
}
}
}
public void should_not_replace_headers()
{
var response = new DownstreamResponse(new StringContent(string.Empty), HttpStatusCode.Accepted,
new List <KeyValuePair <string, IEnumerable <string> > >()
{
new KeyValuePair <string, IEnumerable <string> >("test", new List <string> {
"test"
})
}, "");
var fAndRs = new List <HeaderFindAndReplace>();
this.Given(x => GivenTheHttpResponse(response))
.And(x => GivenTheFollowingHeaderReplacements(fAndRs))
.When(x => WhenICallTheReplacer())
.Then(x => ThenTheHeadersAreNotReplaced())
.BDDfy();
}
public async Task <DownstreamResponse> SendRequestAsync(DownstreamRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
try
{
var response = await _httpClient.SendAsync(request);
return(await DownstreamResponse.FromHttpResponseAsync(response, request));
}
catch (Exception ex)
{
return(DownstreamResponse.FromException(ex));
}
}
private static void ProcessError(HttpContext context, Exception e)
{
var content = new GrpcHttpContent(new ApiResponse
{
ResponseCode = _defaultErrorStatus,
Errors = new[] { new ApiError(e.Message, e.InnerException?.Message) }
});
context.Response.ContentType = MediaTypeNames.Application.Json;
var response = new DownstreamResponse(content,
_defaultErrorCode,
new List <Header>
{
new Header(HeaderNames.ContentType, new [] { MediaTypeNames.Application.Json })
},
_defaultErrorCode.ToString());
context.Items.UpsertDownstreamResponse(response);
}
private static async Task <CachedResponse> CreateCachedResponse(DownstreamResponse response)
{
if (response == null)
{
return(null);
}
var statusCode = response.StatusCode;
var headers = response.Headers.ToDictionary(v => v.Key, v => v.Values);
var body = response.Content != null
? await response.Content.ReadAsStringAsync()
: null;
var contentHeaders = response.Content?.Headers.ToDictionary(v => v.Key, v => v.Value);
var cached = new CachedResponse(statusCode, headers, body, contentHeaders, response.ReasonPhrase);
return(cached);
}
public async Task <DownstreamResponse> Aggregate(List <DownstreamResponse> responses)
{
Console.WriteLine("This should be written but isn't");
//return new Task<DownstreamResponse>(() =>
//{
// return responses[0];
//});
//return responses[0];
try
{
List <Result> returnResult = new List <Result>();
foreach (var response in responses)
{
var contentString = response.Content.ReadAsStringAsync().Result;
var content = JsonConvert.DeserializeObject <Result>(contentString);
returnResult.Add(content);
}
HttpResponseMessage aaa = new HttpResponseMessage();
aaa.StatusCode = System.Net.HttpStatusCode.OK;
using (var httpClient = new HttpClient())
{
var content = new StringContent(JsonConvert.SerializeObject(returnResult), encoding: Encoding.UTF8);
HttpResponseMessage response;
var uri = new Uri("http://localhost:5557/api/CP");
ServicePoint serverPoint = ServicePointManager.FindServicePoint(uri);
HttpRequestMessage requestMessage = CreateRequestMessage(uri, HttpMethod.Post, content);
response = await httpClient.SendAsync(requestMessage);
aaa.Content = response.Content;
}
//DownstreamResponse(HttpContent content, HttpStatusCode statusCode, List<Header> headers, string reasonPhrase);
DownstreamResponse resultResponse = new DownstreamResponse(aaa);
return(resultResponse);
}
catch (Exception e)
{
throw new Exception();
}
}
public Response Replace(DownstreamResponse response, List <HeaderFindAndReplace> fAndRs, DownstreamRequest request)
{
foreach (var f in fAndRs)
{
var dict = response.Headers.ToDictionary(x => x.Key);
//if the response headers contain a matching find and replace
if (dict.TryGetValue(f.Key, out var values))
{
//check to see if it is a placeholder in the find...
var placeholderValue = _placeholders.Get(f.Find, request);
if (!placeholderValue.IsError)
{
//if it is we need to get the value of the placeholder
var replaced = values.Values.ToList()[f.Index].Replace(placeholderValue.Data, f.Replace.LastCharAsForwardSlash());
response.Headers.Remove(response.Headers.First(item => item.Key == f.Key));
response.Headers.Add(new Header(f.Key, new List <string> {
replaced
}));
}
else
{
var replaced = values.Values.ToList()[f.Index].Replace(f.Find, f.Replace);
response.Headers.Remove(response.Headers.First(item => item.Key == f.Key));
response.Headers.Add(new Header(f.Key, new List <string> {
replaced
}));
}
}
}
return(new OkResponse());
}
internal async Task <CachedResponse> CreateCachedResponse(DownstreamResponse response)
{
if (response == null)
{
return(null);
}
var statusCode = response.StatusCode;
var headers = response.Headers.ToDictionary(v => v.Key, v => v.Values);
string body = null;
if (response.Content != null)
{
var content = await response.Content.ReadAsByteArrayAsync();
body = Convert.ToBase64String(content);
}
var contentHeaders = response?.Content?.Headers.ToDictionary(v => v.Key, v => v.Value);
var cached = new CachedResponse(statusCode, headers, body, contentHeaders, response.ReasonPhrase);
return(cached);
}
private void GivenTheHttpResponseMessageIs(DownstreamResponse response)
{
_httpContext.Items.UpsertDownstreamResponse(response);
}
private void GivenResponseIsNotCached(DownstreamResponse response)
{
_downstreamContext.DownstreamResponse = response;
}
private void GivenTheHttpResponse(DownstreamResponse response)
{
_response = response;
}
private void GivenTheHttpResponseMessageIs(DownstreamResponse response)
{
_downstreamContext.DownstreamResponse = response;
}
private void SetHttpResponseMessageThisRequest(DownstreamContext context,
DownstreamResponse response)
{
context.DownstreamResponse = response;
}
private void GivenAResponseMessage()
{
_response = new DownstreamResponse(new HttpResponseMessage());
}
