protected virtual Task <ConnectionStatus> DoAsyncRequest(HttpWebRequest request, string data = null)
{
var tcs = new TaskCompletionSource <ConnectionStatus>();
var timeout = this._ConnectionSettings.Timeout;
if (!this._ResourceLock.WaitOne(timeout))
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
var m = "Could not start the operation before the timeout of " + timeout +
"ms completed while waiting for the semaphore";
var cs = new ConnectionStatus(new TimeoutException(m));
tcs.SetResult(cs);
tracer.SetResult(cs);
return(tcs.Task);
}
}
try
{
return(Task.Factory.StartNew(() =>
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
this.Iterate(this._AsyncSteps(request, tcs, data), tcs);
var cs = tcs.Task.Result;
tracer.SetResult(cs);
return cs;
}
}, TaskCreationOptions.LongRunning));
}
finally
{
this._ResourceLock.Release();
}
}
protected virtual Task <ConnectionStatus> DoAsyncRequest(HttpWebRequest request, byte[] data = null)
{
var tcs = new TaskCompletionSource <ConnectionStatus>();
if (this._ConnectionSettings.MaximumAsyncConnections <= 0 ||
this._ResourceLock == null)
{
return(this.CreateIterateTask(request, data, tcs));
}
var timeout = this._ConnectionSettings.Timeout;
if (!this._ResourceLock.WaitOne(timeout))
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
var m = "Could not start the operation before the timeout of " + timeout +
"ms completed while waiting for the semaphore";
var cs = new ConnectionStatus(this._ConnectionSettings, new TimeoutException(m));
tcs.SetResult(cs);
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
return(tcs.Task);
}
}
try
{
return(this.CreateIterateTask(request, data, tcs));
}
finally
{
this._ResourceLock.Release();
}
}
public AsyncRequestOperation(HttpWebRequest request, string requestData, IConnectionSettings connectionSettings, ConnectionStatusTracer tracer)
{
m_request = request;
m_requestData = requestData;
m_connectionSettings = connectionSettings;
m_tracer = tracer;
Start();
}
protected virtual ConnectionStatus DoSynchronousRequest(HttpWebRequest request, string data = null)
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
ConnectionStatus cs = null;
if (data != null)
{
using (var r = request.GetRequestStream())
{
byte[] buffer = Encoding.UTF8.GetBytes(data);
r.Write(buffer, 0, buffer.Length);
}
}
try
{
using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = response.GetResponseStream())
using (var streamReader = new StreamReader(responseStream))
{
string result = streamReader.ReadToEnd();
cs = new ConnectionStatus(result)
{
Request = data,
RequestUrl = request.RequestUri.ToString(),
RequestMethod = request.Method
};
tracer.SetResult(cs);
return(cs);
}
}
catch (WebException webException)
{
cs = new ConnectionStatus(webException)
{
Request = data,
RequestUrl = request.RequestUri.ToString(),
RequestMethod = request.Method
};
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
return(cs);
}
}
}
protected virtual ConnectionStatus DoSynchronousRequest(HttpWebRequest request, byte[] data = null)
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
ConnectionStatus cs = null;
if (data != null)
{
using (var r = request.GetRequestStream())
{
r.Write(data, 0, data.Length);
}
}
var requestData = data.Utf8String();
try
{
using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = response.GetResponseStream())
using (var memoryStream = new MemoryStream())
{
responseStream.CopyTo(memoryStream);
cs = new ConnectionStatus(this._ConnectionSettings, memoryStream.ToArray())
{
Request = requestData,
RequestUrl = request.RequestUri.ToString(),
RequestMethod = request.Method
};
tracer.SetResult(cs);
return(cs);
}
}
catch (WebException webException)
{
cs = new ConnectionStatus(this._ConnectionSettings, webException)
{
Request = requestData,
RequestUrl = request.RequestUri.ToString(),
RequestMethod = request.Method
};
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
return(cs);
}
}
}
private IEnumerable <Task> _AsyncSteps(HttpWebRequest request, TaskCompletionSource <ConnectionStatus> tcs, byte[] data = null)
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
var timeout = this._ConnectionSettings.Timeout;
var state = new ConnectionState {
Connection = request
};
if (data != null)
{
var getRequestStream = Task.Factory.FromAsync <Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null);
//ThreadPool.RegisterWaitForSingleObject((getRequestStream as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
yield return(getRequestStream);
var requestStream = getRequestStream.Result;
try
{
var writeToRequestStream = Task.Factory.FromAsync(requestStream.BeginWrite, requestStream.EndWrite, data, 0, data.Length, state);
yield return(writeToRequestStream);
}
finally
{
requestStream.Close();
}
}
// Get the response
var getResponse = Task.Factory.FromAsync <WebResponse>(request.BeginGetResponse, request.EndGetResponse, null);
//ThreadPool.RegisterWaitForSingleObject((getResponse as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
yield return(getResponse);
// Get the response stream
using (var response = (HttpWebResponse)getResponse.Result)
using (var responseStream = response.GetResponseStream())
using (var memoryStream = new MemoryStream())
{
// Copy all data from the response stream
var buffer = new byte[BUFFER_SIZE];
while (responseStream != null)
{
var read = Task <int> .Factory.FromAsync(responseStream.BeginRead, responseStream.EndRead, buffer, 0, BUFFER_SIZE, null);
yield return(read);
if (read.Result == 0)
{
break;
}
memoryStream.Write(buffer, 0, read.Result);
}
// Decode the data and store the result
var cs = new ConnectionStatus(this._ConnectionSettings, memoryStream.ToArray())
{
Request = data.Utf8String(),
RequestUrl = request.RequestUri.ToString(),
RequestMethod = request.Method
};
tcs.TrySetResult(cs);
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
}
}
}
private IEnumerable<Task> _AsyncSteps(HttpWebRequest request, TaskCompletionSource<ElasticsearchResponse> tcs, byte[] data = null)
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
var timeout = this._ConnectionSettings.Timeout;
var state = new ConnectionState { Connection = request };
if (data != null)
{
var getRequestStream = Task.Factory.FromAsync<Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null);
//ThreadPool.RegisterWaitForSingleObject((getRequestStream as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
yield return getRequestStream;
var requestStream = getRequestStream.Result;
try
{
var writeToRequestStream = Task.Factory.FromAsync(requestStream.BeginWrite, requestStream.EndWrite, data, 0, data.Length, state);
yield return writeToRequestStream;
}
finally
{
requestStream.Close();
}
}
// Get the response
var getResponse = Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null);
//ThreadPool.RegisterWaitForSingleObject((getResponse as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
yield return getResponse;
var path = request.RequestUri.ToString();
var method = request.Method;
// Get the response stream
using (var response = (HttpWebResponse)getResponse.Result)
using (var responseStream = response.GetResponseStream())
using (var memoryStream = new MemoryStream())
{
// Copy all data from the response stream
var buffer = new byte[BUFFER_SIZE];
while (responseStream != null)
{
var read = Task<int>.Factory.FromAsync(responseStream.BeginRead, responseStream.EndRead, buffer, 0, BUFFER_SIZE, null);
yield return read;
if (read.Result == 0) break;
memoryStream.Write(buffer, 0, read.Result);
}
var cs = ElasticsearchResponse.Create(this._ConnectionSettings, (int) response.StatusCode, method, path, data, memoryStream.ToArray());
tcs.TrySetResult(cs);
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
}
}
}
protected virtual ElasticsearchResponse DoSynchronousRequest(HttpWebRequest request, byte[] data = null)
{
var path = request.RequestUri.ToString();
var method = request.Method;
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
ElasticsearchResponse cs = null;
if (data != null)
{
using (var r = request.GetRequestStream())
{
r.Write(data, 0, data.Length);
}
}
try
{
using (var response = (HttpWebResponse)request.GetResponse())
using (var responseStream = response.GetResponseStream())
using (var memoryStream = new MemoryStream())
{
responseStream.CopyTo(memoryStream);
cs = ElasticsearchResponse.Create(this._ConnectionSettings, (int) response.StatusCode, method, path, data,
memoryStream.ToArray());
tracer.SetResult(cs);
return cs;
}
}
catch (WebException webException)
{
cs = ElasticsearchResponse.CreateError(this._ConnectionSettings, webException, method, path, data);
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
return cs;
}
}
}
protected virtual Task<ElasticsearchResponse> DoAsyncRequest(HttpWebRequest request, byte[] data = null)
{
var tcs = new TaskCompletionSource<ElasticsearchResponse>();
if (this._ConnectionSettings.MaximumAsyncConnections <= 0
|| this._ResourceLock == null)
return this.CreateIterateTask(request, data, tcs);
var timeout = this._ConnectionSettings.Timeout;
var path = request.RequestUri.ToString();
var method = request.Method;
if (!this._ResourceLock.WaitOne(timeout))
{
using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
{
var m = "Could not start the operation before the timeout of " + timeout +
"ms completed while waiting for the semaphore";
var cs = ElasticsearchResponse.CreateError(this._ConnectionSettings, new TimeoutException(m), method, path, data);
tcs.SetResult(cs);
tracer.SetResult(cs);
_ConnectionSettings.ConnectionStatusHandler(cs);
return tcs.Task;
}
}
try
{
return this.CreateIterateTask(request, data, tcs);
}
finally
{
this._ResourceLock.Release();
}
}
