mirror of
https://github.com/EnterpriseDB/repmgr.git
synced 2026-03-23 15:16:29 +00:00
Compare commits
73 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e59b57376d | ||
|
|
3db87e6a31 | ||
|
|
94d05619c3 | ||
|
|
807c7c926c | ||
|
|
df68f1f3f6 | ||
|
|
d4c75bb6c7 | ||
|
|
94d4e1128d | ||
|
|
dbd82ba687 | ||
|
|
0888fbc538 | ||
|
|
92a84bd950 | ||
|
|
a3318d65d2 | ||
|
|
374e9811c9 | ||
|
|
16896510dc | ||
|
|
1c155a1088 | ||
|
|
31d57f4122 | ||
|
|
7b313b9d71 | ||
|
|
cf126642bd | ||
|
|
52281fcde8 | ||
|
|
de573edaaa | ||
|
|
4cb7f301ad | ||
|
|
87d8de4441 | ||
|
|
6db742f81e | ||
|
|
c79933685c | ||
|
|
04ba672b9f | ||
|
|
4f4111063a | ||
|
|
3a3a536e6d | ||
|
|
6f7206a5a1 | ||
|
|
f9fd1dd227 | ||
|
|
8140ba9c27 | ||
|
|
32dba444e1 | ||
|
|
8212ff8d8a | ||
|
|
1ccd0edad2 | ||
|
|
59b31dd1ca | ||
|
|
300b9f0cc2 | ||
|
|
0efee4cf65 | ||
|
|
0cb2584886 | ||
|
|
b88d27248c | ||
|
|
683c54325e | ||
|
|
70d398cd47 | ||
|
|
7b7d80e5f2 | ||
|
|
96b0e26084 | ||
|
|
91c498f6f1 | ||
|
|
d48093e732 | ||
|
|
3f0d1754a4 | ||
|
|
f27979bbe1 | ||
|
|
e9445a5d5e | ||
|
|
9a2717b5e3 | ||
|
|
dd6ea1cd77 | ||
|
|
de5908c122 | ||
|
|
4b5c84921c | ||
|
|
aaa8d70cef | ||
|
|
ca31b846e7 | ||
|
|
a27cecb559 | ||
|
|
cf0cdfa6a1 | ||
|
|
31489d92c0 | ||
|
|
b7fd13aed2 | ||
|
|
3c4bf27aa7 | ||
|
|
0ebd9c15d9 | ||
|
|
f9dba283d4 | ||
|
|
205f1cebbb | ||
|
|
4d97c1ebf7 | ||
|
|
12c395e91f | ||
|
|
bd1e4f71d6 | ||
|
|
cb49071ea4 | ||
|
|
5ad674edff | ||
|
|
ac09bad89c | ||
|
|
009d92fec8 | ||
|
|
b3d8a68a1d | ||
|
|
05b47cb2a8 | ||
|
|
dc542a1b7d | ||
|
|
6ce8058749 | ||
|
|
2edcac77f0 | ||
|
|
f740374392 |
@@ -2,7 +2,7 @@ License and Contributions
|
||||
=========================
|
||||
|
||||
`repmgr` is licensed under the GPL v3. All of its code and documentation is
|
||||
Copyright 2010-2017, 2ndQuadrant Limited. See the files COPYRIGHT and LICENSE for
|
||||
Copyright 2010-2016, 2ndQuadrant Limited. See the files COPYRIGHT and LICENSE for
|
||||
details.
|
||||
|
||||
The development of repmgr has primarily been sponsored by 2ndQuadrant customers.
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
Copyright (c) 2010-2017, 2ndQuadrant Limited
|
||||
Copyright (c) 2010-2016, 2ndQuadrant Limited
|
||||
All rights reserved.
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
|
||||
12
FAQ.md
12
FAQ.md
@@ -137,7 +137,6 @@ General
|
||||
of events which includes servers removed from the replication cluster
|
||||
which no longer have an entry in the `repl_nodes` table.
|
||||
|
||||
|
||||
`repmgrd`
|
||||
---------
|
||||
|
||||
@@ -152,9 +151,6 @@ General
|
||||
|
||||
In `repmgr.conf`, set its priority to a value of 0 or less.
|
||||
|
||||
Additionally, if `failover` is set to `manual`, the node will never
|
||||
be considered as a promotion candidate.
|
||||
|
||||
- Does `repmgrd` support delayed standbys?
|
||||
|
||||
`repmgrd` can monitor delayed standbys - those set up with
|
||||
@@ -173,11 +169,3 @@ General
|
||||
|
||||
Configure your system's `logrotate` service to do this; see example
|
||||
in README.md
|
||||
|
||||
- I've recloned a failed master as a standby, but `repmgrd` refuses to start?
|
||||
|
||||
Check you registered the standby after recloning. If unregistered the standby
|
||||
cannot be considered as a promotion candidate even if `failover` is set to
|
||||
`automatic`, which is probably not what you want. `repmgrd` will start if
|
||||
`failover` is set to `manual` so the node's replication status can still
|
||||
be monitored, if desired.
|
||||
|
||||
90
HISTORY
90
HISTORY
@@ -1,92 +1,4 @@
|
||||
3.3.2 2017-06-01
|
||||
Add support for PostgreSQL 10 (Ian)
|
||||
repmgr: ensure --replication-user option is honoured when passing database
|
||||
connection parameters as a conninfo string (Ian)
|
||||
repmgr: improve detection of pg_rewind on remote server (Ian)
|
||||
repmgr: add DETAIL log output for additional clarification of error messages (Ian)
|
||||
repmgr: suppress various spurious error messages in `standby follow` and
|
||||
`standby switchover` (Ian)
|
||||
repmgr: add missing `-P` option (Ian)
|
||||
repmgrd: monitoring statistic reporting fixes (Ian)
|
||||
|
||||
3.3.1 2017-03-13
|
||||
repmgrd: prevent invalid apply lag value being written to the
|
||||
monitoring table (Ian)
|
||||
repmgrd: fix error in XLogRecPtr conversion when calculating
|
||||
monitoring statistics (Ian)
|
||||
repmgr: if replication slots in use, where possible delete slot on old
|
||||
upstream node after following new upstream (Ian)
|
||||
repmgr: improve logging of rsync actions (Ian)
|
||||
repmgr: improve `standby clone` when synchronous replication in use (Ian)
|
||||
repmgr: stricter checking of allowed node id values
|
||||
repmgr: enable `master register --force` when there is a foreign key
|
||||
dependency from a standby node (Ian)
|
||||
|
||||
3.3 2016-12-27
|
||||
repmgr: always log to STDERR even if log facility defined (Ian)
|
||||
repmgr: add --log-to-file to log repmgr output to the defined
|
||||
log facility (Ian)
|
||||
repmgr: improve handling of command line parameter errors (Ian)
|
||||
repmgr: add option --upstream-conninfo to explicitly set
|
||||
'primary_conninfo' in recovery.conf (Ian)
|
||||
repmgr: enable a standby to be registered which isn't running (Ian)
|
||||
repmgr: enable `standby register --force` to update a node record
|
||||
with cascaded downstream node records (Ian)
|
||||
repmgr: add option `--no-conninfo-password` (Abhijit, Ian)
|
||||
repmgr: add initial support for PostgreSQL 10.0 (Ian)
|
||||
repmgr: escape values in primary_conninfo if needed (Ian)
|
||||
|
||||
3.2.1 2016-10-24
|
||||
repmgr: require a valid repmgr cluster name unless -F/--force
|
||||
supplied (Ian)
|
||||
repmgr: check master server is registered with repmgr before
|
||||
cloning (Ian)
|
||||
repmgr: ensure data directory defaults to that of the source node (Ian)
|
||||
repmgr: various fixes to Barman cloning mode (Gianni, Ian)
|
||||
repmgr: fix `repmgr cluster crosscheck` output (Ian)
|
||||
|
||||
3.2 2016-10-05
|
||||
repmgr: add support for cloning from a Barman backup (Gianni)
|
||||
repmgr: add commands `standby matrix` and `standby crosscheck` (Gianni)
|
||||
repmgr: suppress connection error display in `repmgr cluster show`
|
||||
unless `--verbose` supplied (Ian)
|
||||
repmgr: add commands `witness register` and `witness unregister` (Ian)
|
||||
repmgr: enable `standby unregister` / `witness unregister` to be
|
||||
executed for a node which is not running (Ian)
|
||||
repmgr: remove deprecated command line options --initdb-no-pwprompt and
|
||||
-l/--local-port (Ian)
|
||||
repmgr: before cloning with pg_basebackup, check that sufficient free
|
||||
walsenders are available (Ian)
|
||||
repmgr: add option `--wait-sync` for `standby register` which causes
|
||||
repmgr to wait for the registered node record to synchronise to
|
||||
the standby (Ian)
|
||||
repmgr: add option `--copy-external-config-files` for files outside
|
||||
of the data directory (Ian)
|
||||
repmgr: only require `wal_keep_segments` to be set in certain corner
|
||||
cases (Ian)
|
||||
repmgr: better support cloning from a node other than the one to
|
||||
stream from (Ian)
|
||||
repmgrd: add configuration options to override the default pg_ctl
|
||||
commands (Jarkko Oranen, Ian)
|
||||
repmgrd: don't start if node is inactive and failover=automatic (Ian)
|
||||
packaging: improve "repmgr-auto" Debian package (Gianni)
|
||||
|
||||
|
||||
3.1.5 2016-08-15
|
||||
repmgrd: in a failover situation, prevent endless looping when
|
||||
attempting to establish the status of a node with
|
||||
`failover=manual` (Ian)
|
||||
repmgrd: improve handling of failover events on standbys with
|
||||
`failover=manual`, and create a new event notification
|
||||
for this, `standby_disconnect_manual` (Ian)
|
||||
repmgr: add further event notifications (Gianni)
|
||||
repmgr: when executing `standby switchover`, don't collect remote
|
||||
command output unless required (Gianni, Ian)
|
||||
repmgrd: improve standby monitoring query (Ian, based on suggestion
|
||||
from Álvaro)
|
||||
repmgr: various command line handling improvements (Ian)
|
||||
|
||||
3.1.4 2016-07-12
|
||||
3.1.4 2016-07-
|
||||
repmgr: new configuration option for setting "restore_command"
|
||||
in the recovery.conf file generated by repmgr (Martín)
|
||||
repmgr: add --csv option to "repmgr cluster show" (Gianni)
|
||||
|
||||
17
Makefile
17
Makefile
@@ -1,16 +1,15 @@
|
||||
#
|
||||
# Makefile
|
||||
# Copyright (c) 2ndQuadrant, 2010-2017
|
||||
# Copyright (c) 2ndQuadrant, 2010-2016
|
||||
|
||||
HEADERS = $(wildcard *.h)
|
||||
|
||||
repmgrd_OBJS = dbutils.o config.o repmgrd.o log.o strutil.o
|
||||
repmgr_OBJS = dbutils.o check_dir.o config.o repmgr.o log.o strutil.o dirmod.o compat.o
|
||||
repmgr_OBJS = dbutils.o check_dir.o config.o repmgr.o log.o strutil.o dirmod.o
|
||||
|
||||
DATA = repmgr.sql uninstall_repmgr.sql
|
||||
REGRESS = repmgr_funcs repmgr_test
|
||||
|
||||
PG_CPPFLAGS = -I$(includedir_internal) -I$(libpq_srcdir)
|
||||
PG_CPPFLAGS = -I$(libpq_srcdir)
|
||||
PG_LIBS = $(libpq_pgport)
|
||||
|
||||
|
||||
@@ -18,11 +17,11 @@ all: repmgrd repmgr
|
||||
$(MAKE) -C sql
|
||||
|
||||
repmgrd: $(repmgrd_OBJS)
|
||||
$(CC) -o repmgrd $(CFLAGS) $(repmgrd_OBJS) $(PG_LIBS) $(LDFLAGS) $(LDFLAGS_EX)
|
||||
$(CC) -o repmgrd $(CFLAGS) $(repmgrd_OBJS) $(PG_LIBS) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS)
|
||||
$(MAKE) -C sql
|
||||
|
||||
repmgr: $(repmgr_OBJS)
|
||||
$(CC) -o repmgr $(CFLAGS) $(repmgr_OBJS) $(PG_LIBS) $(LDFLAGS) $(LDFLAGS_EX)
|
||||
$(CC) -o repmgr $(CFLAGS) $(repmgr_OBJS) $(PG_LIBS) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS)
|
||||
|
||||
# Make all objects depend on all include files. This is a bit of a
|
||||
# shotgun approach, but the codebase is small enough that a complete rebuild
|
||||
@@ -88,12 +87,10 @@ PG_VERSION = $(shell pg_config --version | cut -d ' ' -f 2 | cut -d '.' -f 1,2)
|
||||
REPMGR_VERSION = $(shell grep REPMGR_VERSION version.h | cut -d ' ' -f 3 | cut -d '"' -f 2)
|
||||
PKGLIBDIR = $(shell pg_config --pkglibdir)
|
||||
SHAREDIR = $(shell pg_config --sharedir)
|
||||
PGBINDIR = /usr/lib/postgresql/$(PG_VERSION)/bin
|
||||
|
||||
deb: repmgrd repmgr
|
||||
mkdir -p ./debian/usr/bin ./debian$(PGBINDIR)
|
||||
cp repmgrd repmgr ./debian$(PGBINDIR)
|
||||
ln -s ../..$(PGBINDIR)/repmgr ./debian/usr/bin/repmgr
|
||||
mkdir -p ./debian/usr/bin
|
||||
cp repmgrd repmgr ./debian/usr/bin/
|
||||
mkdir -p ./debian$(SHAREDIR)/contrib/
|
||||
cp sql/repmgr_funcs.sql ./debian$(SHAREDIR)/contrib/
|
||||
cp sql/uninstall_repmgr_funcs.sql ./debian$(SHAREDIR)/contrib/
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* check_dir.c - Directories management functions
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* check_dir.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
|
||||
107
compat.c
107
compat.c
@@ -1,107 +0,0 @@
|
||||
/*
|
||||
*
|
||||
* compat.c
|
||||
* Provides a couple of useful string utility functions adapted
|
||||
* from the backend code, which are not publicly exposed. They're
|
||||
* unlikely to change but it would be worth keeping an eye on them
|
||||
* for any fixes/improvements
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
*
|
||||
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "repmgr.h"
|
||||
#include "compat.h"
|
||||
|
||||
/*
|
||||
* Append the given string to the buffer, with suitable quoting for passing
|
||||
* the string as a value, in a keyword/pair value in a libpq connection
|
||||
* string
|
||||
*
|
||||
* This function is adapted from src/fe_utils/string_utils.c (before 9.6
|
||||
* located in: src/bin/pg_dump/dumputils.c)
|
||||
*/
|
||||
void
|
||||
appendConnStrVal(PQExpBuffer buf, const char *str)
|
||||
{
|
||||
const char *s;
|
||||
bool needquotes;
|
||||
|
||||
/*
|
||||
* If the string is one or more plain ASCII characters, no need to quote
|
||||
* it. This is quite conservative, but better safe than sorry.
|
||||
*/
|
||||
needquotes = true;
|
||||
for (s = str; *s; s++)
|
||||
{
|
||||
if (!((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
|
||||
(*s >= '0' && *s <= '9') || *s == '_' || *s == '.'))
|
||||
{
|
||||
needquotes = true;
|
||||
break;
|
||||
}
|
||||
needquotes = false;
|
||||
}
|
||||
|
||||
if (needquotes)
|
||||
{
|
||||
appendPQExpBufferChar(buf, '\'');
|
||||
while (*str)
|
||||
{
|
||||
/* ' and \ must be escaped by to \' and \\ */
|
||||
if (*str == '\'' || *str == '\\')
|
||||
appendPQExpBufferChar(buf, '\\');
|
||||
|
||||
appendPQExpBufferChar(buf, *str);
|
||||
str++;
|
||||
}
|
||||
appendPQExpBufferChar(buf, '\'');
|
||||
}
|
||||
else
|
||||
appendPQExpBufferStr(buf, str);
|
||||
}
|
||||
|
||||
/*
|
||||
* Adapted from: src/fe_utils/string_utils.c
|
||||
*/
|
||||
void
|
||||
appendShellString(PQExpBuffer buf, const char *str)
|
||||
{
|
||||
const char *p;
|
||||
|
||||
appendPQExpBufferChar(buf, '\'');
|
||||
for (p = str; *p; p++)
|
||||
{
|
||||
if (*p == '\n' || *p == '\r')
|
||||
{
|
||||
fprintf(stderr,
|
||||
_("shell command argument contains a newline or carriage return: \"%s\"\n"),
|
||||
str);
|
||||
exit(ERR_BAD_CONFIG);
|
||||
}
|
||||
|
||||
if (*p == '\'')
|
||||
appendPQExpBufferStr(buf, "'\"'\"'");
|
||||
else
|
||||
appendPQExpBufferChar(buf, *p);
|
||||
}
|
||||
|
||||
appendPQExpBufferChar(buf, '\'');
|
||||
}
|
||||
|
||||
29
compat.h
29
compat.h
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* compat.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _COMPAT_H_
|
||||
#define _COMPAT_H_
|
||||
|
||||
extern void
|
||||
appendConnStrVal(PQExpBuffer buf, const char *str);
|
||||
|
||||
extern void
|
||||
appendShellString(PQExpBuffer buf, const char *str);
|
||||
|
||||
#endif
|
||||
374
config.c
374
config.c
@@ -1,7 +1,6 @@
|
||||
/*
|
||||
* config.c - Functions to parse the config file
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -10,11 +9,11 @@
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
@@ -27,7 +26,7 @@
|
||||
|
||||
static void parse_event_notifications_list(t_configuration_options *options, const char *arg);
|
||||
static void tablespace_list_append(t_configuration_options *options, const char *arg);
|
||||
static void exit_with_errors(ItemList *config_errors);
|
||||
static void exit_with_errors(ErrorList *config_errors);
|
||||
|
||||
const static char *_progname = NULL;
|
||||
static char config_file_path[MAXPGPATH];
|
||||
@@ -55,8 +54,8 @@ progname(void)
|
||||
*
|
||||
* Returns true if a configuration file could be parsed, otherwise false.
|
||||
*
|
||||
* Any *repmgrd-specific* configuration options added/changed in this function must also be
|
||||
* added/changed in reload_config()
|
||||
* Any configuration options changed in this function must also be changed in
|
||||
* reload_config()
|
||||
*
|
||||
* NOTE: this function is called before the logger is set up, so we need
|
||||
* to handle the verbose option ourselves; also the default log level is NOTICE,
|
||||
@@ -99,9 +98,9 @@ load_config(const char *config_file, bool verbose, t_configuration_options *opti
|
||||
/*
|
||||
* If no configuration file was provided, attempt to find a default file
|
||||
* in this order:
|
||||
* - current directory
|
||||
* - /etc/repmgr.conf
|
||||
* - default sysconfdir
|
||||
* - current directory
|
||||
* - /etc/repmgr.conf
|
||||
* - default sysconfdir
|
||||
*
|
||||
* here we just check for the existence of the file; parse_config()
|
||||
* will handle read errors etc.
|
||||
@@ -181,23 +180,6 @@ load_config(const char *config_file, bool verbose, t_configuration_options *opti
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
parse_config(t_configuration_options *options)
|
||||
{
|
||||
/* Collate configuration file errors here for friendlier reporting */
|
||||
static ItemList config_errors = { NULL, NULL };
|
||||
|
||||
_parse_config(options, &config_errors);
|
||||
|
||||
if (config_errors.head != NULL)
|
||||
{
|
||||
exit_with_errors(&config_errors);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Parse configuration file; if any errors are encountered,
|
||||
* list them and exit.
|
||||
@@ -205,8 +187,8 @@ parse_config(t_configuration_options *options)
|
||||
* Ensure any default values set here are synced with repmgr.conf.sample
|
||||
* and any other documentation.
|
||||
*/
|
||||
void
|
||||
_parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
bool
|
||||
parse_config(t_configuration_options *options)
|
||||
{
|
||||
FILE *fp;
|
||||
char *s,
|
||||
@@ -218,6 +200,9 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
PQconninfoOption *conninfo_options;
|
||||
char *conninfo_errmsg = NULL;
|
||||
|
||||
/* Collate configuration file errors here for friendlier reporting */
|
||||
static ErrorList config_errors = { NULL, NULL };
|
||||
|
||||
bool node_found = false;
|
||||
|
||||
/* Initialize configuration options with sensible defaults
|
||||
@@ -225,22 +210,15 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
* to be initialised here
|
||||
*/
|
||||
memset(options->cluster_name, 0, sizeof(options->cluster_name));
|
||||
options->node = UNKNOWN_NODE_ID;
|
||||
options->node = -1;
|
||||
options->upstream_node = NO_UPSTREAM_NODE;
|
||||
options->use_replication_slots = 0;
|
||||
memset(options->conninfo, 0, sizeof(options->conninfo));
|
||||
memset(options->barman_server, 0, sizeof(options->barman_server));
|
||||
memset(options->barman_config, 0, sizeof(options->barman_config));
|
||||
options->failover = MANUAL_FAILOVER;
|
||||
options->priority = DEFAULT_PRIORITY;
|
||||
memset(options->node_name, 0, sizeof(options->node_name));
|
||||
memset(options->promote_command, 0, sizeof(options->promote_command));
|
||||
memset(options->follow_command, 0, sizeof(options->follow_command));
|
||||
memset(options->service_stop_command, 0, sizeof(options->service_stop_command));
|
||||
memset(options->service_start_command, 0, sizeof(options->service_start_command));
|
||||
memset(options->service_restart_command, 0, sizeof(options->service_restart_command));
|
||||
memset(options->service_reload_command, 0, sizeof(options->service_reload_command));
|
||||
memset(options->service_promote_command, 0, sizeof(options->service_promote_command));
|
||||
memset(options->rsync_options, 0, sizeof(options->rsync_options));
|
||||
memset(options->ssh_options, 0, sizeof(options->ssh_options));
|
||||
memset(options->pg_bindir, 0, sizeof(options->pg_bindir));
|
||||
@@ -276,7 +254,7 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
{
|
||||
log_verbose(LOG_NOTICE, _("no configuration file provided and no default file found - "
|
||||
"continuing with default values\n"));
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
|
||||
fp = fopen(config_file_path, "r");
|
||||
@@ -321,17 +299,13 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
strncpy(options->cluster_name, value, MAXLEN);
|
||||
else if (strcmp(name, "node") == 0)
|
||||
{
|
||||
options->node = repmgr_atoi(value, "node", error_list, false);
|
||||
options->node = repmgr_atoi(value, "node", &config_errors, false);
|
||||
node_found = true;
|
||||
}
|
||||
else if (strcmp(name, "upstream_node") == 0)
|
||||
options->upstream_node = repmgr_atoi(value, "upstream_node", error_list, false);
|
||||
options->upstream_node = repmgr_atoi(value, "upstream_node", &config_errors, false);
|
||||
else if (strcmp(name, "conninfo") == 0)
|
||||
strncpy(options->conninfo, value, MAXLEN);
|
||||
else if (strcmp(name, "barman_server") == 0)
|
||||
strncpy(options->barman_server, value, MAXLEN);
|
||||
else if (strcmp(name, "barman_config") == 0)
|
||||
strncpy(options->barman_config, value, MAXLEN);
|
||||
else if (strcmp(name, "rsync_options") == 0)
|
||||
strncpy(options->rsync_options, value, QUERY_STR_LEN);
|
||||
else if (strcmp(name, "ssh_options") == 0)
|
||||
@@ -356,39 +330,29 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
}
|
||||
else
|
||||
{
|
||||
item_list_append(error_list, _("value for 'failover' must be 'automatic' or 'manual'\n"));
|
||||
error_list_append(&config_errors,_("value for 'failover' must be 'automatic' or 'manual'\n"));
|
||||
}
|
||||
}
|
||||
else if (strcmp(name, "priority") == 0)
|
||||
options->priority = repmgr_atoi(value, "priority", error_list, true);
|
||||
options->priority = repmgr_atoi(value, "priority", &config_errors, true);
|
||||
else if (strcmp(name, "node_name") == 0)
|
||||
strncpy(options->node_name, value, MAXLEN);
|
||||
else if (strcmp(name, "promote_command") == 0)
|
||||
strncpy(options->promote_command, value, MAXLEN);
|
||||
else if (strcmp(name, "follow_command") == 0)
|
||||
strncpy(options->follow_command, value, MAXLEN);
|
||||
else if (strcmp(name, "service_stop_command") == 0)
|
||||
strncpy(options->service_stop_command, value, MAXLEN);
|
||||
else if (strcmp(name, "service_start_command") == 0)
|
||||
strncpy(options->service_start_command, value, MAXLEN);
|
||||
else if (strcmp(name, "service_restart_command") == 0)
|
||||
strncpy(options->service_restart_command, value, MAXLEN);
|
||||
else if (strcmp(name, "service_reload_command") == 0)
|
||||
strncpy(options->service_reload_command, value, MAXLEN);
|
||||
else if (strcmp(name, "service_promote_command") == 0)
|
||||
strncpy(options->service_promote_command, value, MAXLEN);
|
||||
else if (strcmp(name, "master_response_timeout") == 0)
|
||||
options->master_response_timeout = repmgr_atoi(value, "master_response_timeout", error_list, false);
|
||||
options->master_response_timeout = repmgr_atoi(value, "master_response_timeout", &config_errors, false);
|
||||
/*
|
||||
* 'primary_response_timeout' as synonym for 'master_response_timeout' -
|
||||
* we'll switch terminology in a future release (3.1?)
|
||||
*/
|
||||
else if (strcmp(name, "primary_response_timeout") == 0)
|
||||
options->master_response_timeout = repmgr_atoi(value, "primary_response_timeout", error_list, false);
|
||||
options->master_response_timeout = repmgr_atoi(value, "primary_response_timeout", &config_errors, false);
|
||||
else if (strcmp(name, "reconnect_attempts") == 0)
|
||||
options->reconnect_attempts = repmgr_atoi(value, "reconnect_attempts", error_list, false);
|
||||
options->reconnect_attempts = repmgr_atoi(value, "reconnect_attempts", &config_errors, false);
|
||||
else if (strcmp(name, "reconnect_interval") == 0)
|
||||
options->reconnect_interval = repmgr_atoi(value, "reconnect_interval", error_list, false);
|
||||
options->reconnect_interval = repmgr_atoi(value, "reconnect_interval", &config_errors, false);
|
||||
else if (strcmp(name, "pg_bindir") == 0)
|
||||
strncpy(options->pg_bindir, value, MAXLEN);
|
||||
else if (strcmp(name, "pg_ctl_options") == 0)
|
||||
@@ -398,14 +362,14 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
else if (strcmp(name, "logfile") == 0)
|
||||
strncpy(options->logfile, value, MAXLEN);
|
||||
else if (strcmp(name, "monitor_interval_secs") == 0)
|
||||
options->monitor_interval_secs = repmgr_atoi(value, "monitor_interval_secs", error_list, false);
|
||||
options->monitor_interval_secs = repmgr_atoi(value, "monitor_interval_secs", &config_errors, false);
|
||||
else if (strcmp(name, "retry_promote_interval_secs") == 0)
|
||||
options->retry_promote_interval_secs = repmgr_atoi(value, "retry_promote_interval_secs", error_list, false);
|
||||
options->retry_promote_interval_secs = repmgr_atoi(value, "retry_promote_interval_secs", &config_errors, false);
|
||||
else if (strcmp(name, "witness_repl_nodes_sync_interval_secs") == 0)
|
||||
options->witness_repl_nodes_sync_interval_secs = repmgr_atoi(value, "witness_repl_nodes_sync_interval_secs", error_list, false);
|
||||
options->witness_repl_nodes_sync_interval_secs = repmgr_atoi(value, "witness_repl_nodes_sync_interval_secs", &config_errors, false);
|
||||
else if (strcmp(name, "use_replication_slots") == 0)
|
||||
/* XXX we should have a dedicated boolean argument format */
|
||||
options->use_replication_slots = repmgr_atoi(value, "use_replication_slots", error_list, false);
|
||||
options->use_replication_slots = repmgr_atoi(value, "use_replication_slots", &config_errors, false);
|
||||
else if (strcmp(name, "event_notification_command") == 0)
|
||||
strncpy(options->event_notification_command, value, MAXLEN);
|
||||
else if (strcmp(name, "event_notifications") == 0)
|
||||
@@ -433,7 +397,7 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
_("no value provided for parameter \"%s\""),
|
||||
name);
|
||||
|
||||
item_list_append(error_list, error_message_buf);
|
||||
error_list_append(&config_errors, error_message_buf);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -442,15 +406,11 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
|
||||
if (node_found == false)
|
||||
{
|
||||
item_list_append(error_list, _("\"node\": parameter was not found"));
|
||||
error_list_append(&config_errors, _("\"node\": parameter was not found"));
|
||||
}
|
||||
else if (options->node == 0)
|
||||
{
|
||||
item_list_append(error_list, _("\"node\": must be greater than zero"));
|
||||
}
|
||||
else if (options->node < 0)
|
||||
{
|
||||
item_list_append(error_list, _("\"node\": must be a positive signed 32 bit integer, i.e. 2147483647 or less"));
|
||||
error_list_append(&config_errors, _("\"node\": must be greater than zero"));
|
||||
}
|
||||
|
||||
if (strlen(options->conninfo))
|
||||
@@ -470,11 +430,18 @@ _parse_config(t_configuration_options *options, ItemList *error_list)
|
||||
_("\"conninfo\": %s"),
|
||||
conninfo_errmsg);
|
||||
|
||||
item_list_append(error_list, error_message_buf);
|
||||
error_list_append(&config_errors, error_message_buf);
|
||||
}
|
||||
|
||||
PQconninfoFree(conninfo_options);
|
||||
}
|
||||
|
||||
if (config_errors.head != NULL)
|
||||
{
|
||||
exit_with_errors(&config_errors);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -564,85 +531,70 @@ parse_line(char *buf, char *name, char *value)
|
||||
trim(value);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* reload_config()
|
||||
*
|
||||
* This is only called by repmgrd after receiving a SIGHUP or when a monitoring
|
||||
* loop is started up; it therefore only needs to reload options required
|
||||
* by repmgrd, which are as follows:
|
||||
*
|
||||
* changeable options:
|
||||
* - failover
|
||||
* - follow_command
|
||||
* - logfacility
|
||||
* - logfile
|
||||
* - loglevel
|
||||
* - master_response_timeout
|
||||
* - monitor_interval_secs
|
||||
* - priority
|
||||
* - promote_command
|
||||
* - reconnect_attempts
|
||||
* - reconnect_interval
|
||||
* - retry_promote_interval_secs
|
||||
* - witness_repl_nodes_sync_interval_secs
|
||||
*
|
||||
* non-changeable options:
|
||||
* - cluster_name
|
||||
* - conninfo
|
||||
* - node
|
||||
* - node_name
|
||||
*
|
||||
* extract with something like:
|
||||
* grep local_options\\. repmgrd.c | perl -n -e '/local_options\.([\w_]+)/ && print qq|$1\n|;' | sort | uniq
|
||||
|
||||
*/
|
||||
bool
|
||||
reload_config(t_configuration_options *orig_options)
|
||||
{
|
||||
PGconn *conn;
|
||||
t_configuration_options new_options = T_CONFIGURATION_OPTIONS_INITIALIZER;
|
||||
t_configuration_options new_options;
|
||||
bool config_changed = false;
|
||||
bool log_config_changed = false;
|
||||
|
||||
static ItemList config_errors = { NULL, NULL };
|
||||
|
||||
/*
|
||||
* Re-read the configuration file: repmgr.conf
|
||||
*/
|
||||
log_info(_("reloading configuration file\n"));
|
||||
log_info(_("reloading configuration file and updating repmgr tables\n"));
|
||||
|
||||
_parse_config(&new_options, &config_errors);
|
||||
|
||||
if (config_errors.head != NULL)
|
||||
parse_config(&new_options);
|
||||
if (new_options.node == -1)
|
||||
{
|
||||
/* XXX dump errors to log */
|
||||
log_warning(_("unable to parse new configuration, retaining current configuration\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
/* The following options cannot be changed */
|
||||
if (strcmp(new_options.cluster_name, orig_options->cluster_name) != 0)
|
||||
{
|
||||
log_warning(_("cluster_name cannot be changed, retaining current configuration\n"));
|
||||
log_warning(_("unable to change cluster name, retaining current configuration\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (new_options.node != orig_options->node)
|
||||
{
|
||||
log_warning(_("node ID cannot be changed, retaining current configuration\n"));
|
||||
log_warning(_("unable to change node ID, retaining current configuration\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (strcmp(new_options.node_name, orig_options->node_name) != 0)
|
||||
{
|
||||
log_warning(_("node_name cannot be changed, keeping current configuration\n"));
|
||||
log_warning(_("unable to change standby name, keeping current configuration\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (new_options.failover != MANUAL_FAILOVER && new_options.failover != AUTOMATIC_FAILOVER)
|
||||
{
|
||||
log_warning(_("new value for 'failover' must be 'automatic' or 'manual'\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (new_options.master_response_timeout <= 0)
|
||||
{
|
||||
log_warning(_("new value for 'master_response_timeout' must be greater than zero\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (new_options.reconnect_attempts < 0)
|
||||
{
|
||||
log_warning(_("new value for 'reconnect_attempts' must be zero or greater\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (new_options.reconnect_interval < 0)
|
||||
{
|
||||
log_warning(_("new value for 'reconnect_interval' must be zero or greater\n"));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (strcmp(orig_options->conninfo, new_options.conninfo) != 0)
|
||||
{
|
||||
/* Test conninfo string works*/
|
||||
/* Test conninfo string */
|
||||
conn = establish_db_connection(new_options.conninfo, false);
|
||||
if (!conn || (PQstatus(conn) != CONNECTION_OK))
|
||||
{
|
||||
@@ -659,6 +611,27 @@ reload_config(t_configuration_options *orig_options)
|
||||
* to manage them
|
||||
*/
|
||||
|
||||
/* cluster_name */
|
||||
if (strcmp(orig_options->cluster_name, new_options.cluster_name) != 0)
|
||||
{
|
||||
strcpy(orig_options->cluster_name, new_options.cluster_name);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* conninfo */
|
||||
if (strcmp(orig_options->conninfo, new_options.conninfo) != 0)
|
||||
{
|
||||
strcpy(orig_options->conninfo, new_options.conninfo);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* node */
|
||||
if (orig_options->node != new_options.node)
|
||||
{
|
||||
orig_options->node = new_options.node;
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* failover */
|
||||
if (orig_options->failover != new_options.failover)
|
||||
{
|
||||
@@ -666,27 +639,6 @@ reload_config(t_configuration_options *orig_options)
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* follow_command */
|
||||
if (strcmp(orig_options->follow_command, new_options.follow_command) != 0)
|
||||
{
|
||||
strcpy(orig_options->follow_command, new_options.follow_command);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* master_response_timeout */
|
||||
if (orig_options->master_response_timeout != new_options.master_response_timeout)
|
||||
{
|
||||
orig_options->master_response_timeout = new_options.master_response_timeout;
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* monitor_interval_secs */
|
||||
if (orig_options->monitor_interval_secs != new_options.monitor_interval_secs)
|
||||
{
|
||||
orig_options->monitor_interval_secs = new_options.monitor_interval_secs;
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* priority */
|
||||
if (orig_options->priority != new_options.priority)
|
||||
{
|
||||
@@ -694,6 +646,13 @@ reload_config(t_configuration_options *orig_options)
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* node_name */
|
||||
if (strcmp(orig_options->node_name, new_options.node_name) != 0)
|
||||
{
|
||||
strcpy(orig_options->node_name, new_options.node_name);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* promote_command */
|
||||
if (strcmp(orig_options->promote_command, new_options.promote_command) != 0)
|
||||
{
|
||||
@@ -701,6 +660,44 @@ reload_config(t_configuration_options *orig_options)
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* follow_command */
|
||||
if (strcmp(orig_options->follow_command, new_options.follow_command) != 0)
|
||||
{
|
||||
strcpy(orig_options->follow_command, new_options.follow_command);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX These ones can change with a simple SIGHUP?
|
||||
*
|
||||
* strcpy (orig_options->loglevel, new_options.loglevel); strcpy
|
||||
* (orig_options->logfacility, new_options.logfacility);
|
||||
*
|
||||
* logger_shutdown(); XXX do we have progname here ? logger_init(progname,
|
||||
* orig_options.loglevel, orig_options.logfacility);
|
||||
*/
|
||||
|
||||
/* rsync_options */
|
||||
if (strcmp(orig_options->rsync_options, new_options.rsync_options) != 0)
|
||||
{
|
||||
strcpy(orig_options->rsync_options, new_options.rsync_options);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* ssh_options */
|
||||
if (strcmp(orig_options->ssh_options, new_options.ssh_options) != 0)
|
||||
{
|
||||
strcpy(orig_options->ssh_options, new_options.ssh_options);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* master_response_timeout */
|
||||
if (orig_options->master_response_timeout != new_options.master_response_timeout)
|
||||
{
|
||||
orig_options->master_response_timeout = new_options.master_response_timeout;
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* reconnect_attempts */
|
||||
if (orig_options->reconnect_attempts != new_options.reconnect_attempts)
|
||||
{
|
||||
@@ -715,6 +712,27 @@ reload_config(t_configuration_options *orig_options)
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* pg_ctl_options */
|
||||
if (strcmp(orig_options->pg_ctl_options, new_options.pg_ctl_options) != 0)
|
||||
{
|
||||
strcpy(orig_options->pg_ctl_options, new_options.pg_ctl_options);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* pg_basebackup_options */
|
||||
if (strcmp(orig_options->pg_basebackup_options, new_options.pg_basebackup_options) != 0)
|
||||
{
|
||||
strcpy(orig_options->pg_basebackup_options, new_options.pg_basebackup_options);
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* monitor_interval_secs */
|
||||
if (orig_options->monitor_interval_secs != new_options.monitor_interval_secs)
|
||||
{
|
||||
orig_options->monitor_interval_secs = new_options.monitor_interval_secs;
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/* retry_promote_interval_secs */
|
||||
if (orig_options->retry_promote_interval_secs != new_options.retry_promote_interval_secs)
|
||||
{
|
||||
@@ -722,54 +740,20 @@ reload_config(t_configuration_options *orig_options)
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
|
||||
/* witness_repl_nodes_sync_interval_secs */
|
||||
if (orig_options->witness_repl_nodes_sync_interval_secs != new_options.witness_repl_nodes_sync_interval_secs)
|
||||
/* use_replication_slots */
|
||||
if (orig_options->use_replication_slots != new_options.use_replication_slots)
|
||||
{
|
||||
orig_options->witness_repl_nodes_sync_interval_secs = new_options.witness_repl_nodes_sync_interval_secs;
|
||||
orig_options->use_replication_slots = new_options.use_replication_slots;
|
||||
config_changed = true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Handle changes to logging configuration
|
||||
*/
|
||||
if (strcmp(orig_options->logfacility, new_options.logfacility) != 0)
|
||||
{
|
||||
strcpy(orig_options->logfacility, new_options.logfacility);
|
||||
log_config_changed = true;
|
||||
}
|
||||
|
||||
if (strcmp(orig_options->logfile, new_options.logfile) != 0)
|
||||
{
|
||||
strcpy(orig_options->logfile, new_options.logfile);
|
||||
log_config_changed = true;
|
||||
}
|
||||
|
||||
|
||||
if (strcmp(orig_options->loglevel, new_options.loglevel) != 0)
|
||||
{
|
||||
strcpy(orig_options->loglevel, new_options.loglevel);
|
||||
log_config_changed = true;
|
||||
}
|
||||
|
||||
if (log_config_changed == true)
|
||||
{
|
||||
log_notice(_("restarting logging with changed parameters\n"));
|
||||
logger_shutdown();
|
||||
logger_init(orig_options, progname());
|
||||
}
|
||||
|
||||
if (config_changed == true)
|
||||
{
|
||||
log_notice(_("configuration file reloaded with changed parameters\n"));
|
||||
log_debug(_("reload_config(): configuration has changed\n"));
|
||||
}
|
||||
/*
|
||||
* if logging configuration changed, don't say the configuration didn't
|
||||
* change, as it clearly has.
|
||||
*/
|
||||
else if (log_config_changed == false)
|
||||
else
|
||||
{
|
||||
log_info(_("configuration has not changed\n"));
|
||||
log_debug(_("reload_config(): configuration has not changed\n"));
|
||||
}
|
||||
|
||||
return config_changed;
|
||||
@@ -777,11 +761,11 @@ reload_config(t_configuration_options *orig_options)
|
||||
|
||||
|
||||
void
|
||||
item_list_append(ItemList *item_list, char *error_message)
|
||||
error_list_append(ErrorList *error_list, char *error_message)
|
||||
{
|
||||
ItemListCell *cell;
|
||||
ErrorListCell *cell;
|
||||
|
||||
cell = (ItemListCell *) pg_malloc0(sizeof(ItemListCell));
|
||||
cell = (ErrorListCell *) pg_malloc0(sizeof(ErrorListCell));
|
||||
|
||||
if (cell == NULL)
|
||||
{
|
||||
@@ -789,19 +773,19 @@ item_list_append(ItemList *item_list, char *error_message)
|
||||
exit(ERR_BAD_CONFIG);
|
||||
}
|
||||
|
||||
cell->string = pg_malloc0(MAXLEN);
|
||||
strncpy(cell->string, error_message, MAXLEN);
|
||||
cell->error_message = pg_malloc0(MAXLEN);
|
||||
strncpy(cell->error_message, error_message, MAXLEN);
|
||||
|
||||
if (item_list->tail)
|
||||
if (error_list->tail)
|
||||
{
|
||||
item_list->tail->next = cell;
|
||||
error_list->tail->next = cell;
|
||||
}
|
||||
else
|
||||
{
|
||||
item_list->head = cell;
|
||||
error_list->head = cell;
|
||||
}
|
||||
|
||||
item_list->tail = cell;
|
||||
error_list->tail = cell;
|
||||
}
|
||||
|
||||
|
||||
@@ -811,7 +795,7 @@ item_list_append(ItemList *item_list, char *error_message)
|
||||
* otherwise exit
|
||||
*/
|
||||
int
|
||||
repmgr_atoi(const char *value, const char *config_item, ItemList *error_list, bool allow_negative)
|
||||
repmgr_atoi(const char *value, const char *config_item, ErrorList *error_list, bool allow_negative)
|
||||
{
|
||||
char *endptr;
|
||||
long longval = 0;
|
||||
@@ -860,7 +844,7 @@ repmgr_atoi(const char *value, const char *config_item, ItemList *error_list, bo
|
||||
exit(ERR_BAD_CONFIG);
|
||||
}
|
||||
|
||||
item_list_append(error_list, error_message_buf);
|
||||
error_list_append(error_list, error_message_buf);
|
||||
}
|
||||
|
||||
return (int32) longval;
|
||||
@@ -943,7 +927,7 @@ static void
|
||||
parse_event_notifications_list(t_configuration_options *options, const char *arg)
|
||||
{
|
||||
const char *arg_ptr;
|
||||
char event_type_buf[MAXLEN] = "";
|
||||
char event_type_buf[MAXLEN] = "";
|
||||
char *dst_ptr = event_type_buf;
|
||||
|
||||
|
||||
@@ -1002,15 +986,15 @@ parse_event_notifications_list(t_configuration_options *options, const char *arg
|
||||
|
||||
|
||||
static void
|
||||
exit_with_errors(ItemList *config_errors)
|
||||
exit_with_errors(ErrorList *config_errors)
|
||||
{
|
||||
ItemListCell *cell;
|
||||
ErrorListCell *cell;
|
||||
|
||||
log_err(_("%s: following errors were found in the configuration file.\n"), progname());
|
||||
|
||||
for (cell = config_errors->head; cell; cell = cell->next)
|
||||
{
|
||||
log_err("%s\n", cell->string);
|
||||
log_err("%s\n", cell->error_message);
|
||||
}
|
||||
|
||||
exit(ERR_BAD_CONFIG);
|
||||
|
||||
57
config.h
57
config.h
@@ -1,7 +1,6 @@
|
||||
/*
|
||||
* config.h
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -58,20 +57,11 @@ typedef struct
|
||||
int node;
|
||||
int upstream_node;
|
||||
char conninfo[MAXLEN];
|
||||
char barman_server[MAXLEN];
|
||||
char barman_config[MAXLEN];
|
||||
int failover;
|
||||
int priority;
|
||||
char node_name[MAXLEN];
|
||||
/* commands executed by repmgrd */
|
||||
char promote_command[MAXLEN];
|
||||
char follow_command[MAXLEN];
|
||||
/* Overrides for pg_ctl commands */
|
||||
char service_stop_command[MAXLEN];
|
||||
char service_start_command[MAXLEN];
|
||||
char service_restart_command[MAXLEN];
|
||||
char service_reload_command[MAXLEN];
|
||||
char service_promote_command[MAXLEN];
|
||||
char loglevel[MAXLEN];
|
||||
char logfacility[MAXLEN];
|
||||
char rsync_options[QUERY_STR_LEN];
|
||||
@@ -97,51 +87,32 @@ typedef struct
|
||||
* The following will initialize the structure with a minimal set of options;
|
||||
* actual defaults are set in parse_config() before parsing the configuration file
|
||||
*/
|
||||
#define T_CONFIGURATION_OPTIONS_INITIALIZER { "", UNKNOWN_NODE_ID, NO_UPSTREAM_NODE, "", "", "", MANUAL_FAILOVER, -1, "", "", "", "", "", "", "", "", "", "", "", "", -1, -1, -1, "", "", "", "", "", 0, 0, 0, 0, "", { NULL, NULL }, { NULL, NULL } }
|
||||
#define T_CONFIGURATION_OPTIONS_INITIALIZER { "", -1, NO_UPSTREAM_NODE, "", MANUAL_FAILOVER, -1, "", "", "", "", "", "", "", -1, -1, -1, "", "", "", "", "", 0, 0, 0, 0, "", { NULL, NULL }, { NULL, NULL } }
|
||||
|
||||
typedef struct ItemListCell
|
||||
typedef struct ErrorListCell
|
||||
{
|
||||
struct ItemListCell *next;
|
||||
char *string;
|
||||
} ItemListCell;
|
||||
struct ErrorListCell *next;
|
||||
char *error_message;
|
||||
} ErrorListCell;
|
||||
|
||||
typedef struct ItemList
|
||||
typedef struct ErrorList
|
||||
{
|
||||
ItemListCell *head;
|
||||
ItemListCell *tail;
|
||||
} ItemList;
|
||||
|
||||
typedef struct TablespaceDataListCell
|
||||
{
|
||||
struct TablespaceDataListCell *next;
|
||||
char *name;
|
||||
char *oid;
|
||||
char *location;
|
||||
/* optional payload */
|
||||
FILE *f;
|
||||
} TablespaceDataListCell;
|
||||
|
||||
typedef struct TablespaceDataList
|
||||
{
|
||||
TablespaceDataListCell *head;
|
||||
TablespaceDataListCell *tail;
|
||||
} TablespaceDataList;
|
||||
ErrorListCell *head;
|
||||
ErrorListCell *tail;
|
||||
} ErrorList;
|
||||
|
||||
void set_progname(const char *argv0);
|
||||
const char * progname(void);
|
||||
|
||||
bool load_config(const char *config_file, bool verbose, t_configuration_options *options, char *argv0);
|
||||
|
||||
void _parse_config(t_configuration_options *options, ItemList *error_list);
|
||||
bool parse_config(t_configuration_options *options);
|
||||
bool reload_config(t_configuration_options *orig_options);
|
||||
|
||||
bool parse_config(t_configuration_options *options);
|
||||
void parse_line(char *buff, char *name, char *value);
|
||||
char *trim(char *s);
|
||||
void item_list_append(ItemList *item_list, char *error_message);
|
||||
void error_list_append(ErrorList *error_list, char *error_message);
|
||||
int repmgr_atoi(const char *s,
|
||||
const char *config_item,
|
||||
ItemList *error_list,
|
||||
ErrorList *error_list,
|
||||
bool allow_negative);
|
||||
extern bool config_file_found;
|
||||
|
||||
#endif
|
||||
|
||||
331
dbutils.c
331
dbutils.c
@@ -1,7 +1,6 @@
|
||||
/*
|
||||
* dbutils.c - Database connection/management functions
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -33,18 +32,9 @@ char repmgr_schema[MAXLEN] = "";
|
||||
char repmgr_schema_quoted[MAXLEN] = "";
|
||||
|
||||
static int _get_node_record(PGconn *conn, char *cluster, char *sqlquery, t_node_info *node_info);
|
||||
static bool _set_config(PGconn *conn, const char *config_param, const char *sqlquery);
|
||||
|
||||
/*
|
||||
* _establish_db_connection()
|
||||
*
|
||||
* Connect to a database using a conninfo string.
|
||||
*
|
||||
* NOTE: *do not* use this for replication connections; use establish_db_connection_by_params() instead.
|
||||
*/
|
||||
|
||||
PGconn *
|
||||
_establish_db_connection(const char *conninfo, const bool exit_on_error, const bool log_notice, const bool verbose_only)
|
||||
_establish_db_connection(const char *conninfo, const bool exit_on_error, const bool log_notice)
|
||||
{
|
||||
/* Make a connection to the database */
|
||||
PGconn *conn = NULL;
|
||||
@@ -60,23 +50,15 @@ _establish_db_connection(const char *conninfo, const bool exit_on_error, const b
|
||||
/* Check to see that the backend connection was successfully made */
|
||||
if ((PQstatus(conn) != CONNECTION_OK))
|
||||
{
|
||||
bool emit_log = true;
|
||||
|
||||
if (verbose_only == true && verbose_logging == false)
|
||||
emit_log = false;
|
||||
|
||||
if (emit_log)
|
||||
if (log_notice)
|
||||
{
|
||||
if (log_notice)
|
||||
{
|
||||
log_notice(_("connection to database failed: %s\n"),
|
||||
PQerrorMessage(conn));
|
||||
}
|
||||
else
|
||||
{
|
||||
log_err(_("connection to database failed: %s\n"),
|
||||
PQerrorMessage(conn));
|
||||
}
|
||||
log_notice(_("connection to database failed: %s\n"),
|
||||
PQerrorMessage(conn));
|
||||
}
|
||||
else
|
||||
{
|
||||
log_err(_("connection to database failed: %s\n"),
|
||||
PQerrorMessage(conn));
|
||||
}
|
||||
|
||||
if (exit_on_error)
|
||||
@@ -86,51 +68,19 @@ _establish_db_connection(const char *conninfo, const bool exit_on_error, const b
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* set "synchronous_commit" to "local" in case synchronous replication is in use
|
||||
*/
|
||||
|
||||
else if (set_config(conn, "synchronous_commit", "local") == false)
|
||||
{
|
||||
if (exit_on_error)
|
||||
{
|
||||
PQfinish(conn);
|
||||
exit(ERR_DB_CON);
|
||||
}
|
||||
}
|
||||
|
||||
return conn;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Establish a database connection, optionally exit on error
|
||||
*/
|
||||
PGconn *
|
||||
establish_db_connection(const char *conninfo, const bool exit_on_error)
|
||||
{
|
||||
return _establish_db_connection(conninfo, exit_on_error, false, false);
|
||||
return _establish_db_connection(conninfo, exit_on_error, false);
|
||||
}
|
||||
|
||||
/*
|
||||
* Attempt to establish a database connection, never exit on error, only
|
||||
* output error messages if --verbose option used
|
||||
*/
|
||||
PGconn *
|
||||
establish_db_connection_quiet(const char *conninfo)
|
||||
test_db_connection(const char *conninfo, const bool exit_on_error)
|
||||
{
|
||||
return _establish_db_connection(conninfo, false, false, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* Attempt to establish a database connection, never exit on error,
|
||||
* output connection error messages as NOTICE (useful when connection
|
||||
* failure is expected)
|
||||
*/
|
||||
PGconn *
|
||||
test_db_connection(const char *conninfo)
|
||||
{
|
||||
return _establish_db_connection(conninfo, false, true, false);
|
||||
return _establish_db_connection(conninfo, exit_on_error, true);
|
||||
}
|
||||
|
||||
|
||||
@@ -138,12 +88,8 @@ PGconn *
|
||||
establish_db_connection_by_params(const char *keywords[], const char *values[],
|
||||
const bool exit_on_error)
|
||||
{
|
||||
PGconn *conn;
|
||||
bool replication_connection = false;
|
||||
int i;
|
||||
|
||||
/* Connect to the database using the provided parameters */
|
||||
conn = PQconnectdbParams(keywords, values, true);
|
||||
/* Make a connection to the database */
|
||||
PGconn *conn = PQconnectdbParams(keywords, values, true);
|
||||
|
||||
/* Check to see that the backend connection was successfully made */
|
||||
if ((PQstatus(conn) != CONNECTION_OK))
|
||||
@@ -156,28 +102,6 @@ establish_db_connection_by_params(const char *keywords[], const char *values[],
|
||||
exit(ERR_DB_CON);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
* set "synchronous_commit" to "local" in case synchronous replication is in
|
||||
* use (provided this is not a replication connection)
|
||||
*/
|
||||
|
||||
for (i = 0; keywords[i]; i++)
|
||||
{
|
||||
if (strcmp(keywords[i], "replication") == 0)
|
||||
replication_connection = true;
|
||||
}
|
||||
|
||||
if (replication_connection == false && set_config(conn, "synchronous_commit", "local") == false)
|
||||
{
|
||||
if (exit_on_error)
|
||||
{
|
||||
PQfinish(conn);
|
||||
exit(ERR_DB_CON);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return conn;
|
||||
}
|
||||
@@ -262,7 +186,7 @@ check_cluster_schema(PGconn *conn)
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = '%s'",
|
||||
"SELECT 1 FROM pg_namespace WHERE nspname = '%s'",
|
||||
get_repmgr_schema());
|
||||
|
||||
log_verbose(LOG_DEBUG, "check_cluster_schema(): %s\n", sqlquery);
|
||||
@@ -327,6 +251,7 @@ is_pgup(PGconn *conn, int timeout)
|
||||
/* Check the connection status twice in case it changes after reset */
|
||||
bool twice = false;
|
||||
|
||||
/* Check the connection status twice in case it changes after reset */
|
||||
for (;;)
|
||||
{
|
||||
if (PQstatus(conn) != CONNECTION_OK)
|
||||
@@ -456,7 +381,7 @@ guc_set(PGconn *conn, const char *parameter, const char *op,
|
||||
int retval = 1;
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT true FROM pg_catalog.pg_settings "
|
||||
"SELECT true FROM pg_settings "
|
||||
" WHERE name = '%s' AND setting %s '%s'",
|
||||
parameter, op, value);
|
||||
|
||||
@@ -492,7 +417,7 @@ guc_set_typed(PGconn *conn, const char *parameter, const char *op,
|
||||
int retval = 1;
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT true FROM pg_catalog.pg_settings "
|
||||
"SELECT true FROM pg_settings "
|
||||
" WHERE name = '%s' AND setting::%s %s '%s'::%s",
|
||||
parameter, datatype, op, value, datatype);
|
||||
|
||||
@@ -524,7 +449,7 @@ get_cluster_size(PGconn *conn, char *size)
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT pg_catalog.pg_size_pretty(SUM(pg_catalog.pg_database_size(oid))::bigint) "
|
||||
" FROM pg_catalog.pg_database ");
|
||||
" FROM pg_database ");
|
||||
|
||||
log_verbose(LOG_DEBUG, "get_cluster_size():\n%s\n", sqlquery);
|
||||
|
||||
@@ -551,11 +476,11 @@ get_pg_setting(PGconn *conn, const char *setting, char *output)
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
PGresult *res;
|
||||
int i;
|
||||
bool success = false;
|
||||
bool success = true;
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT name, setting "
|
||||
" FROM pg_catalog.pg_settings WHERE name = '%s'",
|
||||
" FROM pg_settings WHERE name = '%s'",
|
||||
setting);
|
||||
|
||||
log_verbose(LOG_DEBUG, "get_pg_setting(): %s\n", sqlquery);
|
||||
@@ -992,7 +917,7 @@ get_repmgr_schema_quoted(PGconn *conn)
|
||||
|
||||
|
||||
bool
|
||||
create_replication_slot(PGconn *conn, char *slot_name, int server_version_num, PQExpBufferData *error_msg)
|
||||
create_replication_slot(PGconn *conn, char *slot_name, int server_version_num)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
int query_res;
|
||||
@@ -1011,9 +936,8 @@ create_replication_slot(PGconn *conn, char *slot_name, int server_version_num, P
|
||||
{
|
||||
if (strcmp(slot_info.slot_type, "physical") != 0)
|
||||
{
|
||||
appendPQExpBuffer(error_msg,
|
||||
_("Slot '%s' exists and is not a physical slot\n"),
|
||||
slot_name);
|
||||
log_err(_("Slot '%s' exists and is not a physical slot\n"),
|
||||
slot_name);
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1025,9 +949,8 @@ create_replication_slot(PGconn *conn, char *slot_name, int server_version_num, P
|
||||
return true;
|
||||
}
|
||||
|
||||
appendPQExpBuffer(error_msg,
|
||||
_("Slot '%s' already exists as an active slot\n"),
|
||||
slot_name);
|
||||
log_err(_("Slot '%s' already exists as an active slot\n"),
|
||||
slot_name);
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1035,26 +958,25 @@ create_replication_slot(PGconn *conn, char *slot_name, int server_version_num, P
|
||||
if (server_version_num >= 90600)
|
||||
{
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT * FROM pg_catalog.pg_create_physical_replication_slot('%s', TRUE)",
|
||||
"SELECT * FROM pg_create_physical_replication_slot('%s', TRUE)",
|
||||
slot_name);
|
||||
}
|
||||
else
|
||||
{
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT * FROM pg_catalog.pg_create_physical_replication_slot('%s')",
|
||||
"SELECT * FROM pg_create_physical_replication_slot('%s')",
|
||||
slot_name);
|
||||
}
|
||||
|
||||
log_debug(_("create_replication_slot(): Creating slot '%s' on master\n"), slot_name);
|
||||
log_debug(_("create_replication_slot(): Creating slot '%s' on primary\n"), slot_name);
|
||||
log_verbose(LOG_DEBUG, "create_replication_slot():\n%s\n", sqlquery);
|
||||
|
||||
res = PQexec(conn, sqlquery);
|
||||
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
|
||||
{
|
||||
appendPQExpBuffer(error_msg,
|
||||
_("unable to create slot '%s' on the master node: %s\n"),
|
||||
slot_name,
|
||||
PQerrorMessage(conn));
|
||||
log_err(_("unable to create slot '%s' on the primary node: %s\n"),
|
||||
slot_name,
|
||||
PQerrorMessage(conn));
|
||||
PQclear(res);
|
||||
return false;
|
||||
}
|
||||
@@ -1072,7 +994,7 @@ get_slot_record(PGconn *conn, char *slot_name, t_replication_slot *record)
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT slot_name, slot_type, active "
|
||||
" FROM pg_catalog.pg_replication_slots "
|
||||
" FROM pg_replication_slots "
|
||||
" WHERE slot_name = '%s' ",
|
||||
slot_name);
|
||||
|
||||
@@ -1132,25 +1054,15 @@ drop_replication_slot(PGconn *conn, char *slot_name)
|
||||
|
||||
|
||||
bool
|
||||
start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint, int server_version_num)
|
||||
start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
PGresult *res;
|
||||
|
||||
if (server_version_num >= 100000)
|
||||
{
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT pg_catalog.pg_walfile_name(pg_catalog.pg_start_backup('repmgr_standby_clone_%ld', %s))",
|
||||
time(NULL),
|
||||
fast_checkpoint ? "TRUE" : "FALSE");
|
||||
}
|
||||
else
|
||||
{
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT pg_catalog.pg_xlogfile_name(pg_catalog.pg_start_backup('repmgr_standby_clone_%ld', %s))",
|
||||
time(NULL),
|
||||
fast_checkpoint ? "TRUE" : "FALSE");
|
||||
}
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT pg_catalog.pg_xlogfile_name(pg_catalog.pg_start_backup('repmgr_standby_clone_%ld', %s))",
|
||||
time(NULL),
|
||||
fast_checkpoint ? "TRUE" : "FALSE");
|
||||
|
||||
log_verbose(LOG_DEBUG, "start_backup():\n%s\n", sqlquery);
|
||||
|
||||
@@ -1178,19 +1090,12 @@ start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint, int se
|
||||
|
||||
|
||||
bool
|
||||
stop_backup(PGconn *conn, char *last_wal_segment, int server_version_num)
|
||||
stop_backup(PGconn *conn, char *last_wal_segment)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
PGresult *res;
|
||||
|
||||
if (server_version_num >= 100000)
|
||||
{
|
||||
sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_walfile_name(pg_catalog.pg_stop_backup())");
|
||||
}
|
||||
else
|
||||
{
|
||||
sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_xlogfile_name(pg_catalog.pg_stop_backup())");
|
||||
}
|
||||
sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_xlogfile_name(pg_catalog.pg_stop_backup())");
|
||||
|
||||
res = PQexec(conn, sqlquery);
|
||||
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
||||
@@ -1215,12 +1120,19 @@ stop_backup(PGconn *conn, char *last_wal_segment, int server_version_num)
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool
|
||||
_set_config(PGconn *conn, const char *config_param, const char *sqlquery)
|
||||
set_config_bool(PGconn *conn, const char *config_param, bool state)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
PGresult *res;
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SET %s TO %s",
|
||||
config_param,
|
||||
state ? "TRUE" : "FALSE");
|
||||
|
||||
log_verbose(LOG_DEBUG, "set_config_bool():\n%s\n", sqlquery);
|
||||
|
||||
res = PQexec(conn, sqlquery);
|
||||
|
||||
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
||||
@@ -1235,36 +1147,6 @@ _set_config(PGconn *conn, const char *config_param, const char *sqlquery)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
set_config(PGconn *conn, const char *config_param, const char *config_value)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SET %s TO '%s'",
|
||||
config_param,
|
||||
config_value);
|
||||
|
||||
log_verbose(LOG_DEBUG, "set_config():\n%s\n", sqlquery);
|
||||
|
||||
return _set_config(conn, config_param, sqlquery);
|
||||
}
|
||||
|
||||
bool
|
||||
set_config_bool(PGconn *conn, const char *config_param, bool state)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SET %s TO %s",
|
||||
config_param,
|
||||
state ? "TRUE" : "FALSE");
|
||||
|
||||
log_verbose(LOG_DEBUG, "set_config_bool():\n%s\n", sqlquery);
|
||||
|
||||
return _set_config(conn, config_param, sqlquery);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* witness_copy_node_records()
|
||||
@@ -1314,8 +1196,7 @@ witness_copy_node_records(PGconn *masterconn, PGconn *witnessconn, char *cluster
|
||||
|
||||
/* Get current records from primary */
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"SELECT id, type, upstream_node_id, name, conninfo, priority, slot_name, active "
|
||||
" FROM %s.repl_nodes",
|
||||
"SELECT id, type, upstream_node_id, name, conninfo, priority, slot_name, active FROM %s.repl_nodes",
|
||||
get_repmgr_schema_quoted(masterconn));
|
||||
|
||||
log_verbose(LOG_DEBUG, "witness_copy_node_records():\n%s\n", sqlquery);
|
||||
@@ -1429,8 +1310,7 @@ create_node_record(PGconn *conn, char *action, int node, char *type, int upstrea
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"INSERT INTO %s.repl_nodes "
|
||||
" (id, type, upstream_node_id, cluster, "
|
||||
" name, conninfo, slot_name, "
|
||||
" priority, active) "
|
||||
" name, conninfo, slot_name, priority, active) "
|
||||
"VALUES (%i, '%s', %s, '%s', '%s', '%s', %s, %i, %s) ",
|
||||
get_repmgr_schema_quoted(conn),
|
||||
node,
|
||||
@@ -1524,11 +1404,10 @@ create_event_record(PGconn *conn, t_configuration_options *options, int node_id,
|
||||
bool success = true;
|
||||
struct tm ts;
|
||||
|
||||
/*
|
||||
* Only attempt to write a record if a connection handle was provided.
|
||||
* Also check that the repmgr schema has been properly initialised - if
|
||||
* not it means no configuration file was provided, which can happen with
|
||||
* e.g. `repmgr standby clone`, and we won't know which schema to write to.
|
||||
/* Only attempt to write a record if a connection handle was provided.
|
||||
Also check that the repmgr schema has been properly intialised - if
|
||||
not it means no configuration file was provided, which can happen with
|
||||
e.g. `repmgr standby clone`, and we won't know which schema to write to.
|
||||
*/
|
||||
if (conn != NULL && strcmp(repmgr_schema, DEFAULT_REPMGR_SCHEMA_PREFIX) != 0)
|
||||
{
|
||||
@@ -1577,6 +1456,7 @@ create_event_record(PGconn *conn, t_configuration_options *options, int node_id,
|
||||
PQerrorMessage(conn));
|
||||
|
||||
success = false;
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1717,89 +1597,6 @@ create_event_record(PGconn *conn, t_configuration_options *options, int node_id,
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
update_node_record(PGconn *conn, char *action, int node, char *type, int upstream_node, char *cluster_name, char *node_name, char *conninfo, int priority, char *slot_name, bool active)
|
||||
{
|
||||
char sqlquery[QUERY_STR_LEN];
|
||||
char upstream_node_id[MAXLEN];
|
||||
char slot_name_buf[MAXLEN];
|
||||
PGresult *res;
|
||||
|
||||
/* XXX this segment copied from create_node_record() */
|
||||
if (upstream_node == NO_UPSTREAM_NODE)
|
||||
{
|
||||
/*
|
||||
* No explicit upstream node id provided for standby - attempt to
|
||||
* get primary node id
|
||||
*/
|
||||
if (strcmp(type, "standby") == 0)
|
||||
{
|
||||
int primary_node_id = get_master_node_id(conn, cluster_name);
|
||||
maxlen_snprintf(upstream_node_id, "%i", primary_node_id);
|
||||
}
|
||||
else
|
||||
{
|
||||
maxlen_snprintf(upstream_node_id, "%s", "NULL");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
maxlen_snprintf(upstream_node_id, "%i", upstream_node);
|
||||
}
|
||||
|
||||
if (slot_name != NULL && slot_name[0])
|
||||
{
|
||||
maxlen_snprintf(slot_name_buf, "'%s'", slot_name);
|
||||
}
|
||||
else
|
||||
{
|
||||
maxlen_snprintf(slot_name_buf, "%s", "NULL");
|
||||
}
|
||||
|
||||
/* XXX convert to placeholder query */
|
||||
sqlquery_snprintf(sqlquery,
|
||||
"UPDATE %s.repl_nodes SET "
|
||||
" type = '%s', "
|
||||
" upstream_node_id = %s, "
|
||||
" cluster = '%s', "
|
||||
" name = '%s', "
|
||||
" conninfo = '%s', "
|
||||
" slot_name = %s, "
|
||||
" priority = %i, "
|
||||
" active = %s "
|
||||
" WHERE id = %i ",
|
||||
get_repmgr_schema_quoted(conn),
|
||||
type,
|
||||
upstream_node_id,
|
||||
cluster_name,
|
||||
node_name,
|
||||
conninfo,
|
||||
slot_name_buf,
|
||||
priority,
|
||||
active == true ? "TRUE" : "FALSE",
|
||||
node);
|
||||
|
||||
log_verbose(LOG_DEBUG, "update_node_record(): %s\n", sqlquery);
|
||||
|
||||
if (action != NULL)
|
||||
{
|
||||
log_verbose(LOG_DEBUG, "update_node_record(): action is \"%s\"\n", action);
|
||||
}
|
||||
|
||||
res = PQexec(conn, sqlquery);
|
||||
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
|
||||
{
|
||||
log_err(_("Unable to update node record\n%s\n"),
|
||||
PQerrorMessage(conn));
|
||||
PQclear(res);
|
||||
return false;
|
||||
}
|
||||
|
||||
PQclear(res);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Update node record following change of status
|
||||
* (e.g. inactive primary converted to standby)
|
||||
@@ -1889,8 +1686,7 @@ get_node_record(PGconn *conn, char *cluster, int node_id, t_node_info *node_info
|
||||
|
||||
sqlquery_snprintf(
|
||||
sqlquery,
|
||||
"SELECT id, type, upstream_node_id, name, conninfo, "
|
||||
" slot_name, priority, active"
|
||||
"SELECT id, type, upstream_node_id, name, conninfo, slot_name, priority, active"
|
||||
" FROM %s.repl_nodes "
|
||||
" WHERE cluster = '%s' "
|
||||
" AND id = %i",
|
||||
@@ -1960,16 +1756,7 @@ _get_node_record(PGconn *conn, char *cluster, char *sqlquery, t_node_info *node_
|
||||
|
||||
node_info->node_id = atoi(PQgetvalue(res, 0, 0));
|
||||
node_info->type = parse_node_type(PQgetvalue(res, 0, 1));
|
||||
|
||||
if (PQgetisnull(res, 0, 2))
|
||||
{
|
||||
node_info->upstream_node_id = NO_UPSTREAM_NODE;
|
||||
}
|
||||
else
|
||||
{
|
||||
node_info->upstream_node_id = atoi(PQgetvalue(res, 0, 2));
|
||||
}
|
||||
|
||||
node_info->upstream_node_id = atoi(PQgetvalue(res, 0, 2));
|
||||
strncpy(node_info->name, PQgetvalue(res, 0, 3), MAXLEN);
|
||||
strncpy(node_info->conninfo_str, PQgetvalue(res, 0, 4), MAXLEN);
|
||||
strncpy(node_info->slot_name, PQgetvalue(res, 0, 5), MAXLEN);
|
||||
|
||||
21
dbutils.h
21
dbutils.h
@@ -1,7 +1,6 @@
|
||||
/*
|
||||
* dbutils.h
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -22,7 +21,6 @@
|
||||
#define _REPMGR_DBUTILS_H_
|
||||
|
||||
#include "access/xlogdefs.h"
|
||||
#include "pqexpbuffer.h"
|
||||
|
||||
#include "config.h"
|
||||
#include "strutil.h"
|
||||
@@ -79,16 +77,15 @@ typedef struct s_replication_slot
|
||||
bool active;
|
||||
} t_replication_slot;
|
||||
|
||||
extern char repmgr_schema[MAXLEN];
|
||||
|
||||
|
||||
PGconn *_establish_db_connection(const char *conninfo,
|
||||
const bool exit_on_error,
|
||||
const bool log_notice,
|
||||
const bool verbose_only);
|
||||
const bool log_notice);
|
||||
PGconn *establish_db_connection(const char *conninfo,
|
||||
const bool exit_on_error);
|
||||
PGconn *establish_db_connection_quiet(const char *conninfo);
|
||||
PGconn *test_db_connection(const char *conninfo);
|
||||
PGconn *test_db_connection(const char *conninfo,
|
||||
const bool exit_on_error);
|
||||
PGconn *establish_db_connection_by_params(const char *keywords[],
|
||||
const char *values[],
|
||||
const bool exit_on_error);
|
||||
@@ -119,19 +116,17 @@ int wait_connection_availability(PGconn *conn, long long timeout);
|
||||
bool cancel_query(PGconn *conn, int timeout);
|
||||
char *get_repmgr_schema(void);
|
||||
char *get_repmgr_schema_quoted(PGconn *conn);
|
||||
bool create_replication_slot(PGconn *conn, char *slot_name, int server_version_num, PQExpBufferData *error_msg);
|
||||
bool create_replication_slot(PGconn *conn, char *slot_name, int server_version_num);
|
||||
int get_slot_record(PGconn *conn, char *slot_name, t_replication_slot *record);
|
||||
bool drop_replication_slot(PGconn *conn, char *slot_name);
|
||||
bool start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint, int server_version_num);
|
||||
bool stop_backup(PGconn *conn, char *last_wal_segment, int server_version_num);
|
||||
bool set_config(PGconn *conn, const char *config_param, const char *config_value);
|
||||
bool start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint);
|
||||
bool stop_backup(PGconn *conn, char *last_wal_segment);
|
||||
bool set_config_bool(PGconn *conn, const char *config_param, bool state);
|
||||
bool witness_copy_node_records(PGconn *masterconn, PGconn *witnessconn, char *cluster_name);
|
||||
bool create_node_record(PGconn *conn, char *action, int node, char *type, int upstream_node, char *cluster_name, char *node_name, char *conninfo, int priority, char *slot_name, bool active);
|
||||
bool delete_node_record(PGconn *conn, int node, char *action);
|
||||
int get_node_record(PGconn *conn, char *cluster, int node_id, t_node_info *node_info);
|
||||
int get_node_record_by_name(PGconn *conn, char *cluster, const char *node_name, t_node_info *node_info);
|
||||
bool update_node_record(PGconn *conn, char *action, int node, char *type, int upstream_node, char *cluster_name, char *node_name, char *conninfo, int priority, char *slot_name, bool active);
|
||||
bool update_node_record_status(PGconn *conn, char *cluster_name, int this_node_id, char *type, int upstream_node_id, bool active);
|
||||
bool update_node_record_set_upstream(PGconn *conn, char *cluster_name, int this_node_id, int new_upstream_node_id);
|
||||
bool create_event_record(PGconn *conn, t_configuration_options *options, int node_id, char *event, bool successful, char *details);
|
||||
|
||||
2
debian/DEBIAN/control
vendored
2
debian/DEBIAN/control
vendored
@@ -1,5 +1,5 @@
|
||||
Package: repmgr-auto
|
||||
Version: 3.2dev
|
||||
Version: 3.1.3
|
||||
Section: database
|
||||
Priority: optional
|
||||
Architecture: all
|
||||
|
||||
2
dirmod.c
2
dirmod.c
@@ -3,7 +3,7 @@
|
||||
* dirmod.c
|
||||
* directory handling functions
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
|
||||
2
dirmod.h
2
dirmod.h
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* dirmod.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
repmgrd's failover algorithm
|
||||
============================
|
||||
|
||||
When implementing automatic failover, there are two factors which are critical in
|
||||
ensuring the desired result is achieved:
|
||||
|
||||
- has the master node genuinely failed?
|
||||
- which is the best node to promote to the new master?
|
||||
|
||||
This document outlines repmgrd's decision-making process during automatic failover
|
||||
for standbys directly connected to the master node.
|
||||
|
||||
|
||||
Master node failure detection
|
||||
-----------------------------
|
||||
|
||||
If a `repmgrd` instance running on a PostgreSQL standby node is unable to connect to
|
||||
the master node, this doesn't neccesarily mean that the master is down and a
|
||||
failover is required. Factors such as network connectivity issues could mean that
|
||||
even though the standby node is isolated, the replication cluster as a whole
|
||||
is functioning correctly, and promoting the standby without further verification
|
||||
could result in a "split-brain" situation.
|
||||
|
||||
In the event that `repmgrd` is unable to connect to the master node, it will attempt
|
||||
to reconnect to the master server several times (as defined by the `reconnect_attempts`
|
||||
parameter in `repmgr.conf`), with reconnection attempts occuring at the interval
|
||||
specified by `reconnect_interval`. This happens to verify that the master is definitively
|
||||
not accessible (e.g. that connection was not lost due to a brief network glitch).
|
||||
|
||||
Appropriate values for these settings will depend very much on the replication
|
||||
cluster environment. There will necessarily be a trade-off between the time it
|
||||
takes to assume the master is not reachable, and the reliability of that conclusion.
|
||||
A standby in a different physical location to the master will probably need a longer
|
||||
check interval to rule out possible network issues, whereas one located in the same
|
||||
rack with a direct connection between servers could perform the check very quickly.
|
||||
|
||||
Note that it's possible the master comes back online after this point is reached,
|
||||
but before a new master has been selected; in this case it will be noticed
|
||||
during the selection of a new master and no actual failover will take place.
|
||||
|
||||
Promotion candidate selection
|
||||
-----------------------------
|
||||
|
||||
Once `repmgrd` has decided the master is definitively unreachable, following checks
|
||||
will be carried out:
|
||||
|
||||
* attempts to connect to all other nodes in the cluster (including the witness
|
||||
node, if defined) to establish the state of the cluster, including their
|
||||
current LSN
|
||||
|
||||
* If less than half of the nodes are visible (from the viewpoint
|
||||
of this node), `repmgrd` will not take any further action. This is to ensure that
|
||||
e.g. if a replication cluster is spread over multiple data centres, a split-brain
|
||||
situation does not occur if there is a network failure between datacentres. Note
|
||||
that if nodes are split evenly between data centres, a witness server can be
|
||||
used to establish the "majority" data centre.
|
||||
|
||||
* `repmgrd` polls all visible servers and waits for each node to return a valid LSN;
|
||||
it updates the LSN previously stored for this node if it has increased since
|
||||
the initial check
|
||||
|
||||
* once all LSNs have been retrieved, `repmgrd` will check for the highest LSN; if
|
||||
its own node has the highest LSN, it will attempt to promote itself (using the
|
||||
command defined in `promote_command` in `repmgr.conf`. Note that if using
|
||||
`repmgr standby promote` as the promotion command, and the original master becomes available
|
||||
before the promotion takes effect, `repmgr` will return an error and no promotion
|
||||
will take place, and `repmgrd` will resume monitoring as usual.
|
||||
|
||||
* if the node is not the promotion candidate, `repmgrd` will execute the
|
||||
`follow_command` defined in `repmgr.conf`. If using `repmgr standby follow` here,
|
||||
`repmgr` will attempt to detect the new master node and attach to that.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,152 +0,0 @@
|
||||
Fencing a failed master node with repmgrd and pgbouncer
|
||||
=======================================================
|
||||
|
||||
With automatic failover, it's essential to ensure that a failed master
|
||||
remains inaccessible to your application, even if it comes back online
|
||||
again, to avoid a split-brain situation.
|
||||
|
||||
By using `pgbouncer` together with `repmgrd`, it's possible to combine
|
||||
automatic failover with a process to isolate the failed master from
|
||||
your application and ensure that all connections which should go to
|
||||
the master are directed there smoothly without having to reconfigure
|
||||
your application. (Note that as a connection pooler, `pgbouncer` can
|
||||
benefit your application in other ways, but those are beyond the scope
|
||||
of this document).
|
||||
|
||||
* * *
|
||||
|
||||
> *WARNING*: automatic failover is tricky to get right. This document
|
||||
> demonstrates one possible implementation method, however you should
|
||||
> carefully configure and test any setup to suit the needs of your own
|
||||
> replication cluster/application.
|
||||
|
||||
* * *
|
||||
|
||||
In a failover situation, `repmgrd` promotes a standby to master by executing
|
||||
the command defined in `promote_command`. Normally this would be something like:
|
||||
|
||||
repmgr standby promote -f /etc/repmgr.conf
|
||||
|
||||
By wrapping this in a custom script which adjusts the `pgbouncer` configuration
|
||||
on all nodes, it's possible to fence the failed master and redirect write
|
||||
connections to the new master.
|
||||
|
||||
The script consists of three sections:
|
||||
|
||||
* commands to pause `pgbouncer` on all nodes
|
||||
* the promotion command itself
|
||||
* commands to reconfigure and restart `pgbouncer` on all nodes
|
||||
|
||||
Note that it requires password-less SSH access between all nodes to be able to
|
||||
update the `pgbouncer` configuration files.
|
||||
|
||||
For the purposes of this demonstration, we'll assume there are 3 nodes (master
|
||||
and two standbys), with `pgbouncer` listening on port 6432 handling connections
|
||||
to a database called `appdb`. The `postgres` system user must have write
|
||||
access to the `pgbouncer` configuration files on all nodes. We'll assume
|
||||
there's a main `pgbouncer` configuration file, `/etc/pgbouncer.ini`, which uses
|
||||
the `%include` directive (available from PgBouncer 1.6) to include a separate
|
||||
configuration file, `/etc/pgbouncer.database.ini`, which will be modified by
|
||||
`repmgr`.
|
||||
|
||||
`/etc/pgbouncer.ini` should look something like this:
|
||||
|
||||
[pgbouncer]
|
||||
|
||||
logfile = /var/log/pgbouncer/pgbouncer.log
|
||||
pidfile = /var/run/pgbouncer/pgbouncer.pid
|
||||
|
||||
listen_addr = *
|
||||
listen_port = 6532
|
||||
unix_socket_dir = /tmp
|
||||
|
||||
auth_type = trust
|
||||
auth_file = /etc/pgbouncer.auth
|
||||
|
||||
admin_users = postgres
|
||||
stats_users = postgres
|
||||
|
||||
pool_mode = transaction
|
||||
|
||||
max_client_conn = 100
|
||||
default_pool_size = 20
|
||||
min_pool_size = 5
|
||||
reserve_pool_size = 5
|
||||
reserve_pool_timeout = 3
|
||||
|
||||
log_connections = 1
|
||||
log_disconnections = 1
|
||||
log_pooler_errors = 1
|
||||
|
||||
%include /etc/pgbouncer.database.ini
|
||||
|
||||
The actual script is as follows; adjust the configurable items as appropriate:
|
||||
|
||||
`/var/lib/postgres/repmgr/promote.sh`
|
||||
|
||||
|
||||
#!/usr/bin/env bash
|
||||
set -u
|
||||
set -e
|
||||
|
||||
# Configurable items
|
||||
PGBOUNCER_HOSTS="node1 node2 node3"
|
||||
PGBOUNCER_DATABASE_INI="/etc/pgbouncer.database.ini"
|
||||
PGBOUNCER_DATABASE="appdb"
|
||||
PGBOUNCER_PORT=6432
|
||||
|
||||
REPMGR_DB="repmgr"
|
||||
REPMGR_USER="repmgr"
|
||||
REPMGR_SCHEMA="repmgr_test"
|
||||
|
||||
# 1. Pause running pgbouncer instances
|
||||
for HOST in $PGBOUNCER_HOSTS
|
||||
do
|
||||
psql -t -c "pause" -h $HOST -p $PGBOUNCER_PORT -U postgres pgbouncer
|
||||
done
|
||||
|
||||
# 2. Promote this node from standby to master
|
||||
|
||||
repmgr standby promote -f /etc/repmgr.conf
|
||||
|
||||
# 3. Reconfigure pgbouncer instances
|
||||
|
||||
PGBOUNCER_DATABASE_INI_NEW="/tmp/pgbouncer.database.ini"
|
||||
|
||||
for HOST in $PGBOUNCER_HOSTS
|
||||
do
|
||||
# Recreate the pgbouncer config file
|
||||
echo -e "[databases]\n" > $PGBOUNCER_DATABASE_INI_NEW
|
||||
|
||||
psql -d $REPMGR_DB -U $REPMGR_USER -t -A \
|
||||
-c "SELECT '${PGBOUNCER_DATABASE}-rw= ' || conninfo || ' application_name=pgbouncer_${HOST}' \
|
||||
FROM ${REPMGR_SCHEMA}.repl_nodes \
|
||||
WHERE active = TRUE AND type='master'" >> $PGBOUNCER_DATABASE_INI_NEW
|
||||
|
||||
psql -d $REPMGR_DB -U $REPMGR_USER -t -A \
|
||||
-c "SELECT '${PGBOUNCER_DATABASE}-ro= ' || conninfo || ' application_name=pgbouncer_${HOST}' \
|
||||
FROM $REPMGR_SCHEMA.repl_nodes \
|
||||
WHERE node_name='${HOST}'" >> $PGBOUNCER_DATABASE_INI_NEW
|
||||
|
||||
rsync $PGBOUNCER_DATABASE_INI_NEW $HOST:$PGBOUNCER_DATABASE_INI
|
||||
|
||||
psql -tc "reload" -h $HOST -p $PGBOUNCER_PORT -U postgres pgbouncer
|
||||
psql -tc "resume" -h $HOST -p $PGBOUNCER_PORT -U postgres pgbouncer
|
||||
|
||||
done
|
||||
|
||||
# Clean up generated file
|
||||
rm $PGBOUNCER_DATABASE_INI_NEW
|
||||
|
||||
echo "Reconfiguration of pgbouncer complete"
|
||||
|
||||
Script and template file should be installed on each node where
|
||||
`repmgrd` is running.
|
||||
|
||||
Finally, set `promote_command` in `repmgr.conf` on each node to
|
||||
point to the custom promote script:
|
||||
|
||||
promote_command=/var/lib/postgres/repmgr/promote.sh
|
||||
|
||||
and reload/restart any running `repmgrd` instances for the changes to take
|
||||
effect.
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* errcode.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -38,8 +38,5 @@
|
||||
#define ERR_MONITORING_FAIL 16
|
||||
#define ERR_BAD_BACKUP_LABEL 17
|
||||
#define ERR_SWITCHOVER_FAIL 18
|
||||
#define ERR_BARMAN 19
|
||||
#define ERR_REGISTRATION_SYNC 20
|
||||
|
||||
|
||||
#endif /* _ERRCODE_H_ */
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
/*
|
||||
* repmgr_function.sql
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
*
|
||||
*/
|
||||
-- SET SEARCH_PATH TO 'repmgr';
|
||||
CREATE FUNCTION repmgr_update_standby_location(text) RETURNS boolean
|
||||
AS '$libdir/repmgr_funcs', 'repmgr_update_standby_location'
|
||||
LANGUAGE C STRICT;
|
||||
CREATE FUNCTION repmgr_get_last_standby_location() RETURNS text
|
||||
AS '$libdir/repmgr_funcs', 'repmgr_get_last_standby_location'
|
||||
LANGUAGE C STRICT;
|
||||
CREATE FUNCTION repmgr_update_last_updated() RETURNS TIMESTAMP WITH TIME ZONE
|
||||
AS '$libdir/repmgr_funcs', 'repmgr_update_last_updated'
|
||||
LANGUAGE C STRICT;
|
||||
CREATE FUNCTION repmgr_get_last_updated() RETURNS TIMESTAMP WITH TIME ZONE
|
||||
AS '$libdir/repmgr_funcs', 'repmgr_get_last_updated'
|
||||
LANGUAGE C STRICT;
|
||||
@@ -1,24 +0,0 @@
|
||||
select * from repmgr_update_standby_location('');
|
||||
repmgr_update_standby_location
|
||||
--------------------------------
|
||||
f
|
||||
(1 row)
|
||||
|
||||
select * from repmgr_get_last_standby_location();
|
||||
repmgr_get_last_standby_location
|
||||
----------------------------------
|
||||
|
||||
(1 row)
|
||||
|
||||
select * from repmgr_update_last_updated();
|
||||
repmgr_update_last_updated
|
||||
----------------------------
|
||||
|
||||
(1 row)
|
||||
|
||||
select * from repmgr_get_last_updated();
|
||||
repmgr_get_last_updated
|
||||
-------------------------
|
||||
|
||||
(1 row)
|
||||
|
||||
62
log.c
62
log.c
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* log.c - Logging methods
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This module is a set of methods for logging (currently only syslog)
|
||||
*
|
||||
@@ -48,11 +48,6 @@ int log_level = LOG_NOTICE;
|
||||
int last_log_level = LOG_NOTICE;
|
||||
int verbose_logging = false;
|
||||
int terse_logging = false;
|
||||
/*
|
||||
* Global variable to be set by the main application to ensure any log output
|
||||
* emitted before logger_init is called, is output in the correct format
|
||||
*/
|
||||
int logger_output_mode = OM_DAEMON;
|
||||
|
||||
extern void
|
||||
stderr_log_with_level(const char *level_name, int level, const char *fmt, ...)
|
||||
@@ -67,31 +62,22 @@ stderr_log_with_level(const char *level_name, int level, const char *fmt, ...)
|
||||
static void
|
||||
_stderr_log_with_level(const char *level_name, int level, const char *fmt, va_list ap)
|
||||
{
|
||||
char buf[100];
|
||||
time_t t;
|
||||
struct tm *tm;
|
||||
char buff[100];
|
||||
|
||||
/*
|
||||
* Store the requested level so that if there's a subsequent
|
||||
* log_hint() or log_detail(), we can suppress that if appropriate.
|
||||
* log_hint(), we can suppress that if appropriate.
|
||||
*/
|
||||
last_log_level = level;
|
||||
|
||||
if (log_level >= level)
|
||||
{
|
||||
|
||||
/* Format log line prefix with timestamp if in daemon mode */
|
||||
if (logger_output_mode == OM_DAEMON)
|
||||
{
|
||||
time_t t;
|
||||
struct tm *tm;
|
||||
time(&t);
|
||||
tm = localtime(&t);
|
||||
strftime(buf, 100, "[%Y-%m-%d %H:%M:%S]", tm);
|
||||
fprintf(stderr, "%s [%s] ", buf, level_name);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "%s: ", level_name);
|
||||
}
|
||||
time(&t);
|
||||
tm = localtime(&t);
|
||||
strftime(buff, 100, "[%Y-%m-%d %H:%M:%S]", tm);
|
||||
fprintf(stderr, "%s [%s] ", buff, level_name);
|
||||
|
||||
vfprintf(stderr, fmt, ap);
|
||||
|
||||
@@ -113,20 +99,6 @@ log_hint(const char *fmt, ...)
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
log_detail(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
if (terse_logging == false)
|
||||
{
|
||||
va_start(ap, fmt);
|
||||
_stderr_log_with_level("DETAIL", last_log_level, fmt, ap);
|
||||
va_end(ap);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
log_verbose(int level, const char *fmt, ...)
|
||||
{
|
||||
@@ -170,7 +142,7 @@ log_verbose(int level, const char *fmt, ...)
|
||||
|
||||
|
||||
bool
|
||||
logger_init(t_configuration_options *opts, const char *ident)
|
||||
logger_init(t_configuration_options * opts, const char *ident)
|
||||
{
|
||||
char *level = opts->loglevel;
|
||||
char *facility = opts->logfacility;
|
||||
@@ -204,13 +176,6 @@ logger_init(t_configuration_options *opts, const char *ident)
|
||||
stderr_log_warning(_("Invalid log level \"%s\" (available values: DEBUG, INFO, NOTICE, WARNING, ERR, ALERT, CRIT or EMERG)\n"), level);
|
||||
}
|
||||
|
||||
/*
|
||||
* STDERR only logging requested - finish here without setting up any further
|
||||
* logging facility.
|
||||
*/
|
||||
if (logger_output_mode == OM_COMMAND_LINE)
|
||||
return true;
|
||||
|
||||
if (facility && *facility)
|
||||
{
|
||||
|
||||
@@ -271,10 +236,9 @@ logger_init(t_configuration_options *opts, const char *ident)
|
||||
stderr_log_notice(_("Redirecting logging output to '%s'\n"), opts->logfile);
|
||||
fd = freopen(opts->logfile, "a", stderr);
|
||||
|
||||
/*
|
||||
* It's possible freopen() may still fail due to e.g. a race condition;
|
||||
* as it's not feasible to restore stderr after a failed freopen(),
|
||||
* we'll write to stdout as a last resort.
|
||||
/* It's possible freopen() may still fail due to e.g. a race condition;
|
||||
as it's not feasible to restore stderr after a failed freopen(),
|
||||
we'll write to stdout as a last resort.
|
||||
*/
|
||||
if (fd == NULL)
|
||||
{
|
||||
|
||||
12
log.h
12
log.h
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* log.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -25,9 +25,6 @@
|
||||
#define REPMGR_SYSLOG 1
|
||||
#define REPMGR_STDERR 2
|
||||
|
||||
#define OM_COMMAND_LINE 1
|
||||
#define OM_DAEMON 2
|
||||
|
||||
extern void
|
||||
stderr_log_with_level(const char *level_name, int level, const char *fmt,...)
|
||||
__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 4)));
|
||||
@@ -126,8 +123,6 @@ bool logger_shutdown(void);
|
||||
void logger_set_verbose(void);
|
||||
void logger_set_terse(void);
|
||||
|
||||
void log_detail(const char *fmt, ...)
|
||||
__attribute__((format(PG_PRINTF_ATTRIBUTE, 1, 2)));
|
||||
void log_hint(const char *fmt, ...)
|
||||
__attribute__((format(PG_PRINTF_ATTRIBUTE, 1, 2)));
|
||||
void log_verbose(int level, const char *fmt, ...)
|
||||
@@ -135,8 +130,5 @@ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
|
||||
|
||||
extern int log_type;
|
||||
extern int log_level;
|
||||
extern int verbose_logging;
|
||||
extern int terse_logging;
|
||||
extern int logger_output_mode;
|
||||
|
||||
#endif /* _REPMGR_LOG_H_ */
|
||||
#endif
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
#
|
||||
# https://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING
|
||||
#
|
||||
#conninfo='host=192.168.204.104 dbname=repmgr user=repmgr'
|
||||
#conninfo='host=192.168.204.104 dbname=repmgr_db user=repmgr_usr'
|
||||
#
|
||||
# If repmgrd is in use, consider explicitly setting `connect_timeout` in the
|
||||
# conninfo string to determine the length of time which elapses before
|
||||
@@ -66,12 +66,6 @@
|
||||
# (default: NOTICE)
|
||||
#loglevel=NOTICE
|
||||
|
||||
# Note that logging facility settings will only apply to `repmgrd` by default;
|
||||
# `repmgr` will always write to STDERR unless the switch `--log-to-file` is
|
||||
# supplied, in which case it will log to the same destination as `repmgrd`.
|
||||
# This is mainly intended for those cases when `repmgr` is executed directly
|
||||
# by `repmgrd`.
|
||||
|
||||
# Logging facility: possible values are STDERR or - for Syslog integration - one of LOCAL0, LOCAL1, ..., LOCAL7, USER
|
||||
# (default: STDERR)
|
||||
#logfacility=STDERR
|
||||
@@ -106,34 +100,6 @@
|
||||
# path to PostgreSQL binary directory (location of pg_ctl, pg_basebackup etc.)
|
||||
# (if not provided, defaults to system $PATH)
|
||||
#pg_bindir=/usr/bin/
|
||||
#
|
||||
# Debian/Ubuntu users: you will probably need to set this to the directory
|
||||
# where `pg_ctl` is located, e.g. /usr/lib/postgresql/9.5/bin/
|
||||
|
||||
# service control commands
|
||||
#
|
||||
# repmgr provides options to override the default pg_ctl commands
|
||||
# used to stop, start, restart, reload and promote the PostgreSQL cluster
|
||||
#
|
||||
# NOTE: These commands must be runnable on remote nodes as well for switchover
|
||||
# to function correctly.
|
||||
#
|
||||
# If you use sudo, the user repmgr runs as (usually 'postgres') must have
|
||||
# passwordless sudo access to execute the command
|
||||
#
|
||||
# For example, to use systemd, you may use the following configuration:
|
||||
#
|
||||
# # this is required when running sudo over ssh without -t:
|
||||
# Defaults:postgres !requiretty
|
||||
# postgres ALL = NOPASSWD: /usr/bin/systemctl stop postgresql-9.5, \
|
||||
# /usr/bin/systemctl start postgresql-9.5, \
|
||||
# /usr/bin/systemctl restart postgresql-9.5
|
||||
#
|
||||
# service_start_command = systemctl start postgresql-9.5
|
||||
# service_stop_command = systemctl stop postgresql-9.5
|
||||
# service_restart_command = systemctl restart postgresql-9.5
|
||||
# service_reload_command = pg_ctlcluster 9.5 main reload
|
||||
# service_promote_command = pg_ctlcluster 9.5 main promote
|
||||
|
||||
# external command options
|
||||
|
||||
@@ -143,15 +109,8 @@
|
||||
# external command arguments. Values shown are examples.
|
||||
|
||||
#pg_ctl_options='-s'
|
||||
#pg_basebackup_options='--label=repmgr_backup'
|
||||
#pg_basebackup_options='--xlog-method=s'
|
||||
|
||||
# This is the host name of the barman server, which is used for connecting over
|
||||
# to the barman server (passwordless ssh keys should be in place)
|
||||
#barman_server='backup_server'
|
||||
# If you are placing the barman.conf file in a non-standard path, or using
|
||||
# a name other than barman.conf, use this parameter to specify the path and
|
||||
# name of the barman configuration file.
|
||||
#barman_config='/path/to/barman.conf'
|
||||
|
||||
# Standby clone settings
|
||||
# ----------------------
|
||||
@@ -173,11 +132,9 @@
|
||||
# These settings are only applied when repmgrd is running. Values shown
|
||||
# are defaults.
|
||||
|
||||
# monitoring interval in seconds; default is 2
|
||||
#monitor_interval_secs=2
|
||||
# Number of seconds to wait for a response from the primary server before
|
||||
# deciding it has failed.
|
||||
|
||||
# Maximum number of seconds to wait for a response from the primary server
|
||||
# before deciding it has failed.
|
||||
#master_response_timeout=60
|
||||
|
||||
# Number of attempts at what interval (in seconds) to try and
|
||||
@@ -187,21 +144,16 @@
|
||||
#reconnect_interval=10
|
||||
|
||||
# Autofailover options
|
||||
#failover=manual # one of 'automatic', 'manual' (default: manual)
|
||||
# defines the action to take in the event of upstream failure
|
||||
#
|
||||
# 'automatic': repmgrd will automatically attempt to promote the
|
||||
# node or follow the new upstream node
|
||||
# 'manual': repmgrd will take no action and the mode will require
|
||||
# manual attention to reattach it to replication
|
||||
|
||||
#priority=100 # indicate a preferred priorty for promoting nodes
|
||||
# a value of zero or less prevents the node being promoted to primary
|
||||
#failover=manual # one of 'automatic', 'manual'
|
||||
# (default: manual)
|
||||
#priority=100 # a value of zero or less prevents the node being promoted to primary
|
||||
# (default: 100)
|
||||
|
||||
#promote_command='repmgr standby promote -f /path/to/repmgr.conf'
|
||||
#follow_command='repmgr standby follow -f /path/to/repmgr.conf -W'
|
||||
|
||||
# monitoring interval in seconds; default is 2
|
||||
#monitor_interval_secs=2
|
||||
|
||||
# change wait time for primary; before we bail out and exit when the primary
|
||||
# disappears, we wait 'reconnect_attempts' * 'retry_promote_interval_secs'
|
||||
# seconds; by default this would be half an hour, as 'retry_promote_interval_secs'
|
||||
|
||||
197
repmgr.h
197
repmgr.h
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* repmgr.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -23,7 +23,6 @@
|
||||
#include <libpq-fe.h>
|
||||
#include <postgres_fe.h>
|
||||
#include <getopt_long.h>
|
||||
#include "pqexpbuffer.h"
|
||||
|
||||
#include "strutil.h"
|
||||
#include "dbutils.h"
|
||||
@@ -36,7 +35,7 @@
|
||||
|
||||
#define ERRBUFF_SIZE 512
|
||||
|
||||
#define DEFAULT_WAL_KEEP_SEGMENTS "0"
|
||||
#define DEFAULT_WAL_KEEP_SEGMENTS "5000"
|
||||
#define DEFAULT_DEST_DIR "."
|
||||
#define DEFAULT_REPMGR_SCHEMA_PREFIX "repmgr_"
|
||||
#define DEFAULT_PRIORITY 100
|
||||
@@ -48,132 +47,56 @@
|
||||
#define NO_UPSTREAM_NODE -1
|
||||
#define UNKNOWN_NODE_ID -1
|
||||
|
||||
/* command line options without short versions */
|
||||
#define OPT_HELP 1
|
||||
#define OPT_CHECK_UPSTREAM_CONFIG 2
|
||||
#define OPT_RECOVERY_MIN_APPLY_DELAY 3
|
||||
#define OPT_COPY_EXTERNAL_CONFIG_FILES 4
|
||||
#define OPT_CONFIG_ARCHIVE_DIR 5
|
||||
#define OPT_PG_REWIND 6
|
||||
#define OPT_CSV 8
|
||||
#define OPT_NODE 9
|
||||
#define OPT_WITHOUT_BARMAN 10
|
||||
#define OPT_NO_UPSTREAM_CONNECTION 11
|
||||
#define OPT_REGISTER_WAIT 12
|
||||
#define OPT_CLUSTER 13
|
||||
#define OPT_LOG_TO_FILE 14
|
||||
#define OPT_UPSTREAM_CONNINFO 15
|
||||
#define OPT_NO_CONNINFO_PASSWORD 16
|
||||
#define OPT_REPLICATION_USER 17
|
||||
|
||||
/* deprecated command line options */
|
||||
#define OPT_INITDB_NO_PWPROMPT 998
|
||||
#define OPT_IGNORE_EXTERNAL_CONFIG_FILES 999
|
||||
|
||||
/* values for --copy-external-config-files */
|
||||
#define CONFIG_FILE_SAMEPATH 1
|
||||
#define CONFIG_FILE_PGDATA 2
|
||||
|
||||
|
||||
/* Run time options type */
|
||||
typedef struct
|
||||
{
|
||||
/* general repmgr options */
|
||||
char config_file[MAXPGPATH];
|
||||
bool verbose;
|
||||
bool terse;
|
||||
bool force;
|
||||
char pg_bindir[MAXLEN]; /* overrides setting in repmgr.conf */
|
||||
|
||||
/* logging parameters */
|
||||
char loglevel[MAXLEN]; /* overrides setting in repmgr.conf */
|
||||
bool log_to_file;
|
||||
|
||||
/* connection parameters */
|
||||
char dbname[MAXLEN];
|
||||
char host[MAXLEN];
|
||||
char username[MAXLEN];
|
||||
char dest_dir[MAXPGPATH];
|
||||
char config_file[MAXPGPATH];
|
||||
char remote_user[MAXLEN];
|
||||
char superuser[MAXLEN];
|
||||
char masterport[MAXLEN];
|
||||
bool conninfo_provided;
|
||||
bool connection_param_provided;
|
||||
bool host_param_provided;
|
||||
|
||||
/* standby clone parameters */
|
||||
bool wal_keep_segments_used;
|
||||
char wal_keep_segments[MAXLEN];
|
||||
bool verbose;
|
||||
bool terse;
|
||||
bool force;
|
||||
bool wait_for_master;
|
||||
bool ignore_rsync_warn;
|
||||
bool witness_pwprompt;
|
||||
bool rsync_only;
|
||||
bool fast_checkpoint;
|
||||
bool without_barman;
|
||||
bool no_upstream_connection;
|
||||
bool no_conninfo_password;
|
||||
bool copy_external_config_files;
|
||||
int copy_external_config_files_destination;
|
||||
char upstream_conninfo[MAXLEN];
|
||||
char replication_user[MAXLEN];
|
||||
bool ignore_external_config_files;
|
||||
bool csv_mode;
|
||||
char masterport[MAXLEN];
|
||||
/*
|
||||
* configuration file parameters which can be overridden on the
|
||||
* command line
|
||||
*/
|
||||
char loglevel[MAXLEN];
|
||||
|
||||
/* parameter used by STANDBY SWITCHOVER */
|
||||
char remote_config_file[MAXLEN];
|
||||
char pg_rewind[MAXPGPATH];
|
||||
char pg_ctl_mode[MAXLEN];
|
||||
/* parameter used by STANDBY {ARCHIVE_CONFIG | RESTORE_CONFIG} */
|
||||
char config_archive_dir[MAXLEN];
|
||||
/* parameter used by CLUSTER CLEANUP */
|
||||
int keep_history;
|
||||
|
||||
char pg_bindir[MAXLEN];
|
||||
|
||||
char recovery_min_apply_delay[MAXLEN];
|
||||
|
||||
/* standby register parameters */
|
||||
bool wait_register_sync;
|
||||
int wait_register_sync_seconds;
|
||||
|
||||
/* witness create parameters */
|
||||
bool witness_pwprompt;
|
||||
|
||||
/* standby follow parameters */
|
||||
bool wait_for_master;
|
||||
|
||||
/* cluster {show|matrix|crosscheck} parameters */
|
||||
bool csv_mode;
|
||||
|
||||
/* cluster cleanup parameters */
|
||||
int keep_history;
|
||||
|
||||
/* standby switchover parameters */
|
||||
char remote_config_file[MAXLEN];
|
||||
bool pg_rewind_supplied;
|
||||
char pg_rewind[MAXPGPATH];
|
||||
char pg_ctl_mode[MAXLEN];
|
||||
|
||||
/* standby {archive_config | restore_config} parameters */
|
||||
char config_archive_dir[MAXLEN];
|
||||
|
||||
/* {standby|witness} unregister parameters */
|
||||
int node;
|
||||
|
||||
/* deprecated command line options */
|
||||
char localport[MAXLEN];
|
||||
bool initdb_no_pwprompt;
|
||||
} t_runtime_options;
|
||||
|
||||
#define T_RUNTIME_OPTIONS_INITIALIZER { \
|
||||
/* general repmgr options */ \
|
||||
"", false, false, false, "", \
|
||||
/* logging parameters */ \
|
||||
"", false, \
|
||||
/* connection parameters */ \
|
||||
"", "", "", "", "", "", "", \
|
||||
false, false, false, \
|
||||
/* standby clone parameters */ \
|
||||
false, DEFAULT_WAL_KEEP_SEGMENTS, false, false, false, false, false, false, \
|
||||
false, CONFIG_FILE_SAMEPATH, "", "", "", \
|
||||
/* standby register paarameters */ \
|
||||
false, 0, \
|
||||
/* witness create parameters */ \
|
||||
false, \
|
||||
/* standby follow parameters */ \
|
||||
false, \
|
||||
/* cluster {show|matrix|crosscheck} parameters */ \
|
||||
false, \
|
||||
/* cluster cleanup parameters */ \
|
||||
0, \
|
||||
/* standby switchover parameters */ \
|
||||
"", false, "", "fast", \
|
||||
/* standby {archive_config | restore_config} parameters */ \
|
||||
"", \
|
||||
/* {standby|witness} unregister parameters */ \
|
||||
UNKNOWN_NODE_ID }
|
||||
#define T_RUNTIME_OPTIONS_INITIALIZER { "", "", "", "", "", "", "", DEFAULT_WAL_KEEP_SEGMENTS, false, false, false, false, false, false, false, false, false, false, "", "", "", "", "fast", "", 0, "", "", "", false }
|
||||
|
||||
struct BackupLabel
|
||||
{
|
||||
@@ -187,61 +110,7 @@ struct BackupLabel
|
||||
XLogRecPtr min_failover_slot_lsn;
|
||||
};
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char slot[MAXLEN];
|
||||
char xlog_method[MAXLEN];
|
||||
bool no_slot; /* from PostgreSQL 10 */
|
||||
} t_basebackup_options;
|
||||
|
||||
#define T_BASEBACKUP_OPTIONS_INITIALIZER { "", "", false }
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int size;
|
||||
char **keywords;
|
||||
char **values;
|
||||
} t_conninfo_param_list;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char filepath[MAXPGPATH];
|
||||
char filename[MAXPGPATH];
|
||||
bool in_data_directory;
|
||||
} t_configfile_info;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int size;
|
||||
int entries;
|
||||
t_configfile_info **files;
|
||||
} t_configfile_list;
|
||||
|
||||
#define T_CONFIGFILE_LIST_INITIALIZER { 0, 0, NULL }
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int node_id;
|
||||
int node_status;
|
||||
} t_node_status_rec;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int node_id;
|
||||
char node_name[MAXLEN];
|
||||
t_node_status_rec **node_status_list;
|
||||
} t_node_matrix_rec;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int node_id;
|
||||
char node_name[MAXLEN];
|
||||
t_node_matrix_rec **matrix_list_rec;
|
||||
} t_node_status_cube;
|
||||
|
||||
|
||||
extern char repmgr_schema[MAXLEN];
|
||||
extern bool config_file_found;
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/*
|
||||
* repmgr.sql
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
*/
|
||||
|
||||
@@ -64,7 +64,7 @@ CREATE INDEX idx_repl_status_sort ON repl_monitor(last_monitor_time, standby_nod
|
||||
* This view shows the list of nodes with the information of which one is the upstream
|
||||
* in each case (when appliable)
|
||||
*/
|
||||
CREATE VIEW repl_show_nodes AS
|
||||
CREATE VIEW repl_show_nodes AS
|
||||
SELECT rn.id, rn.conninfo, rn.type, rn.name, rn.cluster,
|
||||
rn.priority, rn.active, sq.name AS upstream_node_name
|
||||
FROM repl_nodes as rn LEFT JOIN repl_nodes AS sq ON sq.id=rn.upstream_node_id;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
# Makefile
|
||||
#
|
||||
# Copyright (c) 2ndQuadrant, 2010-2017
|
||||
# Copyright (c) 2ndQuadrant, 2010-2016
|
||||
#
|
||||
|
||||
MODULE_big = repmgr_funcs
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* repmgr_function.sql
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
select * from repmgr_update_standby_location('');
|
||||
select * from repmgr_get_last_standby_location();
|
||||
select * from repmgr_update_last_updated();
|
||||
select * from repmgr_get_last_updated();
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* uninstall_repmgr_funcs.sql
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (c) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
20
strutil.c
20
strutil.c
@@ -1,7 +1,7 @@
|
||||
/*
|
||||
* strutil.c
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
@@ -87,21 +87,3 @@ maxlen_snprintf(char *str, const char *format,...)
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Escape a string for use as a parameter in recovery.conf
|
||||
* Caller must free returned value
|
||||
*/
|
||||
char *
|
||||
escape_recovery_conf_value(const char *src)
|
||||
{
|
||||
char *result = escape_single_quotes_ascii(src);
|
||||
|
||||
if (!result)
|
||||
{
|
||||
fprintf(stderr, _("%s: out of memory\n"), progname());
|
||||
exit(ERR_INTERNAL);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* strutil.h
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
@@ -22,7 +22,6 @@
|
||||
#define _STRUTIL_H_
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "pqexpbuffer.h"
|
||||
#include "errcode.h"
|
||||
|
||||
|
||||
@@ -49,6 +48,4 @@ extern int
|
||||
maxlen_snprintf(char *str, const char *format,...)
|
||||
__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
|
||||
|
||||
extern char *
|
||||
escape_recovery_conf_value(const char *src);
|
||||
#endif /* _STRUTIL_H_ */
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/*
|
||||
* uninstall_repmgr.sql
|
||||
*
|
||||
* Copyright (c) 2ndQuadrant, 2010-2017
|
||||
* Copyright (C) 2ndQuadrant, 2010-2016
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
Reference in New Issue
Block a user