mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-12 14:28:05 +02:00
When starting either an old or new postmaster, force it to place its Unix socket in the current directory. This makes it even harder for accidental connections to occur during pg_upgrade, and also works around some scenarios where the default socket location isn't usable. (For example, if the default location is something other than "/tmp", it might not exist during "make check".) When checking an already-running old postmaster, find out its actual socket directory location from postmaster.pid, if possible. This dodges problems with an old postmaster having a configured location different from the default built into pg_upgrade's libpq. We can't find that out if the old postmaster is pre-9.1, so also document how to cope with such scenarios manually. In support of this, centralize handling of the connection-related command line options passed to pg_upgrade's subsidiary programs, such as pg_dump. This should make future changes easier. Bruce Momjian and Tom Lane
312 lines
7.9 KiB
C
312 lines
7.9 KiB
C
/*
|
|
* server.c
|
|
*
|
|
* database server functions
|
|
*
|
|
* Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
|
* contrib/pg_upgrade/server.c
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "pg_upgrade.h"
|
|
|
|
|
|
static PGconn *get_db_conn(ClusterInfo *cluster, const char *db_name);
|
|
|
|
|
|
/*
|
|
* connectToServer()
|
|
*
|
|
* Connects to the desired database on the designated server.
|
|
* If the connection attempt fails, this function logs an error
|
|
* message and calls exit() to kill the program.
|
|
*/
|
|
PGconn *
|
|
connectToServer(ClusterInfo *cluster, const char *db_name)
|
|
{
|
|
PGconn *conn = get_db_conn(cluster, db_name);
|
|
|
|
if (conn == NULL || PQstatus(conn) != CONNECTION_OK)
|
|
{
|
|
pg_log(PG_REPORT, "connection to database failed: %s\n",
|
|
PQerrorMessage(conn));
|
|
|
|
if (conn)
|
|
PQfinish(conn);
|
|
|
|
printf("Failure, exiting\n");
|
|
exit(1);
|
|
}
|
|
|
|
return conn;
|
|
}
|
|
|
|
|
|
/*
|
|
* get_db_conn()
|
|
*
|
|
* get database connection, using named database + standard params for cluster
|
|
*/
|
|
static PGconn *
|
|
get_db_conn(ClusterInfo *cluster, const char *db_name)
|
|
{
|
|
char conn_opts[2 * NAMEDATALEN + MAXPGPATH + 100];
|
|
|
|
if (cluster->sockdir)
|
|
snprintf(conn_opts, sizeof(conn_opts),
|
|
"dbname = '%s' user = '%s' host = '%s' port = %d",
|
|
db_name, os_info.user, cluster->sockdir, cluster->port);
|
|
else
|
|
snprintf(conn_opts, sizeof(conn_opts),
|
|
"dbname = '%s' user = '%s' port = %d",
|
|
db_name, os_info.user, cluster->port);
|
|
|
|
return PQconnectdb(conn_opts);
|
|
}
|
|
|
|
|
|
/*
|
|
* cluster_conn_opts()
|
|
*
|
|
* Return standard command-line options for connecting to this cluster when
|
|
* using psql, pg_dump, etc. Ideally this would match what get_db_conn()
|
|
* sets, but the utilities we need aren't very consistent about the treatment
|
|
* of database name options, so we leave that out.
|
|
*
|
|
* Note result is in static storage, so use it right away.
|
|
*/
|
|
char *
|
|
cluster_conn_opts(ClusterInfo *cluster)
|
|
{
|
|
static char conn_opts[MAXPGPATH + NAMEDATALEN + 100];
|
|
|
|
if (cluster->sockdir)
|
|
snprintf(conn_opts, sizeof(conn_opts),
|
|
"--host \"%s\" --port %d --username \"%s\"",
|
|
cluster->sockdir, cluster->port, os_info.user);
|
|
else
|
|
snprintf(conn_opts, sizeof(conn_opts),
|
|
"--port %d --username \"%s\"",
|
|
cluster->port, os_info.user);
|
|
|
|
return conn_opts;
|
|
}
|
|
|
|
|
|
/*
|
|
* executeQueryOrDie()
|
|
*
|
|
* Formats a query string from the given arguments and executes the
|
|
* resulting query. If the query fails, this function logs an error
|
|
* message and calls exit() to kill the program.
|
|
*/
|
|
PGresult *
|
|
executeQueryOrDie(PGconn *conn, const char *fmt,...)
|
|
{
|
|
static char command[8192];
|
|
va_list args;
|
|
PGresult *result;
|
|
ExecStatusType status;
|
|
|
|
va_start(args, fmt);
|
|
vsnprintf(command, sizeof(command), fmt, args);
|
|
va_end(args);
|
|
|
|
pg_log(PG_VERBOSE, "executing: %s\n", command);
|
|
result = PQexec(conn, command);
|
|
status = PQresultStatus(result);
|
|
|
|
if ((status != PGRES_TUPLES_OK) && (status != PGRES_COMMAND_OK))
|
|
{
|
|
pg_log(PG_REPORT, "SQL command failed\n%s\n%s\n", command,
|
|
PQerrorMessage(conn));
|
|
PQclear(result);
|
|
PQfinish(conn);
|
|
printf("Failure, exiting\n");
|
|
exit(1);
|
|
}
|
|
else
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
* get_major_server_version()
|
|
*
|
|
* gets the version (in unsigned int form) for the given datadir. Assumes
|
|
* that datadir is an absolute path to a valid pgdata directory. The version
|
|
* is retrieved by reading the PG_VERSION file.
|
|
*/
|
|
uint32
|
|
get_major_server_version(ClusterInfo *cluster)
|
|
{
|
|
FILE *version_fd;
|
|
char ver_filename[MAXPGPATH];
|
|
int integer_version = 0;
|
|
int fractional_version = 0;
|
|
|
|
snprintf(ver_filename, sizeof(ver_filename), "%s/PG_VERSION",
|
|
cluster->pgdata);
|
|
if ((version_fd = fopen(ver_filename, "r")) == NULL)
|
|
return 0;
|
|
|
|
if (fscanf(version_fd, "%63s", cluster->major_version_str) == 0 ||
|
|
sscanf(cluster->major_version_str, "%d.%d", &integer_version,
|
|
&fractional_version) != 2)
|
|
pg_log(PG_FATAL, "could not get version from %s\n", cluster->pgdata);
|
|
|
|
fclose(version_fd);
|
|
|
|
return (100 * integer_version + fractional_version) * 100;
|
|
}
|
|
|
|
|
|
static void
|
|
stop_postmaster_atexit(void)
|
|
{
|
|
stop_postmaster(true);
|
|
|
|
}
|
|
|
|
|
|
void
|
|
start_postmaster(ClusterInfo *cluster)
|
|
{
|
|
char cmd[MAXPGPATH * 4 + 1000];
|
|
PGconn *conn;
|
|
bool exit_hook_registered = false;
|
|
bool pg_ctl_return = false;
|
|
char socket_string[MAXPGPATH + 200];
|
|
|
|
if (!exit_hook_registered)
|
|
{
|
|
atexit(stop_postmaster_atexit);
|
|
exit_hook_registered = true;
|
|
}
|
|
|
|
socket_string[0] = '\0';
|
|
|
|
#ifdef HAVE_UNIX_SOCKETS
|
|
/* prevent TCP/IP connections, restrict socket access */
|
|
strcat(socket_string,
|
|
" -c listen_addresses='' -c unix_socket_permissions=0700");
|
|
|
|
/* Have a sockdir? Tell the postmaster. */
|
|
if (cluster->sockdir)
|
|
snprintf(socket_string + strlen(socket_string),
|
|
sizeof(socket_string) - strlen(socket_string),
|
|
" -c %s='%s'",
|
|
(GET_MAJOR_VERSION(cluster->major_version) < 903) ?
|
|
"unix_socket_directory" : "unix_socket_directories",
|
|
cluster->sockdir);
|
|
#endif
|
|
|
|
/*
|
|
* Using autovacuum=off disables cleanup vacuum and analyze, but freeze
|
|
* vacuums can still happen, so we set autovacuum_freeze_max_age to its
|
|
* maximum. We assume all datfrozenxid and relfrozen values are less than
|
|
* a gap of 2000000000 from the current xid counter, so autovacuum will
|
|
* not touch them.
|
|
*/
|
|
snprintf(cmd, sizeof(cmd),
|
|
"\"%s/pg_ctl\" -w -l \"%s\" -D \"%s\" -o \"-p %d %s %s%s\" start",
|
|
cluster->bindir, SERVER_LOG_FILE, cluster->pgconfig, cluster->port,
|
|
(cluster->controldata.cat_ver >=
|
|
BINARY_UPGRADE_SERVER_FLAG_CAT_VER) ? "-b" :
|
|
"-c autovacuum=off -c autovacuum_freeze_max_age=2000000000",
|
|
cluster->pgopts ? cluster->pgopts : "", socket_string);
|
|
|
|
/*
|
|
* Don't throw an error right away, let connecting throw the error because
|
|
* it might supply a reason for the failure.
|
|
*/
|
|
pg_ctl_return = exec_prog(SERVER_START_LOG_FILE,
|
|
/* pass both file names if they differ */
|
|
(strcmp(SERVER_LOG_FILE,
|
|
SERVER_START_LOG_FILE) != 0) ?
|
|
SERVER_LOG_FILE : NULL,
|
|
false,
|
|
"%s", cmd);
|
|
|
|
/* Check to see if we can connect to the server; if not, report it. */
|
|
if ((conn = get_db_conn(cluster, "template1")) == NULL ||
|
|
PQstatus(conn) != CONNECTION_OK)
|
|
{
|
|
pg_log(PG_REPORT, "\nconnection to database failed: %s\n",
|
|
PQerrorMessage(conn));
|
|
if (conn)
|
|
PQfinish(conn);
|
|
pg_log(PG_FATAL, "could not connect to %s postmaster started with the command:\n"
|
|
"%s\n",
|
|
CLUSTER_NAME(cluster), cmd);
|
|
}
|
|
PQfinish(conn);
|
|
|
|
/* If the connection didn't fail, fail now */
|
|
if (!pg_ctl_return)
|
|
pg_log(PG_FATAL, "pg_ctl failed to start the %s server, or connection failed\n",
|
|
CLUSTER_NAME(cluster));
|
|
|
|
os_info.running_cluster = cluster;
|
|
}
|
|
|
|
|
|
void
|
|
stop_postmaster(bool fast)
|
|
{
|
|
ClusterInfo *cluster;
|
|
|
|
if (os_info.running_cluster == &old_cluster)
|
|
cluster = &old_cluster;
|
|
else if (os_info.running_cluster == &new_cluster)
|
|
cluster = &new_cluster;
|
|
else
|
|
return; /* no cluster running */
|
|
|
|
exec_prog(SERVER_STOP_LOG_FILE, NULL, !fast,
|
|
"\"%s/pg_ctl\" -w -D \"%s\" -o \"%s\" %s stop",
|
|
cluster->bindir, cluster->pgconfig,
|
|
cluster->pgopts ? cluster->pgopts : "",
|
|
fast ? "-m fast" : "");
|
|
|
|
os_info.running_cluster = NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
* check_pghost_envvar()
|
|
*
|
|
* Tests that PGHOST does not point to a non-local server
|
|
*/
|
|
void
|
|
check_pghost_envvar(void)
|
|
{
|
|
PQconninfoOption *option;
|
|
PQconninfoOption *start;
|
|
|
|
/* Get valid libpq env vars from the PQconndefaults function */
|
|
|
|
start = PQconndefaults();
|
|
|
|
for (option = start; option->keyword != NULL; option++)
|
|
{
|
|
if (option->envvar && (strcmp(option->envvar, "PGHOST") == 0 ||
|
|
strcmp(option->envvar, "PGHOSTADDR") == 0))
|
|
{
|
|
const char *value = getenv(option->envvar);
|
|
|
|
if (value && strlen(value) > 0 &&
|
|
/* check for 'local' host values */
|
|
(strcmp(value, "localhost") != 0 && strcmp(value, "127.0.0.1") != 0 &&
|
|
strcmp(value, "::1") != 0 && value[0] != '/'))
|
|
pg_log(PG_FATAL,
|
|
"libpq environment variable %s has a non-local server value: %s\n",
|
|
option->envvar, value);
|
|
}
|
|
}
|
|
|
|
/* Free the memory that libpq allocated on our behalf */
|
|
PQconninfoFree(start);
|
|
}
|