public StreamingDataReaderTokenHandler(TaskCompletionSource <DbDataReader> readerSource, AseDataReader dataReader, IInfoMessageEventNotifier eventNotifier)
{
_readerSource = readerSource;
_dataReader = dataReader;
_eventNotifier = eventNotifier;
_hasFirstResultSet = false;
}
private IInternalConnection FetchIdlePooledConnection(IInfoMessageEventNotifier eventNotifier)
{
var now = DateTime.UtcNow;
while (_available.TryTake(out var connection))
{
if (ShouldRemoveAndReplace(connection, now))
{
RemoveAndReplace(connection);
continue;
}
if (_parameters.PingServer && !connection.Ping())
{
RemoveAndReplace(connection);
continue;
}
Logger.Instance?.WriteLine($"{nameof(FetchIdlePooledConnection)} returned idle connection");
connection.EventNotifier = eventNotifier;
return(connection);
}
Logger.Instance?.WriteLine($"{nameof(FetchIdlePooledConnection)} found no idle connection");
return(null);
}
public Task <IInternalConnection> GetNewConnection(CancellationToken token, IInfoMessageEventNotifier eventNotifier)
{
Logger.Instance?.WriteLine($"{nameof(InternalConnectionFactory)}.{nameof(GetNewConnection)} start");
var socket = CreateSocket(token);
var connection = CreateConnection(socket, token); //will dispose socket on fail
connection.EventNotifier = eventNotifier;
try
{
connection.Login();
return(Task.FromResult((IInternalConnection)connection));
}
catch (AseException)
{
connection.Dispose();
socket?.Dispose();
throw;
}
catch (Exception ex)
{
Logger.Instance?.WriteLine($"{nameof(InternalConnectionFactory)}.{nameof(GetNewConnection)} encountered exception: {ex}");
connection.Dispose();
socket?.Dispose();
throw new OperationCanceledException();
}
}
public IInternalConnection Reserve(IInfoMessageEventNotifier eventNotifier)
{
try
{
using (var src = new CancellationTokenSource())
{
var t = src.Token;
src.CancelAfter(TimeSpan.FromSeconds(_parameters.LoginTimeout));
var task = _parameters.Pooling
? ReservePooledConnection(t, eventNotifier)
: _connectionFactory.GetNewConnection(t, eventNotifier);
task.Wait(t);
var connection = task.Result;
if (connection == null)
{
throw new OperationCanceledException();
}
connection.ChangeDatabase(_parameters.Database);
connection.SetTextSize(_parameters.TextSize);
return(connection);
}
}
catch (AggregateException ae)
{
if (ae.InnerException is OperationCanceledException)
{
throw GetTimedOutAseException(_parameters.Pooling);
}
if (ae.InnerException is AseException)
{
ExceptionDispatchInfo.Capture(ae.InnerException).Throw();
throw;
}
throw new AseException(ae.InnerException);
}
catch (OperationCanceledException)
{
throw GetTimedOutAseException(_parameters.Pooling);
}
catch (AseException)
{
throw;
}
catch (SocketException)
{
throw;
}
catch (Exception ex)
{
throw new AseException(ex);
}
}
// ReSharper disable once MemberCanBePrivate.Global
internal AseDataReader(CommandBehavior behavior, IInfoMessageEventNotifier eventNotifier)
{
_results = new BlockingCollection <TableResult>();
_currentTable = null;
_hasFirst = false;
_behavior = behavior;
_eventNotifier = eventNotifier;
}
private IInternalConnection WaitForPooledConnection(CancellationToken cancellationToken, IInfoMessageEventNotifier eventNotifier)
{
Logger.Instance?.WriteLine($"{nameof(WaitForPooledConnection)} start");
try
{
var conn = _available.Take(cancellationToken);
Logger.Instance?.WriteLine($"{nameof(WaitForPooledConnection)} found connection");
conn.EventNotifier = eventNotifier;
return(conn);
}
catch (OperationCanceledException)
{
Logger.Instance?.WriteLine($"{nameof(WaitForPooledConnection)} timed out waiting for connection");
throw;
}
}
private async Task <IInternalConnection> CreateNewPooledConnection(CancellationToken cancellationToken = new CancellationToken(), IInfoMessageEventNotifier eventNotifier = null)
{
try
{
Logger.Instance?.WriteLine($"{nameof(CreateNewPooledConnection)} start");
return(await _connectionFactory.GetNewConnection(cancellationToken, eventNotifier));
}
catch
{
Logger.Instance?.WriteLine($"{nameof(CreateNewPooledConnection)} failed");
RemoveConnection();
throw;
}
}
private async Task <IInternalConnection> ReservePooledConnection(CancellationToken cancellationToken, IInfoMessageEventNotifier eventNotifier)
{
return(FetchIdlePooledConnection(eventNotifier)
?? (CheckAndIncrementPoolSize()
//there's room in the pool! create new connection and return it
? await CreateNewPooledConnection(cancellationToken, eventNotifier)
//pool's full, wait for something to release a connection
: WaitForPooledConnection(cancellationToken, eventNotifier)));
}
internal AseDataReader(AseCommand command, CommandBehavior behavior, IInfoMessageEventNotifier eventNotifier) : this(behavior, eventNotifier)
{
_command = command;
}
public MessageTokenHandler()
{
_eventNotifier = null;
}
public async Task <IInternalConnection> GetNewConnection(CancellationToken token, IInfoMessageEventNotifier eventNotifier)
{
return(await Task.FromResult <IInternalConnection>(new DoNothingInternalConnection(_changeDatabaseThrows)));
}
public async Task <IInternalConnection> GetNewConnection(CancellationToken token, IInfoMessageEventNotifier eventNotifier)
{
if (IsSuccessful())
{
return(await Task.FromResult <IInternalConnection>(new DoNothingInternalConnection()));
}
throw new Exception();
}
public IInternalConnection Reserve(string connectionString, IConnectionParameters parameters, IInfoMessageEventNotifier eventNotifier, RemoteCertificateValidationCallback userCertificateValidationCallback = null)
{
return(Pools.GetOrAdd(connectionString, _ =>
{
#if ENABLE_ARRAY_POOL
var internalConnectionFactory = new InternalConnectionFactory(parameters, BufferPool, userCertificateValidationCallback);
#else
var internalConnectionFactory = new InternalConnectionFactory(parameters, userCertificateValidationCallback);
#endif
return new ConnectionPool(parameters, internalConnectionFactory);
}).Reserve(eventNotifier));
}
public IInternalConnection Reserve(string connectionString, IConnectionParameters parameters, IInfoMessageEventNotifier eventNotifier)
{
return(Pools.GetOrAdd(connectionString, _ =>
{
#if ENABLE_ARRAY_POOL
var internalConnectionFactory = new InternalConnectionFactory(parameters, BufferPool);
#else
var internalConnectionFactory = new InternalConnectionFactory(parameters);
#endif
return new ConnectionPool(parameters, internalConnectionFactory);
}).Reserve(eventNotifier));
}
public MessageTokenHandler(IInfoMessageEventNotifier eventNotifier)
{
_eventNotifier = eventNotifier;
}
public Task <IInternalConnection> GetNewConnection(CancellationToken token, IInfoMessageEventNotifier eventNotifier)
{
token.WaitHandle.WaitOne();
throw new TimeoutException("Timed out attempting to create new connection");
}
public IInternalConnection Reserve(string connectionString, IConnectionParameters parameters, IInfoMessageEventNotifier eventNotifier)
{
return(Pools.GetOrAdd(connectionString, _ => new ConnectionPool(parameters, new InternalConnectionFactory(parameters))).Reserve(eventNotifier));
}
