///<summary>
/// This method is responsible to handle all protocol messages sent from the backend.
/// It holds all the logic to do it.
/// To exchange data, it uses a Mediator object from which it reads/writes information
/// to handle backend requests.
/// </summary>
///
internal IEnumerable <IServerResponseObject> ProcessBackendResponsesEnum(NpgsqlConnector context)
{
try
{
// Flush buffers to the wire.
context.Stream.Flush();
// Process commandTimeout behavior.
if ((context.Mediator.BackendCommandTimeout > 0) &&
(!CheckForContextSocketAvailability(context, SelectMode.SelectRead)))
{
// If timeout occurs when establishing the session with server then
// throw an exception instead of trying to cancel query. This helps to prevent loop as
// CancelRequest will also try to stablish a connection and sends commands.
if (!((this is NpgsqlStartupState || this is NpgsqlConnectedState)))
{
try
{
context.CancelRequest();
ProcessAndDiscardBackendResponses(context);
}
catch (Exception)
{
}
// We should have gotten an error from CancelRequest(). Whether we did or not, what we
// really have is a timeout exception, and that will be less confusing to the user than
// "operation cancelled by user" or similar, so whatever the case, that is what we'll throw.
// Changed message again to report about the two possible timeouts: connection or command
// as the establishment timeout only was confusing users when the timeout was a command timeout.
}
throw new NpgsqlException(resman.GetString("Exception_ConnectionOrCommandTimeout"));
}
switch (context.BackendProtocolVersion)
{
case ProtocolVersion.Version2:
return(ProcessBackendResponses_Ver_2(context));
case ProtocolVersion.Version3:
return(ProcessBackendResponses_Ver_3(context));
default:
throw new NpgsqlException(resman.GetString("Exception_UnknownProtocol"));
}
}
catch (ThreadAbortException)
{
try
{
context.CancelRequest();
context.Close();
}
catch {}
throw;
}
}
/// <summary>
/// Repeatedly attempts to rollback, to support timeout-triggered rollbacks that occur while the connection is busy.
/// </summary>
void RollbackLocal()
{
Debug.Assert(_connector != null, "No connector");
Debug.Assert(_localTx != null, "No local transaction");
var attempt = 0;
while (true)
{
try
{
_localTx.Rollback();
return;
}
catch (NpgsqlOperationInProgressException)
{
// This really shouldn't be necessary, but just in case
if (attempt++ == MaximumRollbackAttempts)
{
throw new Exception($"Could not roll back after {MaximumRollbackAttempts} attempts, aborting. Transaction is in an unknown state.");
}
Log.Logger.LogWarning(NpgsqlEventId.ConnectionInUseDuringRollback, "[{ConnectorId}] Connection in use while trying to rollback, will cancel and retry (localid={TransactionId}", _connector.Id, _txId);
_connector.CancelRequest();
// Cancellations are asynchronous, give it some time
Thread.Sleep(500);
}
}
}
/// <summary>
/// Cancels and terminates an ongoing operation. Any data already written will be discarded.
/// </summary>
public void Cancel()
{
CheckDisposed();
if (CanWrite)
{
_isDisposed = true;
_buf.Clear();
_connector.SendSingleMessage(new CopyFailMessage());
try
{
var msg = _connector.ReadSingleMessage();
// The CopyFail should immediately trigger an exception from the read above.
_connector.Break();
throw new Exception("Expected ErrorResponse when cancelling COPY but got: " + msg.Code);
}
catch (NpgsqlException e)
{
if (e.Code == "57014")
{
return;
}
throw;
}
}
else
{
_connector.CancelRequest();
}
}
void RollbackLocal()
{
Log.Debug($"Single-phase transaction rollback (localid={_txId})", _connector.Id);
var attempt = 0;
while (true)
{
try
{
_localTx.Rollback();
return;
}
catch (NpgsqlOperationInProgressException)
{
// Repeatedly attempts to rollback, to support timeout-triggered rollbacks that occur
// while the connection is busy.
// This really shouldn't be necessary, but just in case
if (attempt++ == MaximumRollbackAttempts)
{
throw new Exception($"Could not roll back after {MaximumRollbackAttempts} attempts, aborting. Transaction is in an unknown state.");
}
Log.Warn($"Connection in use while trying to rollback, will cancel and retry (localid={_txId}", _connector.Id);
_connector.CancelRequest();
// Cancellations are asynchronous, give it some time
Thread.Sleep(500);
}
}
}
async Task Cancel(bool async)
{
CheckDisposed();
if (CanWrite)
{
_isDisposed = true;
_writeBuf.EndCopyMode();
_writeBuf.Clear();
await _connector.WriteCopyFail(async);
await _connector.Flush(async);
try
{
var msg = await _connector.ReadMessage(async);
// The CopyFail should immediately trigger an exception from the read above.
_connector.Break();
throw new NpgsqlException("Expected ErrorResponse when cancelling COPY but got: " + msg.Code);
}
catch (PostgresException e)
{
if (e.SqlState == PostgresErrorCodes.QueryCanceled)
{
return;
}
throw;
}
}
else
{
_connector.CancelRequest();
}
}
/// <summary>
/// Cancels and terminates an ongoing operation. Any data already written will be discarded.
/// </summary>
public void Cancel()
{
CheckDisposed();
if (CanWrite)
{
_isDisposed = true;
_buf.Clear();
_connector.SendSingleMessage(new CopyFailMessage());
try
{
var msg = _connector.ReadSingleMessage();
_connector.State = ConnectorState.Broken;
throw new Exception("Expected ErrorResponse when cancelling COPY but got: " + msg.Code);
}
catch (NpgsqlException e)
{
if (e.Code == "57014")
{
return;
}
throw;
}
}
else
{
_connector.CancelRequest();
}
}
internal IEnumerable <IServerResponseObject> ProcessExistingBackendResponses(NpgsqlConnector context)
{
try
{
return(ProcessBackendResponses_Ver_3(context));
}
catch (ThreadAbortException)
{
try
{
context.CancelRequest();
context.Close();
}
catch { }
throw;
}
}
/// <summary>
/// Attempts to cancel the execution of a <see cref="Npgsql.NpgsqlCommand">NpgsqlCommand</see>.
/// </summary>
/// <remarks>This Method isn't implemented yet.</remarks>
public override void Cancel()
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Cancel");
try
{
// get copy for thread safety of null test
NpgsqlConnector connector = Connector;
if (connector != null)
{
connector.CancelRequest();
}
}
catch (IOException)
{
Connection.ClearPool();
}
catch (NpgsqlException)
{
// Cancel documentation says the Cancel doesn't throw on failure
}
}
///<summary>
/// This method is responsible to handle all protocol messages sent from the backend.
/// It holds all the logic to do it.
/// To exchange data, it uses a Mediator object from which it reads/writes information
/// to handle backend requests.
/// </summary>
///
internal virtual void ProcessBackendResponses(NpgsqlConnector context)
{
try
{
// Process commandTimeout behavior.
if ((context.Mediator.CommandTimeout > 0) && (!context.Socket.Poll(1000000 * context.Mediator.CommandTimeout, SelectMode.SelectRead)))
{
// If timeout occurs when establishing the session with server then
// throw an exception instead of trying to cancel query. This helps to prevent loop as CancelRequest will also try to stablish a connection and sends commands.
if ((this is NpgsqlStartupState || this is NpgsqlConnectedState))
{
throw new NpgsqlException(resman.GetString("Exception_ConnectionTimeout"));
}
else
{
context.CancelRequest();
}
}
switch (context.BackendProtocolVersion)
{
case ProtocolVersion.Version2:
ProcessBackendResponses_Ver_2(context);
break;
case ProtocolVersion.Version3:
ProcessBackendResponses_Ver_3(context);
break;
}
}
finally
{
// reset expectations right after getting new responses
context.Mediator.ResetExpectations();
}
}
///<summary>
/// This method is responsible to handle all protocol messages sent from the backend.
/// It holds all the logic to do it.
/// To exchange data, it uses a Mediator object from which it reads/writes information
/// to handle backend requests.
/// </summary>
///
internal IEnumerable<IServerResponseObject> ProcessBackendResponsesEnum(NpgsqlConnector context)
{
try
{
// Process commandTimeout behavior.
if ((context.Mediator.CommandTimeout > 0) &&
(!context.Socket.Poll(1000000*context.Mediator.CommandTimeout, SelectMode.SelectRead)))
{
// If timeout occurs when establishing the session with server then
// throw an exception instead of trying to cancel query. This helps to prevent loop as CancelRequest will also try to stablish a connection and sends commands.
if (!((this is NpgsqlStartupState || this is NpgsqlConnectedState || context.CancelRequestCalled)))
{
try
{
context.CancelRequest();
foreach (IServerResponseObject obj in ProcessBackendResponsesEnum(context))
{
if (obj is IDisposable)
{
(obj as IDisposable).Dispose();
}
}
}
catch(Exception ex)
{
}
//We should have gotten an error from CancelRequest(). Whether we did or not, what we
//really have is a timeout exception, and that will be less confusing to the user than
//"operation cancelled by user" or similar, so whatever the case, that is what we'll throw.
// Changed message again to report about the two possible timeouts: connection or command as the establishment timeout only was confusing users when the timeout was a command timeout.
}
throw new NpgsqlException(resman.GetString("Exception_ConnectionOrCommandTimeout"));
}
switch (context.BackendProtocolVersion)
{
case ProtocolVersion.Version2:
return ProcessBackendResponses_Ver_2(context);
case ProtocolVersion.Version3:
return ProcessBackendResponses_Ver_3(context);
default:
throw new NpgsqlException(resman.GetString("Exception_UnknownProtocol"));
}
}
catch(ThreadAbortException)
{
try
{
context.CancelRequest();
context.Close();
}
catch {}
throw;
}
}
/// <summary>
/// Cancels an ongoing export.
/// </summary>
public void Cancel()
{
_connector.CancelRequest();
}
internal IEnumerable<IServerResponseObject> ProcessExistingBackendResponses(NpgsqlConnector context)
{
try
{
return ProcessBackendResponses_Ver_3(context);
}
catch (ThreadAbortException)
{
try
{
context.CancelRequest();
context.Close();
}
catch { }
throw;
}
}
///<summary>
/// This method is responsible to handle all protocol messages sent from the backend.
/// It holds all the logic to do it.
/// To exchange data, it uses a Mediator object from which it reads/writes information
/// to handle backend requests.
/// </summary>
///
internal virtual void ProcessBackendResponses( NpgsqlConnector context )
{
try
{
// Process commandTimeout behavior.
if ((context.Mediator.CommandTimeout > 0) && (!context.Socket.Poll(1000000 * context.Mediator.CommandTimeout, SelectMode.SelectRead)))
{
// If timeout occurs when establishing the session with server then
// throw an exception instead of trying to cancel query. This helps to prevent loop as CancelRequest will also try to stablish a connection and sends commands.
if ((this is NpgsqlStartupState || this is NpgsqlConnectedState))
throw new NpgsqlException(resman.GetString("Exception_ConnectionTimeout"));
else
context.CancelRequest();
}
switch (context.BackendProtocolVersion)
{
case ProtocolVersion.Version2 :
ProcessBackendResponses_Ver_2(context);
break;
case ProtocolVersion.Version3 :
ProcessBackendResponses_Ver_3(context);
break;
}
}
finally
{
// reset expectations right after getting new responses
context.Mediator.ResetExpectations();
}
}
///<summary>
/// This method is responsible to handle all protocol messages sent from the backend.
/// It holds all the logic to do it.
/// To exchange data, it uses a Mediator object from which it reads/writes information
/// to handle backend requests.
/// </summary>
///
internal IEnumerable<IServerResponseObject> ProcessBackendResponsesEnum(NpgsqlConnector context)
{
try
{
// Flush buffers to the wire.
context.Stream.Flush();
// Process commandTimeout behavior.
if ((context.Mediator.BackendCommandTimeout > 0) &&
(!CheckForContextSocketAvailability(context, SelectMode.SelectRead)))
{
// If timeout occurs when establishing the session with server then
// throw an exception instead of trying to cancel query. This helps to prevent loop as
// CancelRequest will also try to stablish a connection and sends commands.
if (!((this is NpgsqlStartupState || this is NpgsqlConnectedState)))
{
try
{
context.CancelRequest();
ProcessAndDiscardBackendResponses(context);
}
catch(Exception)
{
}
// We should have gotten an error from CancelRequest(). Whether we did or not, what we
// really have is a timeout exception, and that will be less confusing to the user than
// "operation cancelled by user" or similar, so whatever the case, that is what we'll throw.
// Changed message again to report about the two possible timeouts: connection or command
// as the establishment timeout only was confusing users when the timeout was a command timeout.
}
throw new NpgsqlException(resman.GetString("Exception_ConnectionOrCommandTimeout"));
}
return ProcessBackendResponses(context);
}
catch(ThreadAbortException)
{
try
{
context.CancelRequest();
context.Close();
}
catch {}
throw;
}
}
///<summary>
/// This method is responsible to handle all protocol messages sent from the backend.
/// It holds all the logic to do it.
/// To exchange data, it uses a Mediator object from which it reads/writes information
/// to handle backend requests.
/// </summary>
///
internal IEnumerable<IServerResponseObject> ProcessBackendResponsesEnum(NpgsqlConnector context)
{
try
{
// Flush buffers to the wire.
context.Stream.Flush();
// Process commandTimeout behavior.
// We will give an extra 5 seconds to context.Mediator.CommandTimeout
// because we'd prefer to receive a timeout error from PG
// than to be forced to start a new connection and send a cancel request.
// The result is that a timeout could take 5 seconds too long to occur, but if everything
// is healthy, that shouldn't happen.
if ((context.Mediator.BackendCommandTimeout > 0) && (!context.Stream.WaitAvailable(TimeSpan.FromSeconds(context.Mediator.BackendCommandTimeout + 5))))
{
// If timeout occurs when establishing the session with server then
// throw an exception instead of trying to cancel query. This helps to prevent loop as
// CancelRequest will also try to stablish a connection and sends commands.
if (!((this is NpgsqlStartupState || this is NpgsqlConnectedState)))
{
try
{
context.CancelRequest();
ProcessAndDiscardBackendResponses(context);
}
catch(Exception)
{
}
// We should have gotten an error from CancelRequest(). Whether we did or not, what we
// really have is a timeout exception, and that will be less confusing to the user than
// "operation cancelled by user" or similar, so whatever the case, that is what we'll throw.
// Changed message again to report about the two possible timeouts: connection or command
// as the establishment timeout only was confusing users when the timeout was a command timeout.
}
throw new NpgsqlException(resman.GetString("Exception_ConnectionOrCommandTimeout"));
}
switch (context.BackendProtocolVersion)
{
case ProtocolVersion.Version2:
return ProcessBackendResponses_Ver_2(context);
case ProtocolVersion.Version3:
return ProcessBackendResponses_Ver_3(context);
default:
throw new NpgsqlException(resman.GetString("Exception_UnknownProtocol"));
}
}
catch(ThreadAbortException)
{
try
{
context.CancelRequest();
context.Close();
}
catch {}
throw;
}
}
