private async Task <HttpResponseMessage> PrivateMakeRequestAsync(
TimeSpan timeout,
HttpCompletionOption completionOption,
HttpMethod method,
string path,
IQueryString queryString,
IDictionary <string, string> headers,
IRequestContent data,
CancellationToken cancellationToken)
{
// If there is a timeout, we turn it into a cancellation token. At the same time, we need to link to the caller's
// cancellation token. To avoid leaking objects, we must then also dispose of the CancellationTokenSource. To keep
// code flow simple, we treat it as re-entering the same method with a different CancellationToken and no timeout.
if (timeout != s_InfiniteTimeout)
{
using (var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
{
timeoutTokenSource.CancelAfter(timeout);
// We must await here because we need to dispose of the CTS only after the work has been completed.
return(await PrivateMakeRequestAsync(s_InfiniteTimeout, completionOption, method, path, queryString, headers, data, timeoutTokenSource.Token).ConfigureAwait(false));
}
}
var request = PrepareRequest(method, path, queryString, headers, data);
return(await _client.SendAsync(request, completionOption, cancellationToken).ConfigureAwait(false));
}
private async Task <HttpResponseMessage> PrivateMakeRequestAsync(
TimeSpan timeout,
HttpCompletionOption completionOption,
HttpMethod method,
string path,
IQueryString queryString,
IDictionary <string, string> headers,
IRequestContent data,
CancellationToken cancellationToken)
{
var request = PrepareRequest(method, path, queryString, headers, data);
if (timeout != s_InfiniteTimeout)
{
using (var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
{
timeoutTokenSource.CancelAfter(timeout);
return(await _client.SendAsync(request, completionOption, timeoutTokenSource.Token).ConfigureAwait(false));
}
}
var tcs = new TaskCompletionSource <HttpResponseMessage>();
using (cancellationToken.Register(() => tcs.SetCanceled()))
{
return(await await Task.WhenAny(tcs.Task, _client.SendAsync(request, completionOption, cancellationToken)).ConfigureAwait(false));
}
}
internal async Task<DockerApiResponse> MakeRequestAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, TimeSpan? timeout, CancellationToken cancellationToken)
{
HttpResponseMessage response = await this.MakeRequestInnerAsync(null, HttpCompletionOption.ResponseContentRead, method, path, queryString, null, data, cancellationToken);
string body = await response.Content.ReadAsStringAsync();
HandleIfErrorResponse(response.StatusCode, body, errorHandlers);
return new DockerApiResponse(response.StatusCode, body);
}
public RestRequest(HttpMethod method, FormattableString url, IReadOnlyDictionary <string, object> queryStringParameters, IRequestContent content, RestRequestOptions options)
{
_tcs = new TaskCompletionSource <HttpResponseMessage>();
_url = url;
_method = method;
_queryStringParameters = queryStringParameters;
_content = content;
Options = options?.Clone();
}
internal Task <Stream> MakeRequestForStreamAsync(
IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers,
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
CancellationToken token)
{
return(MakeRequestForStreamAsync(errorHandlers, method, path, queryString, body, null, token));
}
internal Task <DockerApiResponse> MakeRequestAsync(
IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers,
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
IDictionary <string, string> headers,
CancellationToken token)
{
return(MakeRequestAsync(errorHandlers, method, path, queryString, body, headers, this.DefaultTimeout, token));
}
internal Task <WriteClosableStream> MakeRequestForHijackedStreamAsync(
IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers,
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
IDictionary <string, string> headers,
CancellationToken cancellationToken)
{
return(MakeRequestForHijackedStreamAsync(errorHandlers, method, path, queryString, body, headers, s_InfiniteTimeout, cancellationToken));
}
internal async Task <HttpResponseMessage> MakeRequestForRawResponseAsync(
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
IDictionary <string, string> headers,
CancellationToken token)
{
var response = await PrivateMakeRequestAsync(s_InfiniteTimeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, body, token).ConfigureAwait(false);
return(response);
}
internal override HttpContent Content(IRequestContent requestContent)
{
var xmlMessage = Serialize(requestContent);
var messageContent = new StringContent(xmlMessage);
var boundary = Guid.NewGuid().ToString();
var mediaTypeHeaderValue = new MediaTypeHeaderValue(DigipostVersion.V7);
mediaTypeHeaderValue.Parameters.Add(new NameValueWithParametersHeaderValue("boundary", boundary));
messageContent.Headers.ContentType = mediaTypeHeaderValue;
return(messageContent);
}
private void InitializeRequestXmlContent(IRequestContent requestContent)
{
if (requestContent == null)
{
return;
}
var document = new XmlDocument();
var serialized = Serialize(requestContent);
document.LoadXml(serialized);
RequestContent = document;
}
protected virtual string GetSignOrigin(IRequestContent content)
{
var originBuilder = new StringBuilder();
foreach (var paramater in content.Paramaters.OrderBy(x => x.Key))
{
if (paramater.Key.ToLower() == "sign")
{
continue;
}
originBuilder.Append($"{paramater.Key}={paramater.Value}&");
}
return(originBuilder.ToString().TrimEnd('&'));
}
public async Task <T> MakeRequestJsonAsync <T>(
HttpMethod method,
string path,
String queryString = null,
IRequestContent body = null,
Action <HttpRequestHeader> headersConfigure = null,
TimeSpan?timeout = null,
CancellationToken?token = null,
IEnumerable <RestResponseErrorHandlingDelegate> errorHandlers = null)
{
var response = await this.MakeRequestAsync(method, path, queryString, body, headersConfigure, timeout, token, errorHandlers);
return(this.JsonSerializer.DeserializeObject <T>(response.Body));
}
internal async Task <Stream> MakeRequestForStreamAsync(
IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers,
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
IDictionary <string, string> headers,
TimeSpan timeout,
CancellationToken token)
{
var response = await PrivateMakeRequestAsync(timeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, body, token).ConfigureAwait(false);
await HandleIfErrorResponseAsync(response.StatusCode, response, errorHandlers);
return(await response.Content.ReadAsStreamAsync().ConfigureAwait(false));
}
public async Task <Stream> MakeRequestForStreamAsync(
HttpMethod method,
string path,
String queryString = null,
IRequestContent body = null,
Action <HttpRequestHeader> headersConfigure = null,
TimeSpan?timeout = null,
CancellationToken?token = null,
IEnumerable <RestResponseErrorHandlingDelegate> errorHandlers = null)
{
var response = await this.MakeRequestCoreAsync(method, path, queryString, body, timeout, token, HttpCompletionOption.ResponseHeadersRead, headersConfigure).ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
return(await response.Content.ReadAsStreamAsync().ConfigureAwait(false));
}
private async Task <HttpResponseMessage> MakeRequestCoreAsync(
HttpMethod method,
string path,
String queryString = null,
IRequestContent data = null,
TimeSpan?timeout = null,
CancellationToken?cancellationToken = null,
HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead,
Action <HttpRequestHeader> headersConfigure = null)
{
var request = PrepareRequest(method, path, queryString, headersConfigure, data);
CancellationToken token;
if (timeout != InfiniteTimeout)
{
token = cancellationToken ?? CancellationToken.None;
var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
timeoutTokenSource.CancelAfter(timeout ?? this.Configuration.Timeout);
token = timeoutTokenSource.Token;
}
try
{
var result = await _client.SendAsync(request, completionOption, token);
return(result);
}
catch (OperationCanceledException cex)
{
String body = null;
if (data != null)
{
body = data.GetContent()?.ReadAsStringAsync()?.GetAwaiter().GetResult();
}
throw new SchubertRestTimeoutException($@"在 {(timeout ?? this.Configuration.Timeout).TotalSeconds.ToString()} 秒内没有收到服务端的 HTTP 响应（uri: {request.RequestUri?.ToString().IfNullOrWhiteSpace("null")}, data:{body.IfNullOrWhiteSpace("null")}）调用的响应。", cex);
}
catch (Exception ex)
{
String body = null;
if (data != null)
{
body = data.GetContent()?.ReadAsStringAsync()?.GetAwaiter().GetResult();
}
throw new SchubertRestException(HttpStatusCode.BadRequest, $@"发送 HTTP 请求生错误（uri: {request.RequestUri?.ToString().IfNullOrWhiteSpace("null")}, data:{body.IfNullOrWhiteSpace("null")}）发生错误。", ex);
}
}
internal override HttpContent Content(IRequestContent requestContent)
{
var message = requestContent as IMessage;
var boundary = Guid.NewGuid().ToString();
var multipartFormDataContent = new MultipartFormDataContent(boundary);
var mediaTypeHeaderValue = new MediaTypeHeaderValue("multipart/vnd.digipost-v7+xml");
mediaTypeHeaderValue.Parameters.Add(new NameValueWithParametersHeaderValue("boundary", boundary));
multipartFormDataContent.Headers.ContentType = mediaTypeHeaderValue;
AddBodyToContent(message, multipartFormDataContent);
AddPrimaryDocumentToContent(message, multipartFormDataContent);
AddAttachmentsToContent(message, multipartFormDataContent);
return(multipartFormDataContent);
}
public string Sign(IRequestContent content)
{
if (content.SignType != "RSA" && content.SignType != "RSA2")
{
throw new PaymentArgumentException(GateWay.Name, "sign_type", $"不支持的sign_type:{content.SignType}");
}
if (content.Encoding == null)
{
throw new PaymentArgumentException(GateWay.Name, "charset", "编码格式错误");
}
if (!(GateWay.MerchantConfigure is AlipayMerchantConfigure merchantConfigure))
{
throw new PaymentException(GateWay.Name, "商户信息错误");
}
return(SecurityUtiity.RSA(GetSignOrigin(content), merchantConfigure.PrivateKey, content.Encoding.BodyName, content.SignType, false));
}
private Task <HttpResponseMessage> PrivateMakeRequestAsync(
TimeSpan timeout,
HttpCompletionOption completionOption,
HttpMethod method,
string path,
IQueryString queryString,
IDictionary <string, string> headers,
IRequestContent data,
CancellationToken cancellationToken)
{
var request = PrepareRequest(method, path, queryString, headers, data);
if (timeout != s_InfiniteTimeout)
{
var timeoutTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
timeoutTokenSource.CancelAfter(timeout);
cancellationToken = timeoutTokenSource.Token;
}
return(_client.SendAsync(request, completionOption, cancellationToken));
}
internal async Task <WriteClosableStream> MakeRequestForHijackedStreamAsync(
IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers,
HttpMethod method,
string path,
IQueryString queryString,
IRequestContent body,
IDictionary <string, string> headers,
TimeSpan timeout,
CancellationToken cancellationToken)
{
var response = await PrivateMakeRequestAsync(timeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, body, cancellationToken).ConfigureAwait(false);
await HandleIfErrorResponseAsync(response.StatusCode, response, errorHandlers);
var content = response.Content as HttpConnectionResponseContent;
if (content == null)
{
throw new NotSupportedException("message handler does not support hijacked streams");
}
return(content.HijackStream());
}
public async Task <WriteClosableStream> MakeRequestForHijackedStreamAsync(
HttpMethod method,
string path,
String queryString = null,
IRequestContent body = null,
Action <HttpRequestHeader> headersConfigure = null,
TimeSpan?timeout = null,
CancellationToken?cancellationToken = null,
IEnumerable <RestResponseErrorHandlingDelegate> errorHandlers = null)
{
var response = await MakeRequestCoreAsync(method, path, queryString, body, timeout, cancellationToken, HttpCompletionOption.ResponseHeadersRead, headersConfigure).ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
var content = response.Content as HttpConnectionResponseContent;
if (content == null)
{
throw new NotSupportedException("message handler does not support hijacked streams");
}
return(content.HijackStream());
}
internal async Task <DockerApiStreamedResponse> MakeRequestForStreamedResponseAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(TimeSpan.FromMilliseconds(Timeout.Infinite), HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, data, cancellationToken);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
Stream body = await response.Content.ReadAsStreamAsync();
return(new DockerApiStreamedResponse(response.StatusCode, body, response.Headers));
}
internal async Task <Stream> MakeRequestForStreamAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(InfiniteTimeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, data, cancellationToken).ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
return(await response.Content.ReadAsStreamAsync().ConfigureAwait(false));
}
protected HttpRequestMessage PrepareRequest(HttpMethod method, string path, String queryString, Action <HttpRequestHeader> headerConfigure, IRequestContent data)
{
if (string.IsNullOrEmpty("path"))
{
throw new ArgumentNullException(nameof(path));
}
var request = new HttpRequestMessage(method, RestUtility.BuildUri(this.EndpointBaseUri, this._requestedApiVersion, path, queryString));
request.Headers.TryAddWithoutValidation("User-Agent", UserAgent);
foreach (var header in this.Configuration.DefaultHeaders)
{
request.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
headerConfigure?.Invoke(request.Headers);
if (data != null)
{
var requestContent = data.GetContent(); // make the call only once.
request.Content = requestContent;
}
return(request);
}
private Task<HttpResponseMessage> MakeRequestInnerAsync(TimeSpan? requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
if (requestTimeout.HasValue)
{
if (requestTimeout.Value != InfiniteTimeout)
{
cancellationToken = CreateTimeoutToken(cancellationToken, requestTimeout.Value);
}
}
else
{
cancellationToken = CreateTimeoutToken(cancellationToken, _defaultTimeout);
}
return _client.SendAsync(request, completionOption, cancellationToken);
}
protected DigipostAction(IRequestContent requestContent)
{
InitializeRequestXmlContent(requestContent);
}
public RestRequest(HttpMethod method, FormattableString url, IRequestContent content, RestRequestOptions options) : this(method, url, null, content, options)
{
}
internal Task<DockerApiResponse> MakeRequestAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data)
{
return MakeRequestAsync(errorHandlers, method, path, queryString, data, null, CancellationToken.None);
}
internal Task<Stream> MakeRequestForStreamAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, CancellationToken cancellationToken)
{
return MakeRequestForStreamAsync(errorHandlers, method, path, queryString, null, data, cancellationToken);
}
internal async Task<Stream> MakeRequestForStreamAsync(IEnumerable<ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(TimeSpan.FromMilliseconds(Timeout.Infinite), HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, data, cancellationToken);
HandleIfErrorResponse(response.StatusCode, null, errorHandlers);
return await response.Content.ReadAsStreamAsync();
}
private async Task<HttpResponseMessage> MakeRequestInnerAsync(TimeSpan? requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpClient client = this.GetHttpClient();
if (requestTimeout.HasValue)
{
client.Timeout = requestTimeout.Value;
}
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
return await client.SendAsync(request, completionOption, cancellationToken);
}
internal async Task <DockerApiResponse> MakeRequestAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data)
{
var response = await MakeRequestInnerAsync(null, HttpCompletionOption.ResponseContentRead, method, path, queryString, headers, data, default(CancellationToken)).ConfigureAwait(false);
var body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, body, errorHandlers);
return(new DockerApiResponse(response.StatusCode, body));
}
private Task <HttpResponseMessage> MakeRequestInnerAsync(TimeSpan?requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
if (requestTimeout.HasValue)
{
if (requestTimeout.Value != InfiniteTimeout)
{
cancellationToken = CreateTimeoutToken(cancellationToken, requestTimeout.Value);
}
}
else
{
cancellationToken = CreateTimeoutToken(cancellationToken, _defaultTimeout);
}
return(_client.SendAsync(request, completionOption, cancellationToken));
}
internal HttpRequestMessage PrepareRequest(HttpMethod method, string path, IQueryString queryString, IDictionary<string, string> headers, IRequestContent data)
{
if (string.IsNullOrEmpty("path"))
{
throw new ArgumentNullException("path");
}
HttpRequestMessage request = new HttpRequestMessage(method, HttpUtility.BuildUri(this.Configuration.EndpointBaseUri, this.RequestedApiVersion, path, queryString));
request.Headers.Add("User-Agent", UserAgent);
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
if (data != null)
{
HttpContent requestContent = data.GetContent(); // make the call only once.
request.Content = requestContent;
}
return request;
}
internal HttpRequestMessage PrepareRequest(HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data)
{
if (string.IsNullOrEmpty("path"))
{
throw new ArgumentNullException("path");
}
HttpRequestMessage request = new HttpRequestMessage(method, HttpUtility.BuildUri(Configuration.EndpointBaseUri, RequestedApiVersion, path, queryString));
request.Headers.Add("User-Agent", UserAgent);
if (headers != null)
{
foreach (var header in headers)
{
request.Headers.Add(header.Key, header.Value);
}
}
if (data != null)
{
HttpContent requestContent = data.GetContent(); // make the call only once.
request.Content = requestContent;
}
return(request);
}
internal Task <DockerApiStreamedResponse> MakeRequestForStreamedResponseAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, CancellationToken cancellationToken)
{
return(MakeRequestForStreamedResponseAsync(errorHandlers, method, path, queryString, null, data, cancellationToken));
}
internal async Task <DockerApiResponse> MakeRequestAsync(IEnumerable <ApiResponseErrorHandlingDelegate> errorHandlers, HttpMethod method, string path, IQueryString queryString, IRequestContent data, TimeSpan?timeout, CancellationToken cancellationToken)
{
HttpResponseMessage response = await MakeRequestInnerAsync(null, HttpCompletionOption.ResponseContentRead, method, path, queryString, null, data, cancellationToken).ConfigureAwait(false);
string body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
HandleIfErrorResponse(response.StatusCode, body, errorHandlers);
return(new DockerApiResponse(response.StatusCode, body));
}
private async Task <HttpResponseMessage> MakeRequestInnerAsync(TimeSpan?requestTimeout, HttpCompletionOption completionOption, HttpMethod method, string path, IQueryString queryString, IDictionary <string, string> headers, IRequestContent data, CancellationToken cancellationToken)
{
HttpClient client = this.GetHttpClient();
if (requestTimeout.HasValue)
{
client.Timeout = requestTimeout.Value;
}
HttpRequestMessage request = PrepareRequest(method, path, queryString, headers, data);
return(await client.SendAsync(request, completionOption, cancellationToken));
}
