From 1889e15035d1e3eadf5372b0255b24c6a22b3f5b Mon Sep 17 00:00:00 2001 From: Greg Nancarrow Date: Tue, 1 Dec 2020 15:27:28 +1100 Subject: [PATCH v20 2/2] Enhance the libpq "target_session_attrs" connection parameter. Enhance the connection parameter "target_session_attrs" to support new values: read-only/primary/standby/prefer-standby. Add a new "read-only" target_session_attrs option value, to support connecting to a read-only server if available from the list of hosts (otherwise the connection attempt fails). Add a new "primary" target_session_attrs option value, to support connecting to a server which is not in hot-standby mode, if available from the list of hosts (otherwise the connection attempt fails). Add a new "standby" target_session_attrs option value, to support connecting to a server which is in hot-standby mode, if available from the list of hosts (otherwise the connection attempt fails). Add a new "prefer-standby" target_session_attrs option value, to support connecting to a server which is in hot-standby mode, if available from the list of hosts (otherwise connect to a server which is not in hot-standby mode). Discussion: https://www.postgresql.org/message-id/flat/CAF3+xM+8-ztOkaV9gHiJ3wfgENTq97QcjXQt+rbFQ6F7oNzt9A@mail.gmail.com --- doc/src/sgml/libpq.sgml | 76 ++++- doc/src/sgml/protocol.sgml | 9 +- src/interfaces/libpq/fe-connect.c | 505 ++++++++++++++++++++++++++++++---- src/interfaces/libpq/fe-exec.c | 18 +- src/interfaces/libpq/libpq-fe.h | 3 +- src/interfaces/libpq/libpq-int.h | 50 +++- src/test/recovery/t/001_stream_rep.pl | 79 +++++- 7 files changed, 650 insertions(+), 90 deletions(-) diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml index 1553f9c..b062086 100644 --- a/doc/src/sgml/libpq.sgml +++ b/doc/src/sgml/libpq.sgml @@ -1817,18 +1817,61 @@ postgresql://%2Fvar%2Flib%2Fpostgresql/dbname target_session_attrs - If this parameter is set to read-write, only a - connection in which read-write transactions are accepted by default - is considered acceptable. The query - SHOW transaction_read_only will be sent upon any - successful connection; if it returns on, the connection - will be closed. If multiple hosts were specified in the connection - string, any remaining servers will be tried just as if the connection - attempt had failed. The default value of this parameter, - any, regards all connections as acceptable. - + The supported options for this parameter are any, + read-write, read-only, + primary, standby and + prefer-standby. + The default value of this parameter, any, regards + all connections as acceptable. If multiple hosts are specified in the + connection string, each host is tried in the order given until a connection + is successful. + + + + The support of read-write transactions is determined by the value of the + transaction_read_only configuration parameter, that is + either reported by the server (if supported) upon successful connection or + is otherwise explicitly queried by sending + SHOW transaction_read_only after successful connection; if + it returns on, it means the server doesn't support + read-write transactions. The standby mode state is determined by either the + value of the in_hot_standby configuration parameter, that is + reported by the server (if supported) upon successful connection, or is + otherwise explicitly queried by sending + SELECT pg_is_in_recovery() after successful connection; if + it returns t, it means the server is in hot standby mode. + + + + If this parameter is set to read-write, only a connection in + which read-write transactions are accepted by default is considered acceptable. + + + + If this parameter is set to read-only, only a connection in + which read-only transactions are accepted by default is considered acceptable. + + + + If this parameter is set to primary, then only a connection in + which the server is not in hot standby mode is considered acceptable. + + + + If this parameter is set to standby, then only a connection in + which the server is in hot standby mode is considered acceptable. + + + + If this parameter is set to prefer-standby, then a connection + in which the server is in hot standby mode is preferred. Otherwise, if no such + connections can be found, then a connection in which the server is not in hot + standby mode will be considered. + + - + + @@ -2136,14 +2179,18 @@ const char *PQparameterStatus(const PGconn *conn, const char *paramName); DateStyle, IntervalStyle, TimeZone, - integer_datetimes, and - standard_conforming_strings. + integer_datetimes, + standard_conforming_strings, + transaction_read_only, and + in_hot_standby. (server_encoding, TimeZone, and integer_datetimes were not reported by releases before 8.0; standard_conforming_strings was not reported by releases before 8.1; IntervalStyle was not reported by releases before 8.4; - application_name was not reported by releases before 9.0.) + application_name was not reported by releases before 9.0; + transaction_read_only and in_hot_standby + were not reported by releases before 14.0.) Note that server_version, server_encoding and @@ -7245,6 +7292,7 @@ myEventProc(PGEventId evtId, void *evtInfo, void *passThrough) linkend="libpq-connect-target-session-attrs"/> connection parameter. + diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml index cee2888..e45dfc6 100644 --- a/doc/src/sgml/protocol.sgml +++ b/doc/src/sgml/protocol.sgml @@ -1283,14 +1283,17 @@ SELCT 1/0; DateStyle, IntervalStyle, TimeZone, - integer_datetimes, and - standard_conforming_strings. + integer_datetimes, + standard_conforming_strings, + transaction_read_only, and + in_hot_standby. (server_encoding, TimeZone, and integer_datetimes were not reported by releases before 8.0; standard_conforming_strings was not reported by releases before 8.1; IntervalStyle was not reported by releases before 8.4; - application_name was not reported by releases before 9.0.) + application_name was not reported by releases before 9.0; + transaction_read_only and in_hot_standby were not reported by releases before 14.0.) Note that server_version, server_encoding and diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index 7d04d36..eb7457a 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -352,7 +352,7 @@ static const internalPQconninfoOption PQconninfoOptions[] = { {"target_session_attrs", "PGTARGETSESSIONATTRS", DefaultTargetSessionAttrs, NULL, - "Target-Session-Attrs", "", 11, /* sizeof("read-write") = 11 */ + "Target-Session-Attrs", "", 15, /* sizeof("prefer-standby") = 15 */ offsetof(struct pg_conn, target_session_attrs)}, /* Terminating entry --- MUST BE LAST */ @@ -1002,6 +1002,33 @@ parse_comma_separated_list(char **startptr, bool *more) } /* + * validateAndGetTargetServerType + * + * Validate a given target_session_attrs value and get the requested server type. + * + * Returns true if OK, false if the specified option value is invalid. + */ +static bool +validateAndGetTargetServerType(const char *optionValue, TargetServerType *requestedServerType) +{ + if (strcmp(optionValue, "any") == 0) + *requestedServerType = SERVER_TYPE_ANY; + else if (strcmp(optionValue, "primary") == 0) + *requestedServerType = SERVER_TYPE_PRIMARY; + else if (strcmp(optionValue, "read-write") == 0) + *requestedServerType = SERVER_TYPE_READ_WRITE; + else if (strcmp(optionValue, "read-only") == 0) + *requestedServerType = SERVER_TYPE_READ_ONLY; + else if (strcmp(optionValue, "prefer-standby") == 0) + *requestedServerType = SERVER_TYPE_PREFER_STANDBY; + else if (strcmp(optionValue, "standby") == 0) + *requestedServerType = SERVER_TYPE_STANDBY; + else + return false; + return true; +} + +/* * connectOptions2 * * Compute derived connection options after absorbing all user-supplied info. @@ -1397,13 +1424,12 @@ connectOptions2(PGconn *conn) */ if (conn->target_session_attrs) { - if (strcmp(conn->target_session_attrs, "any") != 0 - && strcmp(conn->target_session_attrs, "read-write") != 0) + if (!validateAndGetTargetServerType(conn->target_session_attrs, &conn->requested_server_type)) { conn->status = CONNECTION_BAD; printfPQExpBuffer(&conn->errorMessage, libpq_gettext("invalid %s value: \"%s\"\n"), - "target_settion_attrs", + "target_session_attrs", conn->target_session_attrs); return false; } @@ -2229,6 +2255,102 @@ restoreErrorMessage(PGconn *conn, PQExpBuffer savedMessage) termPQExpBuffer(savedMessage); } +/* + * Internal helper function used for rejecting (and closing) a connection that + * doesn't satisfy the requested server type (read-write/read-only). + * The connection state is set to try the next host (if any). + */ +static void +rejectCheckedReadOrWriteConnection(PGconn *conn) +{ + /* Not a requested type; fail this connection. */ + const char *displayed_host; + const char *displayed_port; + + /* Append error report to conn->errorMessage. */ + if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS) + displayed_host = conn->connhost[conn->whichhost].hostaddr; + else + displayed_host = conn->connhost[conn->whichhost].host; + displayed_port = conn->connhost[conn->whichhost].port; + if (displayed_port == NULL || displayed_port[0] == '\0') + displayed_port = DEF_PGPORT_STR; + + if (conn->requested_server_type == SERVER_TYPE_PRIMARY) + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not make a writable " + "connection to server " + "\"%s:%s\"\n"), + displayed_host, displayed_port); + else + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not make a readonly " + "connection to server " + "\"%s:%s\"\n"), + displayed_host, displayed_port); + + /* Close connection politely. */ + conn->status = CONNECTION_OK; + sendTerminateConn(conn); + + /* + * Try next host if any, but we don't want to consider additional + * addresses for this host. + */ + conn->try_next_host = true; +} + +/* + * Internal helper function used for rejecting (and closing) a connection that + * doesn't satisfy the requested server type (for standby). The connection state + * is set to try the next host (if any). + * In the case of SERVER_TYPE_PREFER_STANDBY, if the primary host-index hasn't + * been set, then it is set to the index of this connection's host, so that a + * connection to this host can be made again in the event that no connection to + * a standby host could be made after the first host scan. + */ +static void +rejectCheckedStandbyConnection(PGconn *conn) +{ + /* Not a requested type; fail this connection. */ + const char *displayed_host; + const char *displayed_port; + + /* Append error report to conn->errorMessage. */ + if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS) + displayed_host = conn->connhost[conn->whichhost].hostaddr; + else + displayed_host = conn->connhost[conn->whichhost].host; + displayed_port = conn->connhost[conn->whichhost].port; + if (displayed_port == NULL || displayed_port[0] == '\0') + displayed_port = DEF_PGPORT_STR; + + if (conn->requested_server_type == SERVER_TYPE_PRIMARY) + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("server is in hot standby mode " + "\"%s:%s\"\n"), + displayed_host, displayed_port); + else + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("server is not in hot standby mode " + "\"%s:%s\"\n"), + displayed_host, displayed_port); + + /* Close connection politely. */ + conn->status = CONNECTION_OK; + sendTerminateConn(conn); + + /* Record primary host index */ + if (conn->requested_server_type == SERVER_TYPE_PREFER_STANDBY && conn->which_primary_host == -1) + conn->which_primary_host = conn->whichhost; + + /* + * Try next host if any, but we don't want to consider additional + * addresses for this host. + */ + conn->try_next_host = true; +} + /* ---------------- * PQconnectPoll * @@ -2311,6 +2433,7 @@ PQconnectPoll(PGconn *conn) case CONNECTION_CHECK_WRITABLE: case CONNECTION_CONSUME: case CONNECTION_GSS_STARTUP: + case CONNECTION_CHECK_STANDBY: break; default: @@ -2347,13 +2470,33 @@ keep_going: /* We will come back to here until there is if (conn->whichhost + 1 >= conn->nconnhost) { - /* - * Oops, no more hosts. An appropriate error message is already - * set up, so just set the right status. - */ - goto error_return; + if (conn->which_primary_host >= 0) + { + /* + * Getting here means we failed to connect to standby servers + * and should now try to re-connect to a previously-connected-to + * primary server, whose host index is recorded in + * which_primary_host. + */ + conn->whichhost = conn->which_primary_host; + + /* + * Reset the host index value to avoid recursion during the + * second connection attempt. + */ + conn->which_primary_host = -2; + } + else + { + /* + * Oops, no more hosts. An appropriate error message is + * already set up, so just set the right status. + */ + goto error_return; + } } - conn->whichhost++; + else + conn->whichhost++; /* Drop any address info for previous host */ release_conn_addrinfo(conn); @@ -3560,39 +3703,183 @@ keep_going: /* We will come back to here until there is case CONNECTION_CHECK_TARGET: { - /* - * If a read-write connection is required, see if we have one. - * - * Servers before 7.4 lack the transaction_read_only GUC, but - * by the same token they don't have any read-only mode, so we - * may just skip the test in that case. - */ - if (conn->sversion >= 70400 && - conn->target_session_attrs != NULL && - strcmp(conn->target_session_attrs, "read-write") == 0) + if (conn->requested_server_type != SERVER_TYPE_ANY) { /* - * Save existing error messages across the PQsendQuery - * attempt. This is necessary because PQsendQuery is - * going to reset conn->errorMessage, so we would lose - * error messages related to previous hosts we have tried - * and failed to connect to. + * If a read-write or read-only connection is required, see if + * we have one. + * + * Servers before 7.4 lack the transaction_read_only GUC, but + * by the same token they don't have any read-only mode, so we + * may just skip the test in that case. */ - if (!saveErrorMessage(conn, &savedMessage)) - goto error_return; + if (conn->sversion >= 70400 && + (conn->requested_server_type == SERVER_TYPE_READ_WRITE || + conn->requested_server_type == SERVER_TYPE_READ_ONLY)) + { + /* + * For servers which don't have "transaction_read_only" as + * a GUC_REPORT variable, it in necessary to determine if + * they are read-only by sending the query + * "SHOW transaction_read_only". + */ + if (conn->transaction_read_only == GUC_BOOL_UNKNOWN) + { + /* + * Save existing error messages across the + * PQsendQuery attempt. This is necessary because + * PQsendQuery is going to reset + * conn->errorMessage, so we would lose error + * messages related to previous hosts we have + * tried and failed to connect to. + */ + if (!saveErrorMessage(conn, &savedMessage)) + goto error_return; + + conn->status = CONNECTION_OK; + if (!PQsendQuery(conn, "SHOW transaction_read_only")) + { + restoreErrorMessage(conn, &savedMessage); + goto error_return; + } + conn->status = CONNECTION_CHECK_WRITABLE; + restoreErrorMessage(conn, &savedMessage); + return PGRES_POLLING_READING; + } + else if ((conn->transaction_read_only == GUC_BOOL_YES && + conn->requested_server_type == SERVER_TYPE_READ_WRITE) || + (conn->transaction_read_only == GUC_BOOL_NO && + conn->requested_server_type == SERVER_TYPE_READ_ONLY)) + { + /* + * Server is read-only but requested read-write, + * or server is read-write but requested + * read-only, reject and continue to process any + * further hosts ... + */ + + rejectCheckedReadOrWriteConnection(conn); + goto keep_going; + } - conn->status = CONNECTION_OK; - if (!PQsendQuery(conn, - "SHOW transaction_read_only")) + /* obtained the requested type, consume it */ + goto consume_checked_target_connection; + } + + /* + * Servers before 9.0 don't support standby mode, skip the + * check when the requested type of connection is primary, + * prefer-standby or standby. + */ + else if ((conn->sversion >= 90000 && + (conn->requested_server_type == SERVER_TYPE_PRIMARY || + conn->requested_server_type == SERVER_TYPE_PREFER_STANDBY || + conn->requested_server_type == SERVER_TYPE_STANDBY))) { - restoreErrorMessage(conn, &savedMessage); - goto error_return; + /* + * For servers which don't have the "in_hot_standby" GUC_REPORT + * variable, it in necessary to determine if they are in hot + * standby mode by sending the query "SELECT pg_is_in_recovery()". + */ + if (conn->in_hot_standby == GUC_BOOL_UNKNOWN) + { + /* + * Save existing error messages across the PQsendQuery + * attempt. This is necessary because PQsendQuery is + * going to reset conn->errorMessage, so we would lose + * error messages related to previous hosts we have + * tried and failed to connect to. + */ + if (!saveErrorMessage(conn, &savedMessage)) + goto error_return; + + conn->status = CONNECTION_OK; + if (!PQsendQuery(conn, "SELECT pg_is_in_recovery()")) + { + restoreErrorMessage(conn, &savedMessage); + goto error_return; + } + + conn->status = CONNECTION_CHECK_STANDBY; + + restoreErrorMessage(conn, &savedMessage); + return PGRES_POLLING_READING; + } + else if ((conn->in_hot_standby == GUC_BOOL_YES && + conn->requested_server_type == SERVER_TYPE_PRIMARY) || + (conn->in_hot_standby == GUC_BOOL_NO && + (conn->requested_server_type == SERVER_TYPE_PREFER_STANDBY || + conn->requested_server_type == SERVER_TYPE_STANDBY))) + { + /* + * Server is in standby but requested primary, or + * server is not in standby but requested + * prefer-standby/standby, reject and continue to + * process any further hosts ... + */ + + if (conn->which_primary_host == -2) + { + /* + * This scenario is possible only for the + * prefer-standby type for the next pass of + * the list of connections, as it couldn't find + * any servers that are in standby mode. + */ + goto consume_checked_target_connection; + } + + rejectCheckedStandbyConnection(conn); + goto keep_going; + } + + /* obtained the requested type, consume it */ + goto consume_checked_target_connection; + } + + /* + * If the requested type is prefer-standby, then record this host + * index and try any others before considering it later. If the + * requested type of connection is read-only or standby, ignore + * this connection, as servers of this version don't support this + * type of connection. + */ + if (conn->requested_server_type == SERVER_TYPE_PREFER_STANDBY || + conn->requested_server_type == SERVER_TYPE_READ_ONLY || + conn->requested_server_type == SERVER_TYPE_STANDBY) + { + if (conn->which_primary_host == -2) + { + /* + * This scenario is possible only for the prefer-standby + * type for the next pass of the list of connections, as + * it couldn't find any servers that are in standby mode. + */ + goto consume_checked_target_connection; + } + + /* Close connection politely. */ + conn->status = CONNECTION_OK; + sendTerminateConn(conn); + + /* Record host index */ + if (conn->requested_server_type == SERVER_TYPE_PREFER_STANDBY) + { + if (conn->which_primary_host == -1) + conn->which_primary_host = conn->whichhost; + } + + /* + * Try the next host, if any, but we don't want to consider + * additional addresses for this host. + */ + conn->try_next_host = true; + goto keep_going; } - conn->status = CONNECTION_CHECK_WRITABLE; - restoreErrorMessage(conn, &savedMessage); - return PGRES_POLLING_READING; } + consume_checked_target_connection: + /* We can release the address list now. */ release_conn_addrinfo(conn); @@ -3664,6 +3951,7 @@ keep_going: /* We will come back to here until there is conn->status = CONNECTION_OK; return PGRES_POLLING_OK; } + case CONNECTION_CHECK_WRITABLE: { const char *displayed_host; @@ -3691,42 +3979,135 @@ keep_going: /* We will come back to here until there is PQntuples(res) == 1) { char *val; + bool readonly_server; val = PQgetvalue(res, 0, 0); - if (strncmp(val, "on", 2) == 0) + readonly_server = (strncmp(val, "on", 2) == 0); + + /* + * Server is read-only and requested server type is read-write, + * ignore this connection. Server is read-write and requested + * type is read-only, ignore this connection. + */ + if ((readonly_server && + (conn->requested_server_type == SERVER_TYPE_READ_WRITE)) || + (!readonly_server && + (conn->requested_server_type == SERVER_TYPE_READ_ONLY))) { - /* Not writable; fail this connection. */ + /* Not a requested type; fail this connection. */ PQclear(res); restoreErrorMessage(conn, &savedMessage); - /* Append error report to conn->errorMessage. */ - if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS) - displayed_host = conn->connhost[conn->whichhost].hostaddr; - else - displayed_host = conn->connhost[conn->whichhost].host; - displayed_port = conn->connhost[conn->whichhost].port; - if (displayed_port == NULL || displayed_port[0] == '\0') - displayed_port = DEF_PGPORT_STR; + rejectCheckedReadOrWriteConnection(conn); + goto keep_going; + } - appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("could not make a writable " - "connection to server " - "\"%s:%s\"\n"), - displayed_host, displayed_port); + /* Session is requested type, so we're good. */ + PQclear(res); + termPQExpBuffer(&savedMessage); - /* Close connection politely. */ - conn->status = CONNECTION_OK; - sendTerminateConn(conn); + /* + * Finish reading any remaining messages before being + * considered as ready. + */ + conn->status = CONNECTION_CONSUME; + goto keep_going; + } + + /* + * Something went wrong with "SHOW transaction_read_only". We + * should try next addresses. + */ + if (res) + PQclear(res); + restoreErrorMessage(conn, &savedMessage); + + /* Append error report to conn->errorMessage. */ + if (conn->connhost[conn->whichhost].type == CHT_HOST_ADDRESS) + displayed_host = conn->connhost[conn->whichhost].hostaddr; + else + displayed_host = conn->connhost[conn->whichhost].host; + displayed_port = conn->connhost[conn->whichhost].port; + if (displayed_port == NULL || displayed_port[0] == '\0') + displayed_port = DEF_PGPORT_STR; + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("test \"SHOW transaction_read_only\" failed " + "on server \"%s:%s\"\n"), + displayed_host, displayed_port); + + /* Close connection politely. */ + conn->status = CONNECTION_OK; + sendTerminateConn(conn); + + /* Try next address */ + conn->try_next_addr = true; + goto keep_going; + } + + case CONNECTION_CHECK_STANDBY: + { + const char *displayed_host; + const char *displayed_port; + + if (!saveErrorMessage(conn, &savedMessage)) + goto error_return; + + conn->status = CONNECTION_OK; + if (!PQconsumeInput(conn)) + { + restoreErrorMessage(conn, &savedMessage); + goto error_return; + } + + if (PQisBusy(conn)) + { + conn->status = CONNECTION_CHECK_STANDBY; + restoreErrorMessage(conn, &savedMessage); + return PGRES_POLLING_READING; + } + res = PQgetResult(conn); + if (res && (PQresultStatus(res) == PGRES_TUPLES_OK) && + PQntuples(res) == 1) + { + char *val; + bool standby_server; + + val = PQgetvalue(res, 0, 0); + standby_server = (strncmp(val, "t", 1) == 0); + + /* + * Server is in standby mode and requested mode is + * primary, ignore it. Server is not in standby mode and + * requested mode is prefer-standby, record it for the + * first time and try to consume in the next scan (it + * means no standby server was found in the first scan). + */ + if ((standby_server && + conn->requested_server_type == SERVER_TYPE_PRIMARY) || + (!standby_server && + (conn->requested_server_type == SERVER_TYPE_PREFER_STANDBY || + conn->requested_server_type == SERVER_TYPE_STANDBY))) + { /* - * Try next host if any, but we don't want to consider - * additional addresses for this host. + * The following scenario is possible only for the + * prefer-standby mode for the next pass of the list + * of connections, as it couldn't find any servers that + * are in standby mode. */ - conn->try_next_host = true; + if (conn->which_primary_host == -2) + goto consume_checked_standby_connection; + + /* Not a requested type; fail this connection. */ + PQclear(res); + restoreErrorMessage(conn, &savedMessage); + + rejectCheckedStandbyConnection(conn); goto keep_going; } - /* Session is read-write, so we're good. */ + consume_checked_standby_connection: + /* Session is requested type, so we're good. */ PQclear(res); termPQExpBuffer(&savedMessage); @@ -3739,7 +4120,7 @@ keep_going: /* We will come back to here until there is } /* - * Something went wrong with "SHOW transaction_read_only". We + * Something went wrong with "SELECT pg_is_in_recovery()". We * should try next addresses. */ if (res) @@ -3755,7 +4136,7 @@ keep_going: /* We will come back to here until there is if (displayed_port == NULL || displayed_port[0] == '\0') displayed_port = DEF_PGPORT_STR; appendPQExpBuffer(&conn->errorMessage, - libpq_gettext("test \"SHOW transaction_read_only\" failed " + libpq_gettext("test \"SELECT pg_is_in_recovery()\" failed " "on server \"%s:%s\"\n"), displayed_host, displayed_port); @@ -3767,7 +4148,6 @@ keep_going: /* We will come back to here until there is conn->try_next_addr = true; goto keep_going; } - default: appendPQExpBuffer(&conn->errorMessage, libpq_gettext("invalid connection state %d, " @@ -3911,10 +4291,15 @@ makeEmptyPGconn(void) conn->setenv_state = SETENV_STATE_IDLE; conn->client_encoding = PG_SQL_ASCII; conn->std_strings = false; /* unless server says differently */ + conn->transaction_read_only = GUC_BOOL_UNKNOWN; + conn->in_hot_standby = GUC_BOOL_UNKNOWN; conn->verbosity = PQERRORS_DEFAULT; conn->show_context = PQSHOW_CONTEXT_ERRORS; conn->sock = PGINVALID_SOCKET; + conn->requested_server_type = SERVER_TYPE_ANY; + conn->which_primary_host = -1; + /* * We try to send at least 8K at a time, which is the usual size of pipe * buffers on Unix systems. That way, when we are sending a large amount diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c index eea0237..ff92ee2 100644 --- a/src/interfaces/libpq/fe-exec.c +++ b/src/interfaces/libpq/fe-exec.c @@ -1058,11 +1058,11 @@ pqSaveParameterStatus(PGconn *conn, const char *name, const char *value) } /* - * Special hacks: remember client_encoding and - * standard_conforming_strings, and convert server version to a numeric - * form. We keep the first two of these in static variables as well, so - * that PQescapeString and PQescapeBytea can behave somewhat sanely (at - * least in single-connection-using programs). + * Special hacks: remember client_encoding, transaction_read_only, + * in_hot_standby and standard_conforming_strings, and convert server + * version to a numeric form. We keep the first two of these in static + * variables as well, so that PQescapeString and PQescapeBytea can + * behave somewhat sanely (at least in single-connection-using programs). */ if (strcmp(name, "client_encoding") == 0) { @@ -1112,6 +1112,14 @@ pqSaveParameterStatus(PGconn *conn, const char *name, const char *value) else conn->sversion = 0; /* unknown */ } + else if (strcmp(name, "transaction_read_only") == 0) + { + conn->transaction_read_only = (strcmp(value, "on") == 0 ? GUC_BOOL_YES : GUC_BOOL_NO); + } + else if (strcmp(name, "in_hot_standby") == 0) + { + conn->in_hot_standby = (strcmp(value, "on") == 0 ? GUC_BOOL_YES : GUC_BOOL_NO); + } } diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h index 3b6a9fb..832035c 100644 --- a/src/interfaces/libpq/libpq-fe.h +++ b/src/interfaces/libpq/libpq-fe.h @@ -68,7 +68,8 @@ typedef enum CONNECTION_CONSUME, /* Wait for any pending message and consume * them. */ CONNECTION_GSS_STARTUP, /* Negotiating GSSAPI. */ - CONNECTION_CHECK_TARGET /* Check if we have a proper target connection */ + CONNECTION_CHECK_TARGET, /* Check if we have a proper target connection */ + CONNECTION_CHECK_STANDBY /* Check whether server is in standby mode */ } ConnStatusType; typedef enum diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h index 1de91ae..a0a73c8 100644 --- a/src/interfaces/libpq/libpq-int.h +++ b/src/interfaces/libpq/libpq-int.h @@ -317,6 +317,29 @@ typedef struct pg_conn_host * found in password file. */ } pg_conn_host; +/* Target server type to connect to */ +typedef enum +{ + SERVER_TYPE_ANY = 0, /* Any server (default) */ + SERVER_TYPE_READ_WRITE, /* Read-write server */ + SERVER_TYPE_READ_ONLY, /* Read-only server */ + SERVER_TYPE_PRIMARY, /* Primary server */ + SERVER_TYPE_PREFER_STANDBY, /* Prefer Standby server */ + SERVER_TYPE_STANDBY /* Standby server */ +} TargetServerType; + +/* + * State of certain bool GUCs used by libpq, which are determined + * either by the GUC_REPORT mechanism (where supported by the server + * version) or by lazy evaluation (using a query sent to the server). + */ +typedef enum +{ + GUC_BOOL_UNKNOWN = 0, /* Currently unknown */ + GUC_BOOL_YES, /* Yes (true) */ + GUC_BOOL_NO /* No (false) */ +} GucBoolState; + /* * PGconn stores all the state data associated with a single connection * to a backend. @@ -370,9 +393,17 @@ struct pg_conn char *ssl_min_protocol_version; /* minimum TLS protocol version */ char *ssl_max_protocol_version; /* maximum TLS protocol version */ - /* Type of connection to make. Possible values: any, read-write. */ + /* + * Type of connection to make. Possible values: "any", "read-write", + * "read-only", "primary", "prefer-standby", "standby". + */ char *target_session_attrs; + /* + * The requested server type, derived from target_session_attrs. + */ + TargetServerType requested_server_type; + /* Optional file to write trace info to */ FILE *Pfdebug; @@ -406,6 +437,21 @@ struct pg_conn pg_conn_host *connhost; /* details about each named host */ char *connip; /* IP address for current network connection */ + /* + * Index of the first primary host encountered (if any) in the connection + * string. This is used during processing of requested server connection type + * SERVER_TYPE_PREFER_STANDBY. + * + * The initial value is -1, indicating that no primary host has yet been + * found. It is then set to the index of the first primary host, if one is + * found in the connection string during processing. If a second + * connection attempt is later made to that primary host (because no + * connection to a standby server could be made), which_primary_host + * is then set to -2 to avoid recursion during subsequent processing (and + * whichhost is set to the primary host index). + */ + int which_primary_host; + /* Connection data */ pgsocket sock; /* FD for socket, PGINVALID_SOCKET if * unconnected */ @@ -436,6 +482,8 @@ struct pg_conn pgParameterStatus *pstatus; /* ParameterStatus data */ int client_encoding; /* encoding id */ bool std_strings; /* standard_conforming_strings */ + GucBoolState transaction_read_only; /* transaction_read_only GUC report variable state */ + GucBoolState in_hot_standby; /* in_hot_standby GUC report variable state */ PGVerbosity verbosity; /* error/notice message verbosity */ PGContextVisibility show_context; /* whether to show CONTEXT field */ PGlobjfuncs *lobjfuncs; /* private state for large-object access fns */ diff --git a/src/test/recovery/t/001_stream_rep.pl b/src/test/recovery/t/001_stream_rep.pl index 9e31a53..15d0273 100644 --- a/src/test/recovery/t/001_stream_rep.pl +++ b/src/test/recovery/t/001_stream_rep.pl @@ -3,7 +3,7 @@ use strict; use warnings; use PostgresNode; use TestLib; -use Test::More tests => 36; +use Test::More tests => 49; # Initialize primary node my $node_primary = get_new_node('primary'); @@ -85,7 +85,7 @@ sub test_target_session_attrs my $node2_port = $node2->port; my $node2_name = $node2->name; - my $target_name = $target_node->name; + my $target_name = $target_node->name if (defined $target_node); # Build connection string for connection attempt. my $connstr = "host=$node1_host,$node2_host "; @@ -97,10 +97,25 @@ sub test_target_session_attrs my ($ret, $stdout, $stderr) = $node1->psql('postgres', 'SHOW port;', extra_params => [ '-d', $connstr ]); - is( $status == $ret && $stdout eq $target_node->port, - 1, - "connect to node $target_name if mode \"$mode\" and $node1_name,$node2_name listed" - ); + if ($status == 0) + { + is( $status == $ret && $stdout eq $target_node->port, + 1, + "connect to node $target_name if mode \"$mode\" and $node1_name,$node2_name listed" + ); + } + else + { + print "status = $status\n"; + print "ret = $ret\n"; + print "stdout = $stdout\n"; + print "stderr = $stderr\n"; + + is( $status == $ret, + 1, + "fail to connect to any nodes if mode \"$mode\" and $node1_name,$node2_name listed" + ); + } return; } @@ -121,6 +136,58 @@ test_target_session_attrs($node_primary, $node_standby_1, $node_primary, "any", test_target_session_attrs($node_standby_1, $node_primary, $node_standby_1, "any", 0); +# Connect to primary in "primary" mode with primary,standby1 list. +test_target_session_attrs($node_primary, $node_standby_1, $node_primary, + "primary", 0); + +# Connect to primary in "primary" mode with standby1,primary list. +test_target_session_attrs($node_standby_1, $node_primary, $node_primary, + "primary", 0); + +# Connect to standby1 in "read-only" mode with primary,standby1 list. +test_target_session_attrs($node_primary, $node_standby_1, $node_standby_1, + "read-only", 0); + +# Connect to standby1 in "read-only" mode with standby1,primary list. +test_target_session_attrs($node_standby_1, $node_primary, $node_standby_1, + "read-only", 0); + +# Connect to primary in "prefer-standby" mode with primary,primary list. +test_target_session_attrs($node_primary, $node_primary, $node_primary, + "prefer-standby", 0); + +# Connect to standby1 in "prefer-standby" mode with primary,standby1 list. +test_target_session_attrs($node_primary, $node_standby_1, $node_standby_1, + "prefer-standby", 0); + +# Connect to standby1 in "prefer-standby" mode with standby1,primary list. +test_target_session_attrs($node_standby_1, $node_primary, $node_standby_1, + "prefer-standby", 0); + +# Connect to standby1 in "standby" mode with primary,standby1 list. +test_target_session_attrs($node_primary, $node_standby_1, $node_standby_1, + "standby", 0); + +# Connect to standby1 in "standby" mode with standby1,primary list. +test_target_session_attrs($node_standby_1, $node_primary, $node_standby_1, + "standby", 0); + +# Fail to connect in "read-write" mode with standby1,standby2 list. +test_target_session_attrs($node_standby_1, $node_standby_2, undef, + "read-write", 2); + +# Fail to connect in "primary" mode with standby1,standby2 list. +test_target_session_attrs($node_standby_1, $node_standby_2, undef, + "primary", 2); + +# Fail to connect in "read-only" mode with primary,primary list. +test_target_session_attrs($node_primary, $node_primary, undef, + "read-only", 2); + +# Fail to connect in "standby" mode with primary,primary list. +test_target_session_attrs($node_primary, $node_primary, undef, + "standby", 2); + # Test for SHOW commands using a WAL sender connection with a replication # role. note "testing SHOW commands for replication connection"; -- 1.8.3.1