protected virtual Task <ElasticsearchResponse <Stream> > DoAsyncRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null)
{
var tcs = new TaskCompletionSource <ElasticsearchResponse <Stream> >();
if (this.ConnectionSettings.MaximumAsyncConnections <= 0 ||
this._resourceLock == null)
{
return(this.CreateIterateTask(request, data, requestSpecificConfig, tcs));
}
var timeout = this.ConnectionSettings.Timeout;
var path = request.RequestUri.ToString();
var method = request.Method;
if (!this._resourceLock.WaitOne(timeout))
{
var m = "Could not start the operation before the timeout of " + timeout +
"ms completed while waiting for the semaphore";
var cs = ElasticsearchResponse <Stream> .CreateError(this.ConnectionSettings, new TimeoutException(m), method, path, data);
tcs.SetResult(cs);
return(tcs.Task);
}
try
{
return(this.CreateIterateTask(request, data, requestSpecificConfig, tcs));
}
finally
{
this._resourceLock.Release();
}
}
private ElasticsearchResponse <Stream> HandleWebException(byte[] data, WebException webException, string method, string path)
{
ElasticsearchResponse <Stream> cs = null;
var httpEx = webException.Response as HttpWebResponse;
if (httpEx != null)
{
cs = WebToElasticsearchResponse(data, httpEx.GetResponseStream(), httpEx, method, path);
return(cs);
}
cs = ElasticsearchResponse <Stream> .CreateError(this.ConnectionSettings, webException, method, path, data);
return(cs);
}
public async Task <ElasticsearchResponse <Stream> > DoRequestInternal(
HttpMethod method, Uri uri, byte[] data = null, IRequestConfiguration requestSpecificConfig = null)
{
ThrowIfDisposed();
try
{
var request = new HttpRequestMessage(method, uri);
if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.ContentType))
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestSpecificConfig.ContentType));
}
else if (!string.IsNullOrWhiteSpace(DefaultContentType))
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(DefaultContentType));
}
if (!string.IsNullOrEmpty(uri.UserInfo))
{
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes(uri.UserInfo)));
}
if (method != HttpMethod.Get && method != HttpMethod.Head && data != null && data.Length > 0)
{
request.Content = new ByteArrayContent(data);
if (!string.IsNullOrWhiteSpace(DefaultContentType) && request.Content != null && request.Content.Headers != null)
{
request.Content.Headers.ContentType = new MediaTypeHeaderValue(DefaultContentType);
}
}
var response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead)
.ConfigureAwait(false);
if (method == HttpMethod.Head || response.Content == null)
{
return(ElasticsearchResponse <Stream> .Create(_settings, (int)response.StatusCode, method.ToString().ToLowerInvariant(), uri.ToString(), data));
}
var responseStream = await response.Content.ReadAsStreamAsync();
return(ElasticsearchResponse <Stream> .Create(_settings, (int)response.StatusCode, method.ToString().ToLowerInvariant(), uri.ToString(), data, responseStream));
}
catch (Exception ex)
{
return(ElasticsearchResponse <Stream> .CreateError(_settings, ex, method.ToString().ToLowerInvariant(), uri.ToString(), data));
}
}
public ElasticsearchResponse <Stream> DoSyncRequest <T>(string method, Uri uri, byte[] data = null)
{
var client = new System.Net.Http.HttpClient();
HttpResponseMessage response = null;
HttpContent content = null;
if (data != null)
{
content = new ByteArrayContent(data);
}
switch (method.ToLower())
{
case "head":
response = client.SendAsync(new HttpRequestMessage(HttpMethod.Head, uri)).Result;
break;
case "delete":
response = client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, uri)
{
Content = content
}).Result;
break;
case "put":
response = client.PutAsync(uri, content).Result;
break;
case "post":
response = client.PostAsync(uri, content).Result;
break;
case "get":
response = client.GetAsync(uri).Result;
break;
}
if (response == null)
{
return(ElasticsearchResponse <Stream> .CreateError(_settings, null, method, uri.ToString(), data));
}
using (var result = response.Content.ReadAsStreamAsync().Result)
{
var cs = ElasticsearchResponse <Stream> .Create(this._settings, (int)response.StatusCode, method, uri.ToString(), data, result);
return(cs);
}
}
/// <summary>
/// Makes an async call to the specified url. Uses the timeout from the IRequestSpecifiConfig is supplied, or the global timeout from settings.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="uri">The URI.</param>
/// <param name="data">The data.</param>
/// <param name="requestSpecificConfig">The request specific configuration.</param>
/// <returns>Task<ElasticsearchResponse<Stream>>.</returns>
public async Task <ElasticsearchResponse <Stream> > DoRequest(HttpMethod method, Uri uri, byte[] data = null, IRequestConfiguration requestSpecificConfig = null)
{
ThrowIfDisposed();
try
{
var request = new HttpRequestMessage(method, uri);
AddAWSSignature(request, method, uri, data);
if (method != HttpMethod.Get && method != HttpMethod.Head && data != null && data.Length > 0)
{
request.Content = new ByteArrayContent(data);
if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.ContentType))
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestSpecificConfig.ContentType));
}
else if (!string.IsNullOrWhiteSpace(DefaultContentType))
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(DefaultContentType));
}
if (!string.IsNullOrWhiteSpace(DefaultContentType))
{
request.Content.Headers.ContentType = new MediaTypeHeaderValue(DefaultContentType);
}
}
var response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
if (method == HttpMethod.Head || response.Content == null || !response.Content.Headers.ContentLength.HasValue || response.Content.Headers.ContentLength.Value <= 0)
{
return(ElasticsearchResponse <Stream> .Create(_settings, (int)response.StatusCode, method.ToString().ToLowerInvariant(), uri.ToString(), data));
}
var responseStream = await response.Content.ReadAsStreamAsync();
return(ElasticsearchResponse <Stream> .Create(_settings, (int)response.StatusCode, method.ToString().ToLowerInvariant(), uri.ToString(), data, responseStream));
}
catch (Exception ex)
{
return(ElasticsearchResponse <Stream> .CreateError(_settings, ex, method.ToString().ToLowerInvariant(), uri.ToString(), data));
}
}
/// <summary>
/// Wraps the DoRequest to run synchronously
/// </summary>
/// <param name="method">The method.</param>
/// <param name="uri">The URI.</param>
/// <param name="data">The data.</param>
/// <param name="requestSpecificConfig">The request specific configuration.</param>
/// <returns>ElasticsearchResponse<Stream>.</returns>
public ElasticsearchResponse <Stream> DoRequestSync(HttpMethod method, Uri uri, byte[] data = null, IRequestConfiguration requestSpecificConfig = null)
{
ThrowIfDisposed();
try
{
return(this.DoRequestInternal(method, uri, data, requestSpecificConfig)
.Result);
}
catch (AggregateException ex)
{
return(ElasticsearchResponse <Stream> .CreateError(_settings, ex.Flatten(), method.ToString().ToLowerInvariant(), uri.ToString(), data));
}
catch (Exception ex)
{
return(ElasticsearchResponse <Stream> .CreateError(_settings, ex, method.ToString().ToLowerInvariant(), uri.ToString(), data));
}
}
public void Iterate <T>(HttpWebRequest request, byte[] data, IEnumerable <Task> asyncIterator, TaskCompletionSource <ElasticsearchResponse <T> > tcs)
{
var enumerator = asyncIterator.GetEnumerator();
Action <Task> recursiveBody = null;
recursiveBody = completedTask =>
{
if (completedTask != null && completedTask.IsFaulted)
{
//none of the individual steps in _AsyncSteps run in parallel for 1 request
//as this would be impossible we can assume Aggregate Exception.InnerException
var exception = completedTask.Exception.InnerException;
//cleanly exit from exceptions in stages if the exception is a webexception
if (exception is WebException)
{
var path = request.RequestUri.ToString();
var method = request.Method;
var response = ElasticsearchResponse <T> .CreateError(this._ConnectionSettings, exception, method, path, data);
tcs.SetResult(response);
}
else
{
tcs.TrySetException(exception);
}
enumerator.Dispose();
}
else if (enumerator.MoveNext())
{
enumerator.Current.ContinueWith(recursiveBody);
}
else
{
enumerator.Dispose();
}
};
recursiveBody(null);
}
private ElasticsearchResponse <Stream> Execute(RestRequest restRequest, object requestConfiguration)
{
//RestResponse result = GetClient().execute(restRequest);
//
var method = Enum.GetName(typeof(Method), restRequest.Method);
var uri = restRequest.Uri;
var path = uri.ToString();
var baseUri = new Uri(string.Format("{0}://{1}:{2}", uri.Scheme, uri.Host, uri.Port));
var requestData = restRequest.Body;
if (!this._resourceLock.WaitOne(this._timeout))
{
var m = "Could not start the thrift operation before the timeout of " + this._timeout + "ms completed while waiting for the semaphore";
return(ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, new TimeoutException(m), method, path, requestData));
}
try
{
ConcurrentQueue <Rest.Client> queue;
if (!this._clients.TryGetValue(baseUri, out queue))
{
var m = string.Format("Could dequeue a thrift client from internal socket pool of size {0}", this._poolSize);
var status = ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, new Exception(m), method, path, requestData);
return(status);
}
Rest.Client client;
if (!queue.TryDequeue(out client))
{
var m = string.Format("Could dequeue a thrift client from internal socket pool of size {0}", this._poolSize);
var status = ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, new Exception(m), method, path, requestData);
return(status);
}
try
{
if (!client.InputProtocol.Transport.IsOpen)
{
client.InputProtocol.Transport.Open();
}
var result = client.execute(restRequest);
if (result.Status == Status.OK || result.Status == Status.CREATED || result.Status == Status.ACCEPTED)
{
var response = ElasticsearchResponse <Stream> .Create(
this._connectionSettings, (int)result.Status, method, path, requestData, new MemoryStream(result.Body ?? new byte[0]));
return(response);
}
else
{
var response = ElasticsearchResponse <Stream> .Create(
this._connectionSettings, (int)result.Status, method, path, requestData, new MemoryStream(result.Body ?? new byte[0]));
return(response);
}
}
catch (SocketException)
{
client.InputProtocol.Transport.Close();
throw;
}
catch (IOException)
{
client.InputProtocol.Transport.Close();
throw;
}
catch (TTransportException)
{
client.InputProtocol.Transport.Close();
throw;
}
finally
{
//make sure we make the client available again.
if (queue != null && client != null)
{
queue.Enqueue(client);
}
}
}
catch (Exception e)
{
return(ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, e, method, path, requestData));
}
finally
{
this._resourceLock.Release();
}
}
private ElasticsearchResponse <Stream> Execute(RestRequest restRequest, object requestConfiguration)
{
var method = Enum.GetName(typeof(Method), restRequest.Method);
var requestData = restRequest.Body;
var uri = restRequest.Uri;
var path = uri.ToString();
if (this._resourceLock != null && !this._resourceLock.WaitOne(this._timeout))
{
var m = "Could not start the thrift operation before the timeout of " + this._timeout + "ms completed while waiting for the semaphore";
return(ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, new TimeoutException(m), method, path, requestData));
}
try
{
var baseUri = this.GetBaseBaseUri(uri);
string errorMessage;
var client = this.GetClientForUri(baseUri, out errorMessage);
if (client == null)
{
return(ElasticsearchResponse <Stream> .CreateError(
this._connectionSettings, new Exception(errorMessage), method, path, requestData));
}
try
{
if (!client.InputProtocol.Transport.IsOpen)
{
client.InputProtocol.Transport.Open();
}
var result = client.execute(restRequest);
if (result.Status == Status.OK || result.Status == Status.CREATED || result.Status == Status.ACCEPTED)
{
var response = ElasticsearchResponse <Stream> .Create(
this._connectionSettings, (int)result.Status, method, path, requestData, new MemoryStream(result.Body ?? new byte[0]));
return(response);
}
else
{
var response = ElasticsearchResponse <Stream> .Create(
this._connectionSettings, (int)result.Status, method, path, requestData, new MemoryStream(result.Body ?? new byte[0]));
return(response);
}
}
catch (SocketException)
{
client.InputProtocol.Transport.Close();
throw;
}
catch (IOException)
{
client.InputProtocol.Transport.Close();
throw;
}
catch (TTransportException)
{
client.InputProtocol.Transport.Close();
throw;
}
finally
{
this.EnqueueClient(baseUri, client);
}
}
catch (Exception e)
{
return(ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, e, method, path, requestData));
}
finally
{
if (this._resourceLock != null)
{
this._resourceLock.Release();
}
}
}
private ElasticsearchResponse <Stream> Execute(RestRequest restRequest, object deserializationState)
{
//RestResponse result = GetClient().execute(restRequest);
//
var method = Enum.GetName(typeof(Method), restRequest.Method);
var path = restRequest.Uri.ToString();
var requestData = restRequest.Body;
if (!this._resourceLock.WaitOne(this._timeout))
{
var m = "Could not start the thrift operation before the timeout of " + this._timeout + "ms completed while waiting for the semaphore";
return(ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, new TimeoutException(m), method, path, requestData));
}
try
{
Rest.Client client = null;
if (!this._clients.TryDequeue(out client))
{
var m = string.Format("Could dequeue a thrift client from internal socket pool of size {0}", this._poolSize);
var status = ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, new Exception(m), method, path, requestData);
return(status);
}
try
{
if (!client.InputProtocol.Transport.IsOpen)
{
client.InputProtocol.Transport.Open();
}
var result = client.execute(restRequest);
if (result.Status == Status.OK || result.Status == Status.CREATED || result.Status == Status.ACCEPTED)
{
var response = ElasticsearchResponse <Stream> .Create(
this._connectionSettings, (int)result.Status, method, path, requestData, new MemoryStream(result.Body));
return(response);
}
else
{
var response = ElasticsearchResponse <Stream> .Create(
this._connectionSettings, (int)result.Status, method, path, requestData, new MemoryStream(result.Body));
return(response);
}
}
catch (SocketException)
{
client.InputProtocol.Transport.Close();
throw;
}
catch (IOException)
{
client.InputProtocol.Transport.Close();
throw;
}
finally
{
//make sure we make the client available again.
this._clients.Enqueue(client);
}
}
catch (Exception e)
{
return(ElasticsearchResponse <Stream> .CreateError(this._connectionSettings, e, method, path, requestData));
}
finally
{
this._resourceLock.Release();
}
}
