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(); }