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