private void EnqueueClient(Uri baseUri, Rest.Client connection)
{
ConcurrentQueue <Rest.Client> queue;
if (!this._clients.TryGetValue(baseUri, out queue))
{
return;
}
queue.Enqueue(connection);
}
public ThriftConnection(IConnectionSettings2 connectionSettings)
{
this._connectionSettings = connectionSettings;
this._timeout = connectionSettings.Timeout;
this._poolSize = Math.Max(1, connectionSettings.MaximumAsyncConnections);
this._resourceLock = new Semaphore(_poolSize, _poolSize);
for (var i = 0; i <= connectionSettings.MaximumAsyncConnections; i++)
{
var tsocket = new TSocket(connectionSettings.Host, connectionSettings.Port);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = new TBinaryProtocol(transport);
var client = new Rest.Client(protocol);
_clients.Enqueue(client);
}
}
private Rest.Client CreateClient(Uri uri, ConcurrentQueue <Rest.Client> queue)
{
var host = uri.Host;
var port = uri.Port;
var tsocket = new TSocket(host, port, this._connectionSettings.Timeout);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = _protocolFactory == null ? new TBinaryProtocol(transport) : _protocolFactory.GetProtocol(transport);
var client = new Rest.Client(protocol);
tsocket.ConnectTimeout = this._connectionSettings.ConnectTimeout.GetValueOrDefault(200);
tsocket.Timeout = this._connectionSettings.Timeout;
tsocket.TcpClient.SendTimeout = this._connectionSettings.Timeout;
tsocket.TcpClient.ReceiveTimeout = this._connectionSettings.Timeout;
tsocket.TcpClient.NoDelay = true;
queue.Enqueue(client);
return(client);
}
public ThriftConnection(IConnectionConfigurationValues connectionSettings)
{
this._connectionSettings = connectionSettings;
this._timeout = connectionSettings.Timeout;
this._poolSize = Math.Max(1, connectionSettings.MaximumAsyncConnections);
this._resourceLock = new Semaphore(_poolSize, _poolSize);
int seed; bool shouldPingHint;
for (var i = 0; i <= connectionSettings.MaximumAsyncConnections; i++)
{
var uri = this._connectionSettings.ConnectionPool.GetNext(null, out seed, out shouldPingHint);
var host = uri.Host;
var port = uri.Port;
var tsocket = new TSocket(host, port);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = new TBinaryProtocol(transport);
var client = new Rest.Client(protocol);
_clients.Enqueue(client);
}
}
public ThriftConnection(IConnectionConfigurationValues connectionSettings)
{
this._connectionSettings = connectionSettings;
this._timeout = connectionSettings.Timeout;
this._poolSize = Math.Max(1, connectionSettings.MaximumAsyncConnections);
this._resourceLock = new Semaphore(_poolSize, _poolSize);
int seed; bool shouldPingHint;
for (var i = 0; i <= connectionSettings.MaximumAsyncConnections; i++)
{
var uri = this._connectionSettings.ConnectionPool.GetNext(null, out seed, out shouldPingHint);
var host = uri.Host;
var port = uri.Port;
var tsocket = new TSocket(host, port);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = new TBinaryProtocol(transport);
var client = new Rest.Client(protocol);
_clients.Enqueue(client);
}
}
public ThriftConnection(IConnectionConfigurationValues connectionSettings)
{
this._connectionSettings = connectionSettings;
this._timeout = connectionSettings.Timeout;
var connectionPool = this._connectionSettings.ConnectionPool;
var maximumConnections = Math.Max(1, connectionSettings.MaximumAsyncConnections);
var maximumUrls = connectionPool.MaxRetries + 1;
this._poolSize = maximumConnections;
this._resourceLock = new Semaphore(_poolSize, _poolSize);
int seed; int initialSeed = 0; bool shouldPingHint;
for (var i = 0; i < maximumUrls; i++)
{
var uri = connectionPool.GetNext(initialSeed, out seed, out shouldPingHint);
var queue = new ConcurrentQueue <Rest.Client>();
for (var c = 0; c < maximumConnections; c++)
{
var host = uri.Host;
var port = uri.Port;
var tsocket = new TSocket(host, port);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = new TBinaryProtocol(transport);
var client = new Rest.Client(protocol);
tsocket.Timeout = this._connectionSettings.Timeout;
tsocket.TcpClient.SendTimeout = this._connectionSettings.Timeout;
tsocket.TcpClient.ReceiveTimeout = this._connectionSettings.Timeout;
//tsocket.TcpClient.NoDelay = true;
queue.Enqueue(client);
initialSeed = seed;
}
_clients.TryAdd(uri, queue);
}
}
public ThriftConnection(IConnectionConfigurationValues connectionSettings)
{
this._connectionSettings = connectionSettings;
this._timeout = connectionSettings.Timeout;
var connectionPool = this._connectionSettings.ConnectionPool;
var maximumConnections = Math.Max(1, connectionSettings.MaximumAsyncConnections);
var maximumUrls = connectionPool.MaxRetries + 1;
this._poolSize = maximumConnections;
this._resourceLock = new Semaphore(_poolSize, _poolSize);
int seed; int initialSeed = 0; bool shouldPingHint;
for (var i = 0; i < maximumUrls; i++)
{
var uri = connectionPool.GetNext(initialSeed, out seed, out shouldPingHint);
var queue = new ConcurrentQueue<Rest.Client>();
for (var c = 0; c < maximumConnections; c++)
{
var host = uri.Host;
var port = uri.Port;
var tsocket = new TSocket(host, port);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = new TBinaryProtocol(transport);
var client = new Rest.Client(protocol);
tsocket.Timeout = this._connectionSettings.Timeout;
tsocket.TcpClient.SendTimeout = this._connectionSettings.Timeout;
tsocket.TcpClient.ReceiveTimeout = this._connectionSettings.Timeout;
//tsocket.TcpClient.NoDelay = true;
queue.Enqueue(client);
initialSeed = seed;
}
_clients.TryAdd(uri, queue);
}
}
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();
}
}
private Rest.Client CreateClient(Uri uri, ConcurrentQueue<Rest.Client> queue)
{
var host = uri.Host;
var port = uri.Port;
var tsocket = new TSocket(host, port, this._connectionSettings.Timeout);
var transport = new TBufferedTransport(tsocket, 1024);
var protocol = _protocolFactory == null ? new TBinaryProtocol(transport) : _protocolFactory.GetProtocol(transport);
var client = new Rest.Client(protocol);
tsocket.ConnectTimeout = this._connectionSettings.ConnectTimeout.GetValueOrDefault(200);
tsocket.Timeout = this._connectionSettings.Timeout;
tsocket.TcpClient.SendTimeout = this._connectionSettings.Timeout;
tsocket.TcpClient.ReceiveTimeout = this._connectionSettings.Timeout;
tsocket.TcpClient.NoDelay = true;
queue.Enqueue(client);
return client;
}
