/// <summary>
/// Adds certificates, credentials, proxies and cookies to the request
/// </summary>
/// <param name="req">Request object</param>
private void PrepareClientRequest(HttpRequestMessageWrapper req)
{
// Todo: set these properties
#if NET4
if (_connection.Certificates != null)
{
//req.AddClientCerts(_connection.Certificates);
}
#endif
if (_connection.CookieContainer != null)
{
//req.CookieContainer = _connection.CookieContainer;
}
if (_connection.Credentials != null)
{
//req.Credentials = _connection.Credentials;
}
if (_connection.Proxy != null)
{
//req.Proxy = _connection.Proxy;
}
}
/// <summary>
/// Makes an asynchronous http POST request to the specified url.
/// </summary>
/// <param name="url">The url to send the request to.</param>
/// <param name="prepareRequest">A callback that initializes the request with default values.</param>
/// <param name="postData">form url encoded data.</param>
/// <param name="isLongRunning">Indicates whether the request is long running</param>
/// <returns>A <see cref="T:Task{IResponse}"/>.</returns>
public Task<IResponse> Post(string url, Action<IRequest> prepareRequest, IDictionary<string, string> postData, bool isLongRunning)
{
return HttpHelper.PostAsync(_httpClient, url, request =>
{
//request.ConnectionGroupName = isLongRunning ? _longRunningGroup : _shortRunningGroup;
// Todo.. figure out abort
var req = new HttpRequestMessageWrapper(request, () => { });
prepareRequest(req);
PrepareClientRequest(req);
},
postData).Then(response => (IResponse)new HttpResponseMessageWrapper(response));
}
/// <summary>
/// Makes an asynchronous http POST request to the specified url.
/// </summary>
/// <param name="url">The url to send the request to.</param>
/// <param name="prepareRequest">A callback that initializes the request with default values.</param>
/// <param name="postData">form url encoded data.</param>
/// <param name="isLongRunning">Indicates whether the request is long running</param>
/// <returns>A <see cref="T:Task{IResponse}"/>.</returns>
public Task <IResponse> Post(string url, Action <IRequest> prepareRequest, IDictionary <string, string> postData, bool isLongRunning)
{
return(HttpHelper.PostAsync(_httpClient, url, request =>
{
//request.ConnectionGroupName = isLongRunning ? _longRunningGroup : _shortRunningGroup;
// Todo.. figure out abort
var req = new HttpRequestMessageWrapper(request, () => { });
prepareRequest(req);
PrepareClientRequest(req);
},
postData).Then(response => (IResponse) new HttpResponseMessageWrapper(response)));
}
/// <summary>
/// Makes an asynchronous http GET request to the specified url.
/// </summary>
/// <param name="url">The url to send the request to.</param>
/// <param name="prepareRequest">A callback that initializes the request with default values.</param>
/// <param name="isLongRunning">Indicates whether the request is long running</param>
/// <returns>A <see cref="T:Task{IResponse}"/>.</returns>
public Task<IResponse> Get(string url, Action<IRequest> prepareRequest, bool isLongRunning)
{
return HttpHelper.GetAsync(this._httpClient, url, request =>
{
// Todo: Find out where to put the connectiongroup name
//request.ConnectionGroupName = isLongRunning ? _longRunningGroup : _shortRunningGroup;
var req = new HttpRequestMessageWrapper(request, () => {});
prepareRequest(req);
PrepareClientRequest(req);
}
).Then(response => (IResponse)new HttpResponseMessageWrapper(response));
}
/// <summary>
/// Makes an asynchronous http GET request to the specified url.
/// </summary>
/// <param name="url">The url to send the request to.</param>
/// <param name="prepareRequest">A callback that initializes the request with default values.</param>
/// <param name="isLongRunning">Indicates whether the request is long running</param>
/// <returns>A <see cref="T:Task{IResponse}"/>.</returns>
public Task <IResponse> Get(string url, Action <IRequest> prepareRequest, bool isLongRunning)
{
return(HttpHelper.GetAsync(this._httpClient, url, request =>
{
// Todo: Find out where to put the connectiongroup name
//request.ConnectionGroupName = isLongRunning ? _longRunningGroup : _shortRunningGroup;
var req = new HttpRequestMessageWrapper(request, () => {});
prepareRequest(req);
PrepareClientRequest(req);
}
).Then(response => (IResponse) new HttpResponseMessageWrapper(response)));
}
public Task <IResponse> Post(string url, Action <IRequest> prepareRequest, IDictionary <string, string> postData, bool isLongRunning)
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var responseDisposer = new Disposer();
var cts = new CancellationTokenSource();
var requestMessage = new HttpRequestMessage(HttpMethod.Post, new Uri(url));
if (postData == null)
{
requestMessage.Content = new StringContent(String.Empty);
}
else
{
requestMessage.Content = new ByteArrayContent(HttpHelper.ProcessPostData(postData));
}
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
responseDisposer.Dispose();
});
prepareRequest(request);
var httpClient = GetHttpClient(isLongRunning);
return(httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cts.Token)
.Then(responseMessage =>
{
if (responseMessage.IsSuccessStatusCode)
{
responseDisposer.Set(responseMessage);
}
else
{
// Dispose the response (https://github.com/SignalR/SignalR/issues/4092)
var message = responseMessage.ToString();
responseMessage.RequestMessage.Dispose();
responseMessage.Dispose();
throw new HttpClientException(message);
}
return (IResponse) new HttpResponseMessageWrapper(responseMessage);
}));
}
public Task <IResponse> Post(string url, Action <IRequest> prepareRequest, IDictionary <string, string> postData, bool isLongRunning)
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var responseDisposer = new Disposer();
var cts = new CancellationTokenSource();
var requestMessage = new HttpRequestMessage(HttpMethod.Post, new Uri(url));
if (postData == null)
{
requestMessage.Content = new StringContent(String.Empty);
}
else
{
requestMessage.Content = new FormUrlEncodedContent(postData);
}
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
responseDisposer.Dispose();
});
prepareRequest(request);
HttpClient httpClient = GetHttpClient(isLongRunning);
return(httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cts.Token)
.Then(responseMessage =>
{
if (responseMessage.IsSuccessStatusCode)
{
responseDisposer.Set(responseMessage);
}
else
{
throw new HttpClientException(responseMessage);
}
return (IResponse) new HttpResponseMessageWrapper(responseMessage);
}));
}
public Task <IResponse> Get(string url, Action <IRequest> prepareRequest, bool isLongRunning)
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var responseDisposer = new Disposer();
var cts = new CancellationTokenSource();
var requestMessage = new HttpRequestMessage(HttpMethod.Get, new Uri(url));
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
responseDisposer.Dispose();
});
prepareRequest(request);
var httpClient = GetHttpClient(isLongRunning);
return(httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cts.Token)
.Then(responseMessage =>
{
if (responseMessage.IsSuccessStatusCode)
{
responseDisposer.Set(responseMessage);
}
else
{
// Dispose the response (https://github.com/SignalR/SignalR/issues/4092)
responseMessage.RequestMessage.Dispose();
responseMessage.Dispose();
// None of the getters on HttpResponseMessage throw ODE, so it should be safe to give the catcher of the exception
// access to the response. They may get an ODE if they try to read the body, but that's OK.
throw new HttpClientException(responseMessage);
}
return (IResponse) new HttpResponseMessageWrapper(responseMessage);
}));
}
public Task <IResponse> Post(string url, Action <IRequest> prepareRequest, IDictionary <string, string> postData, bool isLongRunning)
{
return(MainThreadDispatcher.Instance.Enqueue(async() =>
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var cts = new CancellationTokenSource();
List <IMultipartFormSection> data = new List <IMultipartFormSection>();
if (postData != null)
{
data.Add(new MultipartFormDataSection(HttpHelper.ProcessPostData(postData)));
}
using (var requestMessage = UnityWebRequest.Post(url, data))
{
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
requestMessage.Dispose();
});
requestMessage.disposeDownloadHandlerOnDispose = true;
requestMessage.downloadHandler = new DownloadHandlerBuffer();
prepareRequest(request);
await requestMessage.SendAsync(cts.Token);
return await MainThreadDispatcher.Instance.Enqueue(() =>
{
if (requestMessage.isHttpError || requestMessage.isNetworkError)
{
throw new HttpClientException(requestMessage);
}
return (IResponse) new HttpResponseMessageWrapper(requestMessage);
});
}
}).Unwrap());
}
public Task<IResponse> Get(string url, Action<IRequest> prepareRequest, bool isLongRunning)
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var responseDisposer = new Disposer();
var cts = new CancellationTokenSource();
var requestMessage = new HttpRequestMessage(HttpMethod.Get, new Uri(url));
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
responseDisposer.Dispose();
});
prepareRequest(request);
HttpClient httpClient = GetHttpClient(isLongRunning);
return httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cts.Token)
.Then(responseMessage =>
{
if (responseMessage.IsSuccessStatusCode)
{
responseDisposer.Set(responseMessage);
}
else
{
throw new HttpClientException(responseMessage);
}
return (IResponse)new HttpResponseMessageWrapper(responseMessage);
});
}
public Task <IResponse> Get(string url, Action <IRequest> prepareRequest, bool isLongRunning)
{
return(MainThreadDispatcher.Instance.Enqueue(async() =>
{
if (prepareRequest == null)
{
throw new ArgumentNullException("prepareRequest");
}
var cts = new CancellationTokenSource();
using (var requestMessage = UnityWebRequest.Get(url))
{
var request = new HttpRequestMessageWrapper(requestMessage, () =>
{
cts.Cancel();
requestMessage.Dispose();
});
requestMessage.disposeDownloadHandlerOnDispose = true;
requestMessage.downloadHandler = new DownloadHandlerBuffer();
prepareRequest(request);
await requestMessage.SendAsync(cts.Token);
return await MainThreadDispatcher.Instance.Enqueue(() =>
{
if (requestMessage.isHttpError || requestMessage.isNetworkError)
{
throw new HttpClientException(requestMessage);
}
return (IResponse) new HttpResponseMessageWrapper(requestMessage);
});
}
}).Unwrap());
}
/// <summary>
/// Adds certificates, credentials, proxies and cookies to the request
/// </summary>
/// <param name="req">Request object</param>
private void PrepareClientRequest(HttpRequestMessageWrapper req)
{
// Todo: set these properties
#if NET4
if (_connection.Certificates != null)
{
//req.AddClientCerts(_connection.Certificates);
}
#endif
if (_connection.CookieContainer != null)
{
//req.CookieContainer = _connection.CookieContainer;
}
if (_connection.Credentials != null)
{
//req.Credentials = _connection.Credentials;
}
if (_connection.Proxy != null)
{
//req.Proxy = _connection.Proxy;
}
}
