/* MultiClientCancel cancels the running query on the given connection. */
bool
MultiClientCancel(int32 connectionId)
{
PGconn *connection = NULL;
PGcancel *cancelObject = NULL;
int cancelSent = 0;
bool canceled = true;
char errorBuffer[STRING_BUFFER_SIZE];
Assert(connectionId != INVALID_CONNECTION_ID);
connection = ClientConnectionArray[connectionId];
Assert(connection != NULL);
cancelObject = PQgetCancel(connection);
cancelSent = PQcancel(cancelObject, errorBuffer, sizeof(errorBuffer));
if (cancelSent == 0)
{
ereport(WARNING, (errmsg("could not issue cancel request"),
errdetail("Client error: %s", errorBuffer)));
canceled = false;
}
PQfreeCancel(cancelObject);
return canceled;
}
static void
handle_sigint(SIGNAL_ARGS)
{
int save_errno = errno;
char errbuf[256];
/* if we are waiting for input, longjmp out of it */
if (sigint_interrupt_enabled)
{
sigint_interrupt_enabled = false;
siglongjmp(sigint_interrupt_jmp, 1);
}
/* else, set cancel flag to stop any long-running loops */
cancel_pressed = true;
/* and send QueryCancel if we are processing a database query */
if (cancelConn != NULL)
{
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
write_stderr("Cancel request sent\n");
else
{
write_stderr("Could not send cancel request: ");
write_stderr(errbuf);
}
}
errno = save_errno; /* just in case the write changed it */
}
/*
* Console control handler for Win32. Note that the control handler will
* execute on a *different thread* than the main one, so we need to do
* proper locking around those structures.
*/
static BOOL WINAPI
consoleHandler(DWORD dwCtrlType)
{
char errbuf[256];
if (dwCtrlType == CTRL_C_EVENT ||
dwCtrlType == CTRL_BREAK_EVENT)
{
/* Send QueryCancel if we are processing a database query */
EnterCriticalSection(&cancelConnLock);
if (cancelConn != NULL)
{
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
fprintf(stderr, _("Cancel request sent\n"));
else
fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
}
LeaveCriticalSection(&cancelConnLock);
return TRUE;
}
else
/* Return FALSE for any signals not being handled */
return FALSE;
}
static PyObject *
psyco_conn_cancel(connectionObject *self, PyObject *args)
{
char errbuf[256];
EXC_IF_CONN_CLOSED(self);
EXC_IF_TPC_PREPARED(self, cancel);
/* do not allow cancellation while the connection is being built */
Dprintf("psyco_conn_cancel: cancelling with key %p", self->cancel);
if (self->status != CONN_STATUS_READY &&
self->status != CONN_STATUS_BEGIN) {
PyErr_SetString(OperationalError,
"asynchronous connection attempt underway");
return NULL;
}
if (PQcancel(self->cancel, errbuf, sizeof(errbuf)) == 0) {
Dprintf("psyco_conn_cancel: cancelling failed: %s", errbuf);
PyErr_SetString(OperationalError, errbuf);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static BOOL WINAPI
consoleHandler(DWORD dwCtrlType)
{
char errbuf[256];
if (dwCtrlType == CTRL_C_EVENT ||
dwCtrlType == CTRL_BREAK_EVENT)
{
/*
* Can't longjmp here, because we are in wrong thread :-(
*/
/* set cancel flag to stop any long-running loops */
cancel_pressed = true;
/* and send QueryCancel if we are processing a database query */
EnterCriticalSection(&cancelConnLock);
if (cancelConn != NULL)
{
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
write_stderr("Cancel request sent\n");
else
{
write_stderr("Could not send cancel request: ");
write_stderr(errbuf);
}
}
LeaveCriticalSection(&cancelConnLock);
return TRUE;
}
else
/* Return FALSE for any signals not being handled */
return FALSE;
}
bool
CancelQuery(PGconn *conn, int timeout)
{
char errbuf[ERRBUFF_SIZE];
PGcancel *pgcancel;
if (wait_connection_availability(conn, timeout) != 1)
return false;
pgcancel = PQgetCancel(conn);
if (pgcancel != NULL)
{
/*
* PQcancel can only return 0 if socket()/connect()/send()
* fails, in any of those cases we can assume something
* bad happened to the connection
*/
if (PQcancel(pgcancel, errbuf, ERRBUFF_SIZE) == 0)
{
log_warning(_("Can't stop current query: %s\n"), errbuf);
PQfreeCancel(pgcancel);
return false;
}
PQfreeCancel(pgcancel);
}
return true;
}
/*
* Handle interrupt signals by cancelling the current command.
*/
static void
on_interrupt(void)
{
pgutConn *c;
int save_errno = errno;
/* Set interruped flag */
interrupted = true;
if (in_cleanup)
return;
/* Send QueryCancel if we are processing a database query */
pgut_conn_lock();
for (c = pgut_connections; c; c = c->next)
{
char buf[256];
if (c->cancel != NULL && PQcancel(c->cancel, buf, sizeof(buf)))
elog(WARNING, "Cancel request sent");
}
pgut_conn_unlock();
errno = save_errno; /* just in case the write changed it */
}
GSQLCursorState
pgsql_cursor_stop (GSQLCursor *cursor)
{
GSQL_TRACE_FUNC;
GSQLSession *session;
GSQLEPGSQLSession *spec_session;
GSQLEPGSQLCursor *spec_cursor;
PGcancel *cancel = NULL;
gchar buff[256];
g_return_val_if_fail (GSQL_IS_CURSOR (cursor), GSQL_CURSOR_STATE_ERROR);
session = cursor->session;
g_return_val_if_fail (GSQL_IS_SESSION (session),
GSQL_CURSOR_STATE_ERROR);
spec_session = session->spec;
spec_cursor = cursor->spec;
cancel = PQgetCancel (spec_session->pgconn);
if ( ! PQcancel (cancel, buff, 256) ) {
pgsql_session_workspace_info (session, buff);
PQfreeCancel (cancel);
return GSQL_CURSOR_STATE_ERROR;
}
PQfreeCancel (cancel);
return GSQL_CURSOR_STATE_STOP;
}
void dbgPgConn::Cancel()
{
// Attempt to cancel any ongoing query
if (m_pgConn)
{
PGcancel *cancel = PQgetCancel(m_pgConn);
char errbuf[256];
PQcancel(cancel, errbuf, sizeof(errbuf));
PQfreeCancel(cancel);
}
}
static void
CancelQuery(void)
{
char errbuf[256];
PGcancel *pgcancel;
pgcancel = PQgetCancel(primaryConn);
if (!pgcancel || PQcancel(pgcancel, errbuf, 256) == 0)
fprintf(stderr, "Can't stop current query: %s", errbuf);
PQfreeCancel(pgcancel);
}
static void
CancelQuery(void)
{
char errbuf[ERRBUFF_SIZE];
PGcancel *pgcancel;
pgcancel = PQgetCancel(primaryConn);
if (!pgcancel || PQcancel(pgcancel, errbuf, ERRBUFF_SIZE) == 0)
log_warning("Can't stop current query: %s\n", errbuf);
PQfreeCancel(pgcancel);
}
void
CancelQuery(PGconn *conn)
{
char errbuf[ERRBUFF_SIZE];
PGcancel *pgcancel;
pgcancel = PQgetCancel(conn);
if (!pgcancel || PQcancel(pgcancel, errbuf, ERRBUFF_SIZE) == 0)
log_warning(_("Can't stop current query: %s\n"), errbuf);
PQfreeCancel(pgcancel);
}
CAMLprim value PQCancel_stub(value v_conn)
{
CAMLparam1(v_conn);
PGconn *conn = get_conn(v_conn);
if (conn == NULL) CAMLreturn(v_None);
else {
PGcancel *cancel = get_cancel_obj(v_conn);
char errbuf[256];
int res;
caml_enter_blocking_section();
res = PQcancel(cancel, errbuf, 256);
caml_leave_blocking_section();
if (res == 0) CAMLreturn(v_None);
else CAMLreturn(make_some(caml_copy_string(errbuf)));
}
}
/*
* Handle interrupt signals by cancelling the current command,
* if it's being executed through executeMaintenanceCommand(),
* and thus has a cancelConn set.
*/
static void
handle_sigint(SIGNAL_ARGS)
{
int save_errno = errno;
char errbuf[256];
/* Send QueryCancel if we are processing a database query */
if (cancelConn != NULL)
{
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
fprintf(stderr, _("Cancel request sent\n"));
else
fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
}
errno = save_errno; /* just in case the write changed it */
}
SWITCH_DECLARE(switch_pgsql_status_t) switch_pgsql_cancel_real(const char *file, const char *func, int line, switch_pgsql_handle_t *handle)
{
switch_pgsql_status_t ret = SWITCH_PGSQL_SUCCESS;
#ifdef SWITCH_HAVE_PGSQL
char err_buf[256];
PGcancel *cancel = NULL;
memset(err_buf, 0, 256);
cancel = PQgetCancel(handle->con);
if(!PQcancel(cancel, err_buf, 256)) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_CRIT, "Failed to cancel long-running query (%s): %s\n", handle->sql, err_buf);
ret = SWITCH_PGSQL_FAIL;
}
PQfreeCancel(cancel);
#endif
return ret;
}
/*
* Handle interrupt signals by cancelling the current command.
*/
static void
on_interrupt(void)
{
int save_errno = errno;
char errbuf[256];
/* Set interrupted flag */
interrupted = true;
/* Send QueryCancel if we are processing a database query */
if (!in_cleanup && cancel_conn != NULL &&
PQcancel(cancel_conn, errbuf, sizeof(errbuf)))
{
elog(WARNING, "cancel request was sent");
}
errno = save_errno; /* just in case the write changed it */
}
void pgConn::CancelExecution(void)
{
char errbuf[256];
wxMutexLocker lock(m_cancelConnMutex);
if (m_cancelConn)
{
PGcancel *cancelConn = m_cancelConn;
m_cancelConn = NULL;
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
{
SetLastResultError(NULL, wxT("Cancel request sent"));
}
else
{
SetLastResultError(NULL, wxString::Format(wxT("Could not send cancel request:\n%s"), errbuf));
}
PQfreeCancel(cancelConn);
}
}
void toQPSqlConnectionSub::nativeCancel()
{
QVariant v = Connection.driver()->handle();
if (v.isValid() && v.typeName() == QString("PGconn*"))
{
#ifdef LIBPQ_DECL_CANCEL
PGconn *handle = *static_cast<PGconn **>(v.data());
if (!handle)
return;
PGcancel *cancel = PQgetCancel(handle);
if (!cancel)
return;
char *errbuf = new char[1024];
PQcancel(cancel, errbuf, 1024);
PQfreeCancel(cancel);
delete[] errbuf;
#endif
}
}
/*
* sigint_handler() - Interupt handler to cancel active queries
*/
static void sigint_handler(SIGNAL_ARGS)
{
char errbuf[256];
/* Once we accept an interupt it's best to simply disable the handler */
signal(SIGINT, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, SIG_IGN);
if (cancelConn != NULL)
{
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
fprintf(stderr, "Cancel request sent\n");
else
{
fprintf(stderr, "Could not send cancel request: ");
fprintf(stderr, "%s", errbuf);
}
}
XRAISE(USER_INTERUPT, "SIGINT");
}
/*
* DisconnectDatabase
* Disconnect the connection associated with the given slot
*/
static void
DisconnectDatabase(ParallelSlot *slot)
{
char errbuf[256];
if (!slot->connection)
return;
if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
{
PGcancel *cancel;
if ((cancel = PQgetCancel(slot->connection)))
{
PQcancel(cancel, errbuf, sizeof(errbuf));
PQfreeCancel(cancel);
}
}
PQfinish(slot->connection);
slot->connection = NULL;
}
/*
* Close the connection to the database and also cancel off the query if we
* have one running.
*/
void
DisconnectDatabase(Archive *AHX)
{
ArchiveHandle *AH = (ArchiveHandle *) AHX;
PGcancel *cancel;
char errbuf[1];
if (!AH->connection)
return;
if (PQtransactionStatus(AH->connection) == PQTRANS_ACTIVE)
{
if ((cancel = PQgetCancel(AH->connection)))
{
PQcancel(cancel, errbuf, sizeof(errbuf));
PQfreeCancel(cancel);
}
}
PQfinish(AH->connection);
AH->connection = NULL;
}
/*
* Send cancel/finish signal to still-running QE through libpq.
* waitMode is either CANCEL or FINISH. Returns true if we successfully
* sent a signal (not necessarily received by the target process).
*/
static DispatchWaitMode
cdbdisp_signalQE(SegmentDatabaseDescriptor * segdbDesc,
DispatchWaitMode waitMode)
{
char errbuf[256];
PGcancel *cn = PQgetCancel(segdbDesc->conn);
int ret = 0;
if (cn == NULL)
return DISPATCH_WAIT_NONE;
/*
* PQcancel uses some strcpy/strcat functions; let's
* clear this for safety.
*/
MemSet(errbuf, 0, sizeof(errbuf));
if (Debug_cancel_print || DEBUG4 >= log_min_messages)
write_log("Calling PQcancel for %s", segdbDesc->whoami);
/*
* Send query-finish, unless the client really wants to cancel the
* query. This could happen if cancel comes after we sent finish.
*/
if (waitMode == DISPATCH_WAIT_CANCEL)
ret = PQcancel(cn, errbuf, 256);
else if (waitMode == DISPATCH_WAIT_FINISH)
ret = PQrequestFinish(cn, errbuf, 256);
else
write_log("unknown waitMode: %d", waitMode);
if (ret == 0 && (Debug_cancel_print || LOG >= log_min_messages))
write_log("Unable to cancel: %s", errbuf);
PQfreeCancel(cn);
return (ret != 0 ? waitMode : DISPATCH_WAIT_NONE);
}
static void
handle_sigint(SIGNAL_ARGS)
{
int save_errno = errno;
int rc;
char errbuf[256];
/* if we are waiting for input, longjmp out of it */
if (sigint_interrupt_enabled)
{
sigint_interrupt_enabled = false;
siglongjmp(sigint_interrupt_jmp, 1);
}
/* else, set cancel flag to stop any long-running loops */
cancel_pressed = true;
/* and send QueryCancel if we are processing a database query */
if (cancelConn != NULL)
{
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
{
rc = write_stderr("Cancel request sent\n");
(void) rc; /* ignore errors, nothing we can do here */
}
else
{
rc = write_stderr("Could not send cancel request: ");
(void) rc; /* ignore errors, nothing we can do here */
sprintf(errbuf, "signal: %d\n", postgres_signal_arg);
rc = write_stderr(errbuf);
(void) rc; /* ignore errors, nothing we can do here */
}
}
errno = save_errno; /* just in case the write changed it */
}
/*
* pgfdw_subxact_callback --- cleanup at subtransaction end.
*/
static void
pgfdw_subxact_callback(SubXactEvent event, SubTransactionId mySubid,
SubTransactionId parentSubid, void *arg)
{
HASH_SEQ_STATUS scan;
ConnCacheEntry *entry;
int curlevel;
/* Nothing to do at subxact start, nor after commit. */
if (!(event == SUBXACT_EVENT_PRE_COMMIT_SUB ||
event == SUBXACT_EVENT_ABORT_SUB))
return;
/* Quick exit if no connections were touched in this transaction. */
if (!xact_got_connection)
return;
/*
* Scan all connection cache entries to find open remote subtransactions
* of the current level, and close them.
*/
curlevel = GetCurrentTransactionNestLevel();
hash_seq_init(&scan, ConnectionHash);
while ((entry = (ConnCacheEntry *) hash_seq_search(&scan)))
{
PGresult *res;
char sql[100];
/*
* We only care about connections with open remote subtransactions of
* the current level.
*/
if (entry->conn == NULL || entry->xact_depth < curlevel)
continue;
if (entry->xact_depth > curlevel)
elog(ERROR, "missed cleaning up remote subtransaction at level %d",
entry->xact_depth);
if (event == SUBXACT_EVENT_PRE_COMMIT_SUB)
{
/* Commit all remote subtransactions during pre-commit */
snprintf(sql, sizeof(sql), "RELEASE SAVEPOINT s%d", curlevel);
do_sql_command(entry->conn, sql);
}
else
{
/* Assume we might have lost track of prepared statements */
entry->have_error = true;
/*
* If a command has been submitted to the remote server by using
* an asynchronous execution function, the command might not have
* yet completed. Check to see if a command is still being
* processed by the remote server, and if so, request cancellation
* of the command.
*/
if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE)
{
PGcancel *cancel;
char errbuf[256];
if ((cancel = PQgetCancel(entry->conn)))
{
if (!PQcancel(cancel, errbuf, sizeof(errbuf)))
ereport(WARNING,
(errcode(ERRCODE_CONNECTION_FAILURE),
errmsg("could not send cancel request: %s",
errbuf)));
PQfreeCancel(cancel);
}
}
/* Rollback all remote subtransactions during abort */
snprintf(sql, sizeof(sql),
"ROLLBACK TO SAVEPOINT s%d; RELEASE SAVEPOINT s%d",
curlevel, curlevel);
res = PQexec(entry->conn, sql);
if (PQresultStatus(res) != PGRES_COMMAND_OK)
pgfdw_report_error(WARNING, res, entry->conn, true, sql);
else
PQclear(res);
}
/* OK, we're outta that level of subtransaction */
entry->xact_depth--;
}
}
int pgsql_query_send_async(char *query, char *connect_info, IDL_VPTR *resultVptr)
{
/* connection info */
int query_status;
PGconn *conn=NULL;
PGresult *res=NULL;
PGcancel *cancel_obj;
/* Information about each field */
field_info *fi;
/* Structure definition info */
idl_tag_info *ti;
//UCHAR *dataPtr;
char *dataPtr;
/* temporary pointer to tag data */
UCHAR *tptr;
/* loop variables */
long long row;
int tag;
/* binary or ascii? Only need ascii for file output */
int binary;
int estatus;
int verbose=0;
/* We must reset this each time */
cancel_query = 0;
/* Attempt to establish the connection */
conn = PQconnectdb(connect_info);
if (PQstatus(conn) != CONNECTION_OK)
{
pgsql_query_error("Could not establish connection",
PQerrorMessage(conn));
PQfinish(conn);
return(MYPG_CONNECT_FAILURE);
}
/* send the query and return the results */
if (kw.file_there)
binary = 0;
else
binary = 1;
if (kw.verbose_there)
if (kw.verbose)
verbose = 1;
if (verbose)
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
"Querying database (^C to cancel)");
if (! PQsendQueryParams(conn,
query,
0,
NULL,
NULL,
NULL,
NULL,
binary) )
{
prepExit(conn, res);
return(MYPG_DISPATCH_ERROR);
}
if (! (cancel_obj = PQgetCancel(conn)) )
{
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
"Cancel object is NULL");
return(MYPG_CANCEL_FAILURE);
}
/* Only allow SIGINT after this point, since it calls cancel */
pgsql_sigint_register();
/* note this is a busy loop. I tried sleeping, but it really slows
down the job */
PQconsumeInput(conn); //Try to collect the results
while (PQisBusy(conn)) // while not ready ...
{
if (cancel_query)
{
char errbuf[256];
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
"Canceling query at user request");
if (!PQcancel(cancel_obj, errbuf, 256) )
{
estatus = MYPG_CANCEL_FAILURE;
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
errbuf);
}
else
estatus = MYPG_QUERY_CANCELLED;
pgsql_sigint_unregister();
/* This will call PQfinish and PQclear clear the memory */
prepExit(conn, res);
return(estatus);
}
PQconsumeInput(conn); //...retry
}
/* No signal handling beyond this point */
pgsql_sigint_unregister();
if (verbose)
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Getting result");
res = PQgetResult(conn);
/* Success? */
query_status = pgsql_query_checkstatus(res);
if (query_status != MYPG_SUCCESS)
{
prepExit(conn, res);
return(query_status);
}
/* See if the user input a file to write to */
if (kw.file_there)
{
int write_status;
write_status = pgsql_write_file(res);
prepExit(conn, res);
return(write_status);
}
/* Get information for each returned field */
fi = pgsql_get_field_info(res);
/* Copy into output keywords, if they exist */
pgsql_copy_info(fi);
/* Get info to make struct and copy data */
ti = pgsql_get_idl_tag_info(fi->tagdefs);
/* Create the output structure */
if (verbose)
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Creating output struct");
dataPtr =
IDL_MakeTempStructVector(ti->sdef, (IDL_MEMINT) fi->nTuples,
resultVptr, IDL_TRUE);
/* Copy into output variable */
if (verbose)
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Copying data");
for (row=0; row< fi->nTuples; row++)
for (tag = 0; tag < fi->nFields; tag++)
{
tptr =
( (*resultVptr)->value.s.arr->data +
row*( (*resultVptr)->value.arr->elt_len) + ti->tagOffsets[tag]);
pgsql_store_binary(ti->tagDesc[tag]->type, fi->field_isarray[tag],
PQgetvalue(res, row, tag), tptr);
}
if (verbose)
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Cleaning up");
pgsql_freemem(fi, ti);
PQclear(res);
PQfinish(conn);
if (verbose)
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Done");
return(MYPG_SUCCESS);
}
static WriterResult
ParallelWriterClose(ParallelWriter *self, bool onError)
{
WriterResult ret = { 0 };
if (!self->base.rel)
self->writer->close(self->writer, onError);
/* wait for reader */
if (self->conn)
{
if (self->queue && !onError)
{
PGresult *res;
int sock;
fd_set input_mask;
/* terminate with zero */
write_queue(self, NULL, 0);
do
{
sock = PQsocket(self->conn);
FD_ZERO(&input_mask);
FD_SET(sock, &input_mask);
while (select(sock + 1, &input_mask, NULL, NULL, NULL) < 0)
{
if (errno == EINTR)
{
CHECK_FOR_INTERRUPTS();
continue;
}
ereport(ERROR,
(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("select() failed"),
errdetail("%s", finish_and_get_message(self))));
}
PQconsumeInput(self->conn);
} while (PQisBusy(self->conn));
res = PQgetResult(self->conn);
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
PQfinish(self->conn);
self->conn = NULL;
transfer_message(NULL, res);
}
else
{
self->base.count = ParseInt64(PQgetvalue(res, 0, 1), 0);
ret.num_dup_new = ParseInt64(PQgetvalue(res, 0, 3), 0);
ret.num_dup_old = ParseInt64(PQgetvalue(res, 0, 4), 0);
PQclear(res);
/* commit transaction */
res = PQexec(self->conn, "COMMIT");
if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
ereport(ERROR,
(errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
errmsg("could not commit transaction"),
errdetail("%s", finish_and_get_message(self))));
}
}
PQclear(res);
}
else if (PQisBusy(self->conn))
{
char errbuf[256];
PGcancel *cancel = PQgetCancel(self->conn);
if (cancel)
PQcancel(cancel, errbuf, lengthof(errbuf));
}
if (self->conn)
PQfinish(self->conn);
self->conn = NULL;
}
/*
* Close self after wait for reader because reader hasn't opened the self
* yet. If we close self too early, the reader cannot open the self.
*/
if (self->queue)
QueueClose(self->queue);
self->queue = NULL;
if (!onError)
{
MemoryContextDelete(self->base.context);
if (self->base.rel)
heap_close(self->base.rel, NoLock);
}
return ret;
}
/*
* pgfdw_xact_callback --- cleanup at main-transaction end.
*/
static void
pgfdw_xact_callback(XactEvent event, void *arg)
{
HASH_SEQ_STATUS scan;
ConnCacheEntry *entry;
/* Quick exit if no connections were touched in this transaction. */
if (!xact_got_connection)
return;
/*
* Scan all connection cache entries to find open remote transactions, and
* close them.
*/
hash_seq_init(&scan, ConnectionHash);
while ((entry = (ConnCacheEntry *) hash_seq_search(&scan)))
{
PGresult *res;
/* Ignore cache entry if no open connection right now */
if (entry->conn == NULL)
continue;
/* If it has an open remote transaction, try to close it */
if (entry->xact_depth > 0)
{
elog(DEBUG3, "closing remote transaction on connection %p",
entry->conn);
switch (event)
{
case XACT_EVENT_PARALLEL_PRE_COMMIT:
case XACT_EVENT_PRE_COMMIT:
/* Commit all remote transactions during pre-commit */
do_sql_command(entry->conn, "COMMIT TRANSACTION");
/*
* If there were any errors in subtransactions, and we
* made prepared statements, do a DEALLOCATE ALL to make
* sure we get rid of all prepared statements. This is
* annoying and not terribly bulletproof, but it's
* probably not worth trying harder.
*
* DEALLOCATE ALL only exists in 8.3 and later, so this
* constrains how old a server postgres_fdw can
* communicate with. We intentionally ignore errors in
* the DEALLOCATE, so that we can hobble along to some
* extent with older servers (leaking prepared statements
* as we go; but we don't really support update operations
* pre-8.3 anyway).
*/
if (entry->have_prep_stmt && entry->have_error)
{
res = PQexec(entry->conn, "DEALLOCATE ALL");
PQclear(res);
}
entry->have_prep_stmt = false;
entry->have_error = false;
break;
case XACT_EVENT_PRE_PREPARE:
/*
* We disallow remote transactions that modified anything,
* since it's not very reasonable to hold them open until
* the prepared transaction is committed. For the moment,
* throw error unconditionally; later we might allow
* read-only cases. Note that the error will cause us to
* come right back here with event == XACT_EVENT_ABORT, so
* we'll clean up the connection state at that point.
*/
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot prepare a transaction that modified remote tables")));
break;
case XACT_EVENT_PARALLEL_COMMIT:
case XACT_EVENT_COMMIT:
case XACT_EVENT_PREPARE:
/* Pre-commit should have closed the open transaction */
elog(ERROR, "missed cleaning up connection during pre-commit");
break;
case XACT_EVENT_PARALLEL_ABORT:
case XACT_EVENT_ABORT:
/* Assume we might have lost track of prepared statements */
entry->have_error = true;
/*
* If a command has been submitted to the remote server by
* using an asynchronous execution function, the command
* might not have yet completed. Check to see if a
* command is still being processed by the remote server,
* and if so, request cancellation of the command.
*/
if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE)
{
PGcancel *cancel;
char errbuf[256];
if ((cancel = PQgetCancel(entry->conn)))
{
if (!PQcancel(cancel, errbuf, sizeof(errbuf)))
ereport(WARNING,
(errcode(ERRCODE_CONNECTION_FAILURE),
errmsg("could not send cancel request: %s",
errbuf)));
PQfreeCancel(cancel);
}
}
/* If we're aborting, abort all remote transactions too */
res = PQexec(entry->conn, "ABORT TRANSACTION");
/* Note: can't throw ERROR, it would be infinite loop */
if (PQresultStatus(res) != PGRES_COMMAND_OK)
pgfdw_report_error(WARNING, res, entry->conn, true,
"ABORT TRANSACTION");
else
{
PQclear(res);
/* As above, make sure to clear any prepared stmts */
if (entry->have_prep_stmt && entry->have_error)
{
res = PQexec(entry->conn, "DEALLOCATE ALL");
PQclear(res);
}
entry->have_prep_stmt = false;
entry->have_error = false;
}
break;
}
}
/* Reset state to show we're out of a transaction */
entry->xact_depth = 0;
/*
* If the connection isn't in a good idle state, discard it to
* recover. Next GetConnection will open a new connection.
*/
if (PQstatus(entry->conn) != CONNECTION_OK ||
PQtransactionStatus(entry->conn) != PQTRANS_IDLE)
{
elog(DEBUG3, "discarding connection %p", entry->conn);
PQfinish(entry->conn);
entry->conn = NULL;
}
}
/*
* Regardless of the event type, we can now mark ourselves as out of the
* transaction. (Note: if we are here during PRE_COMMIT or PRE_PREPARE,
* this saves a useless scan of the hashtable during COMMIT or PREPARE.)
*/
xact_got_connection = false;
/* Also reset cursor numbering for next transaction */
cursor_number = 0;
}
/*
* Run one permutation
*/
static void
run_permutation(TestSpec * testspec, int nsteps, Step ** steps)
{
PGresult *res;
int i;
Step *waiting = NULL;
/*
* In dry run mode, just display the permutation in the same format used
* by spec files, and return.
*/
if (dry_run)
{
printf("permutation");
for (i = 0; i < nsteps; i++)
printf(" \"%s\"", steps[i]->name);
printf("\n");
return;
}
printf("\nstarting permutation:");
for (i = 0; i < nsteps; i++)
printf(" %s", steps[i]->name);
printf("\n");
/* Perform setup */
for (i = 0; i < testspec->nsetupsqls; i++)
{
res = PQexec(conns[0], testspec->setupsqls[i]);
if (PQresultStatus(res) == PGRES_TUPLES_OK)
{
printResultSet(res);
}
else if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "setup failed: %s", PQerrorMessage(conns[0]));
exit_nicely();
}
PQclear(res);
}
/* Perform per-session setup */
for (i = 0; i < testspec->nsessions; i++)
{
if (testspec->sessions[i]->setupsql)
{
res = PQexec(conns[i + 1], testspec->sessions[i]->setupsql);
if (PQresultStatus(res) == PGRES_TUPLES_OK)
{
printResultSet(res);
}
else if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "setup of session %s failed: %s",
testspec->sessions[i]->name,
PQerrorMessage(conns[i + 1]));
exit_nicely();
}
PQclear(res);
}
}
/* Perform steps */
for (i = 0; i < nsteps; i++)
{
Step *step = steps[i];
PGconn *conn = conns[1 + step->session];
if (waiting != NULL && step->session == waiting->session)
{
PGcancel *cancel;
PGresult *res;
int j;
/*
* This permutation is invalid: it can never happen in real life.
*
* A session is blocked on an earlier step (waiting) and no
* further steps from this session can run until it is unblocked,
* but it can only be unblocked by running steps from other
* sessions.
*/
fflush(stdout);
fprintf(stderr, "invalid permutation detected\n");
fflush(stderr);
/* Cancel the waiting statement from this session. */
cancel = PQgetCancel(conn);
if (cancel != NULL)
{
char buf[256];
if (!PQcancel(cancel, buf, sizeof(buf)))
fprintf(stderr, "PQcancel failed: %s\n", buf);
/* Be sure to consume the error message. */
while ((res = PQgetResult(conn)) != NULL)
PQclear(res);
PQfreeCancel(cancel);
}
/*
* Now we really have to complete all the running transactions to
* make sure teardown doesn't block.
*/
for (j = 1; j < nconns; j++)
{
res = PQexec(conns[j], "ROLLBACK");
if (res != NULL)
PQclear(res);
}
goto teardown;
}
if (!PQsendQuery(conn, step->sql))
{
fprintf(stdout, "failed to send query for step %s: %s\n",
step->name, PQerrorMessage(conns[1 + step->session]));
exit_nicely();
}
if (waiting != NULL)
{
/* Some other step is already waiting: just block. */
try_complete_step(step, 0);
/*
* See if this step unblocked the waiting step; report both error
* messages together if so.
*/
if (!try_complete_step(waiting, STEP_NONBLOCK | STEP_RETRY))
{
report_two_error_messages(step, waiting);
waiting = NULL;
}
else
report_error_message(step);
}
else
{
if (try_complete_step(step, STEP_NONBLOCK))
waiting = step;
report_error_message(step);
}
}
/* Finish any waiting query. */
if (waiting != NULL)
{
try_complete_step(waiting, STEP_RETRY);
report_error_message(waiting);
}
teardown:
/* Perform per-session teardown */
for (i = 0; i < testspec->nsessions; i++)
{
if (testspec->sessions[i]->teardownsql)
{
res = PQexec(conns[i + 1], testspec->sessions[i]->teardownsql);
if (PQresultStatus(res) == PGRES_TUPLES_OK)
{
printResultSet(res);
}
else if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "teardown of session %s failed: %s",
testspec->sessions[i]->name,
PQerrorMessage(conns[i + 1]));
/* don't exit on teardown failure */
fflush(stderr);
}
PQclear(res);
}
}
/* Perform teardown */
if (testspec->teardownsql)
{
res = PQexec(conns[0], testspec->teardownsql);
if (PQresultStatus(res) == PGRES_TUPLES_OK)
{
printResultSet(res);
}
else if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "teardown failed: %s",
PQerrorMessage(conns[0]));
/* don't exit on teardown failure */
fflush(stderr);
}
PQclear(res);
}
}
/*
* Our caller already sent the query associated with this step. Wait for it
* to either complete or (if given the STEP_NONBLOCK flag) to block while
* waiting for a lock. We assume that any lock wait will persist until we
* have executed additional steps in the permutation.
*
* When calling this function on behalf of a given step for a second or later
* time, pass the STEP_RETRY flag. This only affects the messages printed.
*
* If the query returns an error, the message is saved in step->errormsg.
* Caller should call report_error_message shortly after this, to have it
* printed and cleared.
*
* If the STEP_NONBLOCK flag was specified and the query is waiting to acquire
* a lock, returns true. Otherwise, returns false.
*/
static bool
try_complete_step(Step *step, int flags)
{
PGconn *conn = conns[1 + step->session];
fd_set read_set;
struct timeval start_time;
struct timeval timeout;
int sock = PQsocket(conn);
int ret;
PGresult *res;
bool canceled = false;
if (sock < 0)
{
fprintf(stderr, "invalid socket: %s", PQerrorMessage(conn));
exit_nicely();
}
gettimeofday(&start_time, NULL);
FD_ZERO(&read_set);
while (PQisBusy(conn))
{
FD_SET(sock, &read_set);
timeout.tv_sec = 0;
timeout.tv_usec = 10000; /* Check for lock waits every 10ms. */
ret = select(sock + 1, &read_set, NULL, NULL, &timeout);
if (ret < 0) /* error in select() */
{
if (errno == EINTR)
continue;
fprintf(stderr, "select failed: %s\n", strerror(errno));
exit_nicely();
}
else if (ret == 0) /* select() timeout: check for lock wait */
{
struct timeval current_time;
int64 td;
/* If it's OK for the step to block, check whether it has. */
if (flags & STEP_NONBLOCK)
{
bool waiting;
res = PQexecPrepared(conns[0], PREP_WAITING, 1,
&backend_pids[step->session + 1],
NULL, NULL, 0);
if (PQresultStatus(res) != PGRES_TUPLES_OK ||
PQntuples(res) != 1)
{
fprintf(stderr, "lock wait query failed: %s",
PQerrorMessage(conn));
exit_nicely();
}
waiting = ((PQgetvalue(res, 0, 0))[0] == 't');
PQclear(res);
if (waiting) /* waiting to acquire a lock */
{
if (!(flags & STEP_RETRY))
printf("step %s: %s <waiting ...>\n",
step->name, step->sql);
return true;
}
/* else, not waiting */
}
/* Figure out how long we've been waiting for this step. */
gettimeofday(¤t_time, NULL);
td = (int64) current_time.tv_sec - (int64) start_time.tv_sec;
td *= USECS_PER_SEC;
td += (int64) current_time.tv_usec - (int64) start_time.tv_usec;
/*
* After 60 seconds, try to cancel the query.
*
* If the user tries to test an invalid permutation, we don't want
* to hang forever, especially when this is running in the
* buildfarm. So try to cancel it after a minute. This will
* presumably lead to this permutation failing, but remaining
* permutations and tests should still be OK.
*/
if (td > 60 * USECS_PER_SEC && !canceled)
{
PGcancel *cancel = PQgetCancel(conn);
if (cancel != NULL)
{
char buf[256];
if (PQcancel(cancel, buf, sizeof(buf)))
canceled = true;
else
fprintf(stderr, "PQcancel failed: %s\n", buf);
PQfreeCancel(cancel);
}
}
/*
* After 75 seconds, just give up and die.
*
* Since cleanup steps won't be run in this case, this may cause
* later tests to fail. That stinks, but it's better than waiting
* forever for the server to respond to the cancel.
*/
if (td > 75 * USECS_PER_SEC)
{
fprintf(stderr, "step %s timed out after 75 seconds\n",
step->name);
exit_nicely();
}
}
else if (!PQconsumeInput(conn)) /* select(): data available */
{
fprintf(stderr, "PQconsumeInput failed: %s\n",
PQerrorMessage(conn));
exit_nicely();
}
}
if (flags & STEP_RETRY)
printf("step %s: <... completed>\n", step->name);
else
printf("step %s: %s\n", step->name, step->sql);
while ((res = PQgetResult(conn)))
{
switch (PQresultStatus(res))
{
case PGRES_COMMAND_OK:
break;
case PGRES_TUPLES_OK:
printResultSet(res);
break;
case PGRES_FATAL_ERROR:
if (step->errormsg != NULL)
{
printf("WARNING: this step had a leftover error message\n");
printf("%s\n", step->errormsg);
}
/*
* Detail may contain XID values, so we want to just show
* primary. Beware however that libpq-generated error results
* may not contain subfields, only an old-style message.
*/
{
const char *sev = PQresultErrorField(res,
PG_DIAG_SEVERITY);
const char *msg = PQresultErrorField(res,
PG_DIAG_MESSAGE_PRIMARY);
if (sev && msg)
step->errormsg = psprintf("%s: %s", sev, msg);
else
step->errormsg = pg_strdup(PQresultErrorMessage(res));
}
break;
default:
printf("unexpected result status: %s\n",
PQresStatus(PQresultStatus(res)));
}
PQclear(res);
}
return false;
}
