protected override Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null) { return Task.Factory.StartNew(() => { var cs = this.ReturnConnectionStatus(request, data, requestSpecificConfig); return cs; }); }
private ElasticsearchResponse<Stream> ReturnConnectionStatus(HttpWebRequest request, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { var method = request.Method; var path = request.RequestUri.ToString(); var cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, 200, method, path, data); cs.Response = new MemoryStream(_fixedResultBytes); return cs; }
public ElasticsearchResponse <Stream> GetSync(Uri uri, IRequestConnectionConfiguration deserializationState = null) { var restRequest = new RestRequest(); restRequest.Method = Method.GET; restRequest.Uri = uri; restRequest.Headers = new Dictionary <string, string>(); restRequest.Headers.Add("Content-Type", "application/json"); return(this.Execute(restRequest, deserializationState)); }
public override ElasticsearchResponse <Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestConfigurationOverrides = null) { var statusCode = _rnd.Next(1, 9) % 3 == 0 ? 503 : 200; if (uri.Port == 9202) { statusCode = 200; } return(ElasticsearchResponse <Stream> .Create(this.ConnectionSettings, statusCode, "GET", "/", null)); }
public Task <ElasticsearchResponse <Stream> > Head(Uri uri, IRequestConnectionConfiguration deserializationState = null) { var restRequest = new RestRequest(); restRequest.Method = Method.HEAD; restRequest.Uri = uri; restRequest.Headers = new Dictionary <string, string>(); restRequest.Headers.Add("Content-Type", "application/json"); return(Task.Factory.StartNew <ElasticsearchResponse <Stream> >(() => { return this.Execute(restRequest, deserializationState); })); }
public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null) { var restRequest = new RestRequest(); restRequest.Method = Method.DELETE; restRequest.Uri = uri; restRequest.Body = data; restRequest.Headers = new Dictionary<string, string>(); restRequest.Headers.Add("Content-Type", "application/json"); return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(() => { return this.Execute(restRequest, deserializationState); }); }
/// <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, IRequestConnectionConfiguration requestSpecificConfig = null) { ThrowIfDisposed(); var requestTask = DoRequest(method, uri, data, requestSpecificConfig); try { requestTask.Wait(); return requestTask.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); } }
ElasticsearchResponse <Stream> IConnection.HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig) { return(DoRequestSync(HttpMethod.Head, uri, null, requestSpecificConfig)); }
Task <ElasticsearchResponse <Stream> > IConnection.Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig) { return(DoRequest(HttpMethod.Delete, uri, null, requestSpecificConfig)); }
private ElasticsearchResponse <Stream> ReturnConnectionStatus(HttpWebRequest request, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { var method = request.Method; var path = request.RequestUri.ToString(); var cs = ElasticsearchResponse <Stream> .Create(this.ConnectionSettings, 200, method, path, data); cs.Response = new MemoryStream(_fixedResultBytes); return(cs); }
public override ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestConfigurationOverrides = null) { var statusCode = _rnd.Next(1, 9) % 3 == 0 ? 503 : 200; if (uri.Port == 9202) statusCode = 200; return ElasticsearchResponse<Stream>.Create(this.ConnectionSettings, statusCode, "GET", "/", null); }
ElasticsearchResponse<Stream> IConnection.DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { return DoRequestSync(HttpMethod.Delete, uri, data, requestSpecificConfig); }
public virtual Task <ElasticsearchResponse <Stream> > Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { var r = this.CreateHttpWebRequest(uri, "HEAD", null, requestSpecificConfig); return(this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig)); }
public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { return this.BodyRequest(uri, data, "DELETE", requestSpecificConfig); }
/// <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, IRequestConnectionConfiguration requestSpecificConfig = null) { ThrowIfDisposed(); try { var request = new HttpRequestMessage(method, uri); if (method != HttpMethod.Get && method != HttpMethod.Head && data != null && data.Length > 0) { request.Content = new ByteArrayContent(data); if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.AcceptsContentType)) { request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestSpecificConfig.AcceptsContentType)); } 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); } }
private ElasticsearchResponse<Stream> HeaderOnlyRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig) { var r = this.CreateHttpWebRequest(uri, method, null, requestSpecificConfig); return this.DoSynchronousRequest(r, requestSpecificConfig: requestSpecificConfig); }
public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { var r = this.CreateHttpWebRequest(uri, "DELETE", data, requestSpecificConfig); return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig); }
private ElasticsearchResponse<Stream> BodyRequest(Uri uri, byte[] data, string method, IRequestConnectionConfiguration requestSpecificConfig) { var r = this.CreateHttpWebRequest(uri, method, data, requestSpecificConfig); return this.DoSynchronousRequest(r, data, requestSpecificConfig); }
protected virtual ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null) { var path = request.RequestUri.ToString(); var method = request.Method; if (data != null) { using (var r = request.GetRequestStream()) { r.Write(data, 0, data.Length); } } try { //http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx //Either the stream or the response object needs to be closed but not both although it won't //throw any errors if both are closed atleast one of them has to be Closed. //Since we expose the stream we let closing the stream determining when to close the connection var response = (HttpWebResponse)request.GetResponse(); var responseStream = response.GetResponseStream(); return WebToElasticsearchResponse(data, responseStream, response, method, path); } catch (WebException webException) { return HandleWebException(data, webException, method, path); } }
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(); } }
/// <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, IRequestConnectionConfiguration requestSpecificConfig = null) { ThrowIfDisposed(); var requestTask = DoRequest(method, uri, data, requestSpecificConfig); try { requestTask.Wait(); return(requestTask.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 virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { return this.HeaderOnlyRequest(uri, "GET", requestSpecificConfig); }
protected override ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null) { return this.ReturnConnectionStatus(request, data, requestSpecificConfig); }
public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { var r = this.CreateHttpWebRequest(uri, "HEAD", null, requestSpecificConfig); return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig); }
Task<ElasticsearchResponse<Stream>> IConnection.Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { return DoRequest(HttpMethod.Put, uri, data, requestSpecificConfig); }
public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null) { var restRequest = new RestRequest(); restRequest.Method = Method.PUT; restRequest.Uri = uri; restRequest.Body = data; restRequest.Headers = new Dictionary<string, string>(); restRequest.Headers.Add("Content-Type", "application/json"); return this.Execute(restRequest, deserializationState); }
protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { //TODO append global querystring //var url = this._CreateUriString(path); var myReq = (HttpWebRequest)WebRequest.Create(uri); myReq.Accept = "application/json"; myReq.ContentType = "application/json"; if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.AcceptsContentType)) { myReq.Accept = requestSpecificConfig.AcceptsContentType; myReq.ContentType = requestSpecificConfig.AcceptsContentType; } var timeout = this.ConnectionSettings.Timeout; myReq.Timeout = timeout; // 1 minute timeout. myReq.ReadWriteTimeout = timeout; // 1 minute timeout. myReq.Method = method; //WebRequest won't send Content-Length: 0 for empty bodies //which goes against RFC's and might break i.e IIS when used as a proxy. //see: https://github.com/elasticsearch/elasticsearch-net/issues/562 var m = method.ToLowerInvariant(); if (m != "head" && m != "get" && (data == null || data.Length == 0)) myReq.ContentLength = 0; return myReq; }
public Task <ElasticsearchResponse <Stream> > Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { throw new NotImplementedException(); }
protected override ElasticsearchResponse <Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null) { return(this.ReturnConnectionStatus(request, data, requestSpecificConfig)); }
public virtual Task <ElasticsearchResponse <Stream> > Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { var r = this.CreateHttpWebRequest(uri, "DELETE", data, requestSpecificConfig); return(this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig)); }
protected override Task <ElasticsearchResponse <Stream> > DoAsyncRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null) { return(Task.Factory.StartNew(() => { var cs = this.ReturnConnectionStatus(request, data, requestSpecificConfig); return cs; })); }
protected virtual HttpWebRequest CreateHttpWebRequest(Uri uri, string method, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { var myReq = this.CreateWebRequest(uri, method, data, requestSpecificConfig); this.SetBasicAuthorizationIfNeeded(myReq); this.SetProxyIfNeeded(myReq); return(myReq); }
/// <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, IRequestConnectionConfiguration requestSpecificConfig = null) { ThrowIfDisposed(); try { var request = new HttpRequestMessage(method, uri); if (method != HttpMethod.Get && method != HttpMethod.Head && data != null && data.Length > 0) { request.Content = new ByteArrayContent(data); if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.AcceptsContentType)) { request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestSpecificConfig.AcceptsContentType)); } 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)); } }
protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { //TODO append global querystring //var url = this._CreateUriString(path); var myReq = (HttpWebRequest)WebRequest.Create(uri); myReq.Accept = "application/json"; myReq.ContentType = "application/json"; if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.AcceptsContentType)) { myReq.Accept = requestSpecificConfig.AcceptsContentType; myReq.ContentType = requestSpecificConfig.AcceptsContentType; } var timeout = this.ConnectionSettings.Timeout; myReq.Timeout = timeout; // 1 minute timeout. myReq.ReadWriteTimeout = timeout; // 1 minute timeout. myReq.Method = method; //WebRequest won't send Content-Length: 0 for empty bodies //which goes against RFC's and might break i.e IIS when used as a proxy. //see: https://github.com/elasticsearch/elasticsearch-net/issues/562 var m = method.ToLowerInvariant(); if (m != "head" && m != "get" && (data == null || data.Length == 0)) { myReq.ContentLength = 0; } return(myReq); }
Task <ElasticsearchResponse <Stream> > IConnection.Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { return(DoRequest(HttpMethod.Put, uri, data, requestSpecificConfig)); }
protected virtual ElasticsearchResponse <Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null) { var path = request.RequestUri.ToString(); var method = request.Method; if (data != null) { using (var r = request.GetRequestStream()) { r.Write(data, 0, data.Length); } } try { //http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx //Either the stream or the response object needs to be closed but not both although it won't //throw any errors if both are closed atleast one of them has to be Closed. //Since we expose the stream we let closing the stream determining when to close the connection var response = (HttpWebResponse)request.GetResponse(); var responseStream = response.GetResponseStream(); return(WebToElasticsearchResponse(data, responseStream, response, method, path)); } catch (WebException webException) { return(HandleWebException(data, webException, method, path)); } }
ElasticsearchResponse <Stream> IConnection.DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { return(DoRequestSync(HttpMethod.Delete, uri, data, requestSpecificConfig)); }
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(); } }
public ElasticsearchResponse <Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { throw new NotImplementedException(); }
public virtual Task <ElasticsearchResponse <Stream> > Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { return(DoAsyncRequest(uri)); }
public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { _uriObserver.Observe(uri); return _responseGenerator.Create(); }
public virtual Task <ElasticsearchResponse <Stream> > Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { _uriObserver.Observe(uri); return(Task.FromResult(_responseGenerator.Create())); }
ElasticsearchResponse<Stream> IConnection.HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig) { return DoRequestSync(HttpMethod.Head, uri, null, requestSpecificConfig); }
public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { _uriObserver.Observe(uri); return Task.FromResult(_responseGenerator.Create()); }
Task<ElasticsearchResponse<Stream>> IConnection.Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig) { return DoRequest(HttpMethod.Delete, uri, null, requestSpecificConfig); }
private ElasticsearchResponse <Stream> BodyRequest(Uri uri, byte[] data, string method, IRequestConnectionConfiguration requestSpecificConfig) { var r = this.CreateHttpWebRequest(uri, method, data, requestSpecificConfig); return(this.DoSynchronousRequest(r, data, requestSpecificConfig)); }
public virtual ElasticsearchResponse <Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { return(this.HeaderOnlyRequest(uri, "HEAD", requestSpecificConfig)); }
protected virtual HttpWebRequest CreateHttpWebRequest(Uri uri, string method, byte[] data, IRequestConnectionConfiguration requestSpecificConfig) { var myReq = this.CreateWebRequest(uri, method, data, requestSpecificConfig); this.SetBasicAuthorizationIfNeeded(myReq); this.SetProxyIfNeeded(myReq); return myReq; }
public virtual ElasticsearchResponse <Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { _uriObserver.Observe(uri); return(_responseGenerator.Create()); }
public virtual ElasticsearchResponse <Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null) { return(this.BodyRequest(uri, data, "DELETE", requestSpecificConfig)); }
private ElasticsearchResponse <Stream> HeaderOnlyRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig) { var r = this.CreateHttpWebRequest(uri, method, null, requestSpecificConfig); return(this.DoSynchronousRequest(r, requestSpecificConfig: requestSpecificConfig)); }
public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) { return DoAsyncRequest(uri); }