private long GetExpectedRequestLength(IHeaderCollection incomingHeaders)
{
if (incomingHeaders == null)
{
return(0);
}
var headersDict = incomingHeaders.ToDictionary(x => x.Name);
if (!headersDict.ContainsKey("Content-Length"))
{
return(0);
}
var headerValue =
headersDict["Content-Length"];
if (headerValue == null)
{
return(0);
}
long contentLength;
if (!long.TryParse(headerValue.HeaderValue, NumberStyles.Any, CultureInfo.InvariantCulture, out contentLength))
{
return(0);
}
return(contentLength);
}
public static string ContentType(this IHeaderCollection headers)
{
if (headers == null)
{
return(null);
}
return(headers["content-type"]);
}
protected IResponseResult Post(
string url,
IQueryString queryString = null,
IHeaderCollection headers = null,
IRequestBody body = null)
{
return(this.restHandler.ExecuteRequest(HttpMethod.Post, url, queryString, headers, body));
}
internal static string GetHeaderValue(IHeaderCollection headers, string name)
{
if (headers[name] != null)
{
return(headers[name].HeaderValue);
}
return(String.Empty);
}
/// <summary>
/// Unwrap into an existing NameValueCollection
/// </summary>
public static void Unwrap(this NameValueCollection output, IHeaderCollection input)
{
output.Clear(); // TODO: check this makes sense?
foreach (var key in input.AllKeys)
{
output.Add(key, input[key]);
}
}
public IResponseResult ExecuteRequest(
HttpMethod method,
string url,
IHeaderCollection headers = null,
IRequestBody body = null)
{
return(this.restHandler.ExecuteRequest(method, url, headers, body));
}
public async Task <IResponseResult> ExecuteRequestAsync(
HttpMethod method,
string url,
IHeaderCollection headers = null,
IRequestBody body = null)
{
return(await this.restHandler.ExecuteRequestAsync(method, url, headers, body));
}
public IResponseResult <TResult> ExecuteRequest <TResult>(
HttpMethod method,
string url,
IHeaderCollection headers = null,
IRequestBody body = null)
{
return(this.ExecuteRequestAsync <TResult>(method, url, headers, body).ConfigureAwait(false).GetAwaiter().GetResult());
}
protected async ValueTask <IResponseResult <TResult> > PostAsync <TResult>(
string url,
IQueryString queryString = null,
IHeaderCollection headers = null,
IRequestBody body = null)
{
return(await this.restHandler.ExecuteRequestAsync <TResult>(HttpMethod.Post, url, queryString, headers, body));
}
public async Task <IResponseResult <TResult> > ExecuteRequestAsync <TResult>(
HttpMethod method,
string baseUrl,
IQueryString queryString = null,
IHeaderCollection headers = null,
IRequestBody body = null)
{
return(await this.restHandler.ExecuteRequestAsync <TResult>(method, baseUrl, queryString, headers, body));
}
/// <summary>
/// Unwrap headers to a WebHeaderCollection
/// </summary>
public static WebHeaderCollection Unwrap(this IHeaderCollection input)
{
var output = new WebHeaderCollection();
foreach (var key in input.AllKeys)
{
output.Add(key, input[key]);
}
return(output);
}
private static Dictionary <string, string> MapHeadersToDict(IHeaderCollection requestHeaders)
{
var heads = new Dictionary <string, string>();
foreach (var key in requestHeaders.AllKeys)
{
heads.Add(key, requestHeaders[key]);
}
return(heads);
}
protected JObject RenderHeaders(IHeaderCollection headers)
{
var obj = new JObject();
foreach (var header in headers)
{
obj.Add(header.Key, header.Value);
}
return(obj);
}
public IHeaderCollection AddHeader(IHeaderCollection collection)
{
IHeaderCollection headers = this;
foreach (var pair in collection)
{
headers = this.AddHeader(pair.Key, pair.Value);
}
return(headers);
}
private IDictionary<string, IEnumerable<string>> ConvertToNancyHeaders(IHeaderCollection headers)
{
Dictionary<string, IEnumerable<string>> dict = new Dictionary<string, IEnumerable<string>>();
foreach (var header in headers)
{
if (dict.ContainsKey(header.Name))
((List<string>)dict[header.Name]).Add(header.HeaderValue);
else if (string.Equals(header.Name, "cookie", StringComparison.CurrentCultureIgnoreCase) == false)
dict.Add(header.Name, new List<string> { header.HeaderValue });
}
return dict;
}
public IHeaderCollection Add(IHeaderCollection collection)
{
IHeaderCollection headers = this;
var dictionary = collection.ToDictionary();
foreach (var pair in dictionary)
{
headers = this.Add(pair.Key, pair.Value);
}
return(headers);
}
public async Task <IResponseResult <TResult> > ExecuteRequestAsync <TResult>(
HttpMethod method,
string url,
IHeaderCollection headers = null,
IRequestBody body = null)
{
var restSharpMethod = method.ConvertToRestSharpMethod();
var request = new RestRequest(url, restSharpMethod)
{
RequestFormat = body.ConvertToRestSharpDataFormat()
};
if (body != null)
{
if (body.Type == BodyTypes.Xml)
{
request.AddXmlBody(body.Payload);
}
else
{
request.AddJsonBody(body.Payload);
}
}
if (headers != null)
{
foreach (var header in headers.ToDictionary())
{
request.AddHeader(header.Key, header.Value?.ToString() ?? "");
}
}
var response = await this.Client.ExecuteAsync <TResult>(request);
if (response.IsSuccessful)
{
return(new ResponseResult <TResult>(response.StatusCode)
{
Json = response.Content,
RawData = response.RawBytes,
Data = response.Data
});
}
else
{
return(new ResponseResult <TResult>(response.StatusCode)
{
Message = response.Content,
Json = response.Content,
RawData = response.RawBytes
});
}
}
private static void CopyHeadersToHttpListener(SerialisableResponse response, IHeaderCollection responseHeaders, string rebaseEndpoint)
{
if (response == null || response.Headers == null)
{
return;
}
response.Headers.Remove("Pragma");
response.Headers.Add("Server", new[] { string.Empty });
response.Headers.Remove("X-Powered-By");
foreach (var pair in response.Headers)
{
// Header filters:
switch (pair.Key)
{
// Skip headers we MUST NOT change:
case "Transfer-Encoding": // prevent mismatch of Chunked encoding from breaking things
case "Content-Length": // we handle this one specially
continue;
// Filter out vanity headers:
case "Pragma":
case "Server":
case "X-Powered-By":
case "Via":
continue;
}
if (pair.Key == "Location")
{
if (Uri.TryCreate(string.Join(",", pair.Value), UriKind.Absolute, out var redirectUrl))
{
if (redirectUrl.Host == "0.0.0.0") // local redirect. Pass back the *external* url
{
var newTarget = rebaseEndpoint + redirectUrl.PathAndQuery;
responseHeaders[pair.Key] = newTarget;
continue;
}
}
}
if (responseHeaders[pair.Key] == null)
{
responseHeaders[pair.Key] = string.Join(",", pair.Value);
}
else
{
responseHeaders.Add(pair.Key, string.Join(", ", pair.Value));
}
}
}
public DotvvmHttpRequest(HttpRequest originalRequest, IHttpContext httpContext,
IPathString path, IPathString pathBase, IQueryCollection query, IHeaderCollection headers,
ICookieCollection cookies)
{
OriginalRequest = originalRequest;
HttpContext = httpContext;
PathBase = pathBase;
Path = path;
Query = query;
Headers = headers;
Cookies = cookies;
Url = new Uri(OriginalRequest.GetDisplayUrl());
}
private static async Task WriteHeadersAsync(StreamWriter writer, IHeaderCollection headerCollection)
{
foreach (var header in headerCollection.Where(ShouldSendHeader).OrderBy(h => h.Name, StringComparer.Ordinal)
)
{
await writer.WriteAsync(header.Name).ConfigureAwait(false);
await writer.WriteAsync(": ").ConfigureAwait(false);
await writer.WriteAsync(header.First()).ConfigureAwait(false);
await writer.WriteLineAsync().ConfigureAwait(false);
}
}
public async Task <IResponseResult <TResult> > ExecuteRequestAsync <TResult>(
HttpMethod method,
string url,
IHeaderCollection headers = null,
IRequestBody body = null)
{
using (var httpClient = new HttpClient())
{
var request = new HttpRequestMessage(method, url);
if (headers != null)
{
foreach (var(key, value) in headers.ToDictionary())
{
request.Headers.Add(key, value.ToString());
}
}
var httpContent = body?.GetHttpContent();
if (httpContent != null)
{
request.Content = httpContent;
}
var response = await httpClient.SendAsync(request);
var rawData = await response.Content.ReadAsByteArrayAsync();
var json = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(new ResponseResult <TResult>(response.StatusCode)
{
Json = json,
RawData = rawData,
Data = Newtonsoft.Json.JsonConvert.DeserializeObject <TResult>(json),
});
}
else
{
return(new ResponseResult <TResult>(response.StatusCode, json)
{
Json = json,
RawData = rawData
});
}
}
}
public IResponseResult <TResult> ExecuteRequest <TResult>(
HttpMethod method,
string baseUrl,
IQueryString queryString = null,
IHeaderCollection headers = null,
IRequestBody body = null)
{
if (queryString != null && queryString.Any())
{
var url = $"{baseUrl}?{queryString}";
return(this.ExecuteRequest <TResult>(method, url, headers, body));
}
else
{
return(this.ExecuteRequest <TResult>(method, baseUrl, headers, body));
}
}
public HeaderCollectionPropagatorTests()
{
var headersMock = new Mock <IHeaderCollection>();
var headersDict = new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase);
headersMock.Setup(x => x.Get(It.IsAny <string>())).Returns((string x) =>
{
headersDict.TryGetValue(x, out var value);
return(value);
});
headersMock.Setup(x => x.Set(It.IsAny <string>(), It.IsAny <string>()))
.Callback((string k, string v) =>
{
headersDict.Add(k, v);
});
_headers = headersMock.Object;
}
private IDictionary <string, IEnumerable <string> > ConvertToNancyHeaders(IHeaderCollection headers)
{
Dictionary <string, IEnumerable <string> > dict = new Dictionary <string, IEnumerable <string> >();
foreach (var header in headers)
{
if (dict.ContainsKey(header.Name))
{
((List <string>)dict[header.Name]).Add(header.HeaderValue);
}
else if (string.Equals(header.Name, "cookie", StringComparison.CurrentCultureIgnoreCase) == false)
{
dict.Add(header.Name, new List <string> {
header.HeaderValue
});
}
}
return(dict);
}
/// <summary>
/// Extracts a <see cref="SpanContext"/> from the specified headers.
/// </summary>
/// <param name="headers">The headers.</param>
/// <returns>The <see cref="SpanContext"/></returns>
public static SpanContext Extract(this IHeaderCollection headers)
{
var parentIdHeader = headers.Get(HttpHeaderNames.HttpHeaderParentId);
if (parentIdHeader == null)
{
return(null);
}
var traceIdHeader = headers.Get(HttpHeaderNames.HttpHeaderTraceId);
if (traceIdHeader == null)
{
return(null);
}
ulong parentId;
try
{
parentId = Convert.ToUInt64(parentIdHeader);
}
catch (FormatException)
{
return(null);
}
ulong traceId;
try
{
traceId = Convert.ToUInt64(traceIdHeader);
}
catch (FormatException)
{
return(null);
}
return(new SpanContext(traceId, parentId));
}
internal Request(IServer server, IEndPoint endPoint, IClientConnection client, IClientConnection localClient, HttpProtocol protocol, FlexibleRequestMethod method,
RoutingTarget target, IHeaderCollection headers, ICookieCollection?cookies, IForwardingCollection?forwardings,
IRequestQuery?query, Stream?content)
{
Client = client;
LocalClient = localClient;
Server = server;
EndPoint = endPoint;
ProtocolType = protocol;
Method = method;
Target = target;
_Cookies = cookies;
_Forwardings = forwardings;
_Query = query;
Headers = headers;
Content = content;
}
public ResponseMessage(Version httpVersion, int status, IHeaderCollection headers, string reason)
{
if (httpVersion == null)
{
throw new ArgumentNullException(nameof(httpVersion));
}
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
if ((status < 100) || (status > 999))
{
throw new ArgumentOutOfRangeException(nameof(status));
}
if (string.IsNullOrWhiteSpace(reason))
{
throw new ArgumentException("Argument is null or whitespace", nameof(reason));
}
HttpVersion = httpVersion;
Headers = headers;
Reason = reason;
Status = status;
}
public RequestMessage(string method, string requestUri, Version httpVersion, IHeaderCollection headers)
{
if (string.IsNullOrWhiteSpace(method))
{
throw new ArgumentException("Argument is null or whitespace", nameof(method));
}
if (string.IsNullOrWhiteSpace(requestUri))
{
throw new ArgumentException("Argument is null or whitespace", nameof(requestUri));
}
if (httpVersion == null)
{
throw new ArgumentNullException(nameof(httpVersion));
}
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
Method = method;
RequestUri = requestUri;
HttpVersion = httpVersion;
Headers = headers;
}
protected async Task <IResponseResult <T> > ExecuteRequestAsync <T>(HttpMethod method, TUrlParams urlParams, RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
string url = this.GenerateUrl(urlParams, queryString);
return(await RestHandler.Current.ExecuteRequestAsync <T>(method, url, body, headers));
}
private long GetExpectedRequestLength(IHeaderCollection incomingHeaders)
{
if (incomingHeaders == null)
{
return 0;
}
var headersDict = incomingHeaders.ToDictionary(x => x.Name);
if (!headersDict.ContainsKey("Content-Length"))
{
return 0;
}
var headerValue =
headersDict["Content-Length"];
if (headerValue == null)
{
return 0;
}
long contentLength;
if (!long.TryParse(headerValue.HeaderValue, NumberStyles.Any, CultureInfo.InvariantCulture, out contentLength))
{
return 0;
}
return contentLength;
}
public string GenerateCurlCode(HttpMethod method, TUrlParams urlParams = default(TUrlParams), RequestBody body = null, IQueryString queryString = null, IHeaderCollection headers = null)
{
string curl = $"curl --location --request {method.ToString().ToUpper()} '{this.GenerateUrl(urlParams, queryString)}' \\" + Environment.NewLine;
if (headers != null)
{
foreach (var header in headers)
{
curl += $"--header '{header.Key}: {header.Value}' \\" + Environment.NewLine;
}
}
if (body != null)
{
curl += $"--data-raw '{body.Context}'";
}
return(curl);
}
public async Task <IResponseResult> ExecuteRequestAsync(HttpMethod method, string url, RequestBody body, IHeaderCollection headers)
{
throw new System.NotImplementedException();
}
