su - postgres

createuser -s repmgr

createdb -O repmgr repmgr

Restart the PostgreSQL server::

Clone node1 (the current Master)::

su - postgres

Start the PostgreSQL server::

Log in to node1.

su - postgres

repmgr -f /etc/repmgr/repmgr.conf master register

Log in to node2. Register it as a standby::

su - postgres

replication slots, setting a higher figure will make adding new nodes

easier.

`repmgr`

--------

is intended to support running the witness server as a separate

instance on a normal node server, rather than on its own dedicated server.

- Do I need to include `shared_preload_libraries = 'repmgr_funcs'`

in `postgresql.conf` if I'm not using `repmgrd`?

If you later decide to run `repmgrd`, you just need to add

`shared_preload_libraries = 'repmgr_funcs'` and restart PostgreSQL.

`repmgrd`

---------

Note that after registering a delayed standby, `repmgrd` will only start

once the metadata added in the master node has been replicated.

Improve handling of --help/--version options; and improve help output (Ian)

Improve handling of situation where logfile can't be opened (Ian)

Always pass -D/--pgdata option to pg_basebackup (Ian)

Update tablespace remapping in --rsync-only mode for 9.5 and later (Ian)

Deprecate `-l/--local-port` option - the port can be extracted

from the conninfo string in repmgr.conf (Ian)

3.0.1 2015-04-16

Prevent repmgrd from looping infinitely if node was not registered (Ian)

replication slots and cascading replication, doesn't require a restart

after promotion, and has many usability improvements.

For a list of changes since `repmgr 2` and instructions on upgrading to

`repmgr 3`, see the "Upgrading from repmgr 2" section below.

Overview

--------

# How much WAL to retain on the primary to allow a temporarily

# disconnected standby to catch up again. The larger this is, the

# longer the standby can be disconnected. This is needed only in

wal_keep_segments = 5000

createuser -s repmgr

createdb repmgr -O repmgr

### repmgr configuration

[2015-03-11 13:15:40] [INFO] reloading configuration file and updating repmgr tables

[2015-03-11 13:15:40] [INFO] starting continuous standby node monitoring

Witness server

--------------

standby_promote

witness_create

repmgrd_start

repmgrd_failover_promote

repmgrd_failover_follow

`repmgr` or `repmgrd` will return one of the following error codes on program

exit:

Support and Assistance

----------------------

* PGPASSFILE may not be passed to pg_basebackup

Planned feature improvements

============================

* Have pg_basebackup use replication slots, if and when support for

this is added; see:

http://www.postgresql.org/message-id/[email protected]

}

else if (pg_dir && !force)

{

return false;

}

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 char config_file_path[MAXPGPATH];

static bool config_file_provided = false;

/*

* load_config()

*

* Any configuration options changed in this function must also be changed in

* reload_config()

*/

bool

{

/*

* If a configuration file was provided, check it exists, otherwise

*/

if (config_file[0])

{

strncpy(config_file_path, config_file, MAXPGPATH);

canonicalize_path(config_file_path);

{

config_file,

strerror(errno)

);

exit(ERR_BAD_CONFIG);

}

config_file_provided = true;

}

/*

* If no configuration file was provided, attempt to find a default file

*/

if (config_file_provided == false)

{

char my_exec_path[MAXPGPATH];

if (find_my_exec(argv0, my_exec_path) < 0)

{

fprintf(stderr, _("%s: could not find own program executable\n"), argv0);

exit(EXIT_FAILURE);

}

{

}

}

}

bool

parse_config(t_configuration_options *options)

{

FILE *fp;

char *s,

char name[MAXLEN];

char value[MAXLEN];

PQconninfoOption *conninfo_options;

char *conninfo_errmsg = NULL;

*/

memset(options->cluster_name, 0, sizeof(options->cluster_name));

options->node = -1;

options->upstream_node = NO_UPSTREAM_NODE;

memset(options->conninfo, 0, sizeof(options->conninfo));

options->failover = MANUAL_FAILOVER;

options->priority = DEFAULT_PRIORITY;

/* default to 6 reconnection attempts at intervals of 10 seconds */

options->reconnect_attempts = 6;

options->monitor_interval_secs = 2;

options->retry_promote_interval_secs = 300;

options->tablespace_mapping.head = NULL;

options->tablespace_mapping.tail = NULL;

{

bool known_parameter = true;

/* Parse name/value pair from line */

/* Skip blank lines */

if (!strlen(name))

if (strcmp(name, "cluster") == 0)

strncpy(options->cluster_name, value, MAXLEN);

else if (strcmp(name, "node") == 0)

else if (strcmp(name, "upstream_node") == 0)

else if (strcmp(name, "conninfo") == 0)

strncpy(options->conninfo, value, MAXLEN);

else if (strcmp(name, "rsync_options") == 0)

}

else

{

}

}

else if (strcmp(name, "priority") == 0)

else if (strcmp(name, "node_name") == 0)

strncpy(options->node_name, value, MAXLEN);

else if (strcmp(name, "promote_command") == 0)

else if (strcmp(name, "follow_command") == 0)

strncpy(options->follow_command, value, MAXLEN);

else if (strcmp(name, "master_response_timeout") == 0)

else if (strcmp(name, "reconnect_attempts") == 0)

else if (strcmp(name, "reconnect_interval") == 0)

else if (strcmp(name, "pg_bindir") == 0)

strncpy(options->pg_bindir, value, MAXLEN);

else if (strcmp(name, "pg_ctl_options") == 0)

else if (strcmp(name, "logfile") == 0)

strncpy(options->logfile, value, MAXLEN);

else if (strcmp(name, "monitor_interval_secs") == 0)

else if (strcmp(name, "retry_promote_interval_secs") == 0)

else if (strcmp(name, "use_replication_slots") == 0)

else if (strcmp(name, "event_notification_command") == 0)

strncpy(options->event_notification_command, value, MAXLEN);

else if (strcmp(name, "event_notifications") == 0)

* as currently e.g. an empty `node` value will be converted to '0'.

*/

if (known_parameter == true && !strlen(value)) {

}

}

/* The following checks are for the presence of the parameter */

if (*options->cluster_name == '\0')

{

}

if (options->node == -1)

{

}

if (*options->node_name == '\0')

{

}

if (*options->conninfo == '\0')

{

}

{

}

{

}

return true;

}

void

{

int i = 0;

int j = 0;

for (; i < MAXLEN; ++i)

{

break;

{

/* Ignore whitespace */

case ' ':

case '\t':

continue;

default:

}

}

name[j] = '\0';

*/

for (; i < MAXLEN; ++i)

{

continue;

continue;

break;

*/

j = 0;

for (++i; i < MAXLEN; ++i)

continue;

break;

else

break;

value[j] = '\0';

return false;

}

{

log_warning(_("new value for 'reconnect_interval' must be zero or greater\n"));

return false;

config_changed = true;

}

{

config_changed = true;

}

}

/*

* Split argument into old_dir and new_dir and append to tablespace mapping

}

}

}

#include "strutil.h"

typedef struct EventNotificationListCell

{

char ssh_options[QUERY_STR_LEN];

int master_response_timeout;

int reconnect_attempts;

char pg_bindir[MAXLEN];

char pg_ctl_options[MAXLEN];

char pg_basebackup_options[MAXLEN];

#define T_CONFIGURATION_OPTIONS_INITIALIZER { "", -1, NO_UPSTREAM_NODE, "", MANUAL_FAILOVER, -1, "", "", "", "", "", "", "", -1, -1, -1, "", "", "", "", 0, 0, 0, "", { NULL, NULL }, {NULL, NULL} }

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);

#endif

{

PGresult *res;

res = PQexec(conn, "BEGIN");

if (PQresultStatus(res) != PGRES_COMMAND_OK)

{

PGresult *res;

res = PQexec(conn, "COMMIT");

if (PQresultStatus(res) != PGRES_COMMAND_OK)

{

PGresult *res;

res = PQexec(conn, "ROLLBACK");

if (PQresultStatus(res) != PGRES_COMMAND_OK)

"SELECT 1 FROM pg_namespace WHERE nspname = '%s'",

get_repmgr_schema());

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

{

PGresult *res;

int result = 0;

if (res == NULL || PQresultStatus(res) != PGRES_TUPLES_OK)

{

PQerrorMessage(conn));

result = -1;

}

else if (PQntuples(res) == 1 && strcmp(PQgetvalue(res, 0, 0), "t") == 0)

result = 1;

PQclear(res);

return result;

get_repmgr_schema_quoted(conn),

cluster);

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

char sqlquery[QUERY_STR_LEN];

int retval = 1;

" WHERE name = '%s' AND setting %s '%s'",

parameter, op, value);

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

PQerrorMessage(conn));

retval = -1;

}

" WHERE name = '%s' AND setting::%s %s '%s'::%s",

parameter, datatype, op, value, datatype);

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

PQerrorMessage(conn));

retval = -1;

}

PGresult *res;

char sqlquery[QUERY_STR_LEN];

" FROM pg_database ");

res = PQexec(conn, sqlquery);

if (res == NULL || PQresultStatus(res) != PGRES_TUPLES_OK)

{

PQerrorMessage(conn));

PQclear(res);

" FROM pg_settings WHERE name = '%s'",

setting);

res = PQexec(conn, sqlquery);

}

else

{

}

}

if (success == true)

{

}

PQclear(res);

cluster,

node_id);

res = PQexec(standby_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

PQerrorMessage(standby_conn));

PQclear(res);

return NULL;

PQclear(res);

upstream_conn = establish_db_connection(upstream_conninfo, false);

if (PQstatus(upstream_conn) != CONNECTION_OK)

/*

*

*/

PGconn *

get_master_connection(PGconn *standby_conn, char *cluster,

int *master_id, char *master_conninfo_out)

{

char sqlquery[QUERY_STR_LEN];

int i,

node_id;

}

/* find all nodes belonging to this cluster */

cluster);

sqlquery_snprintf(sqlquery,

get_repmgr_schema_quoted(standby_conn),

cluster);

{

log_err(_("unable to retrieve node records: %s\n"),

PQerrorMessage(standby_conn));

return NULL;

}

{

continue;

{

continue;

}

{

log_debug(_("get_master_connection(): current master node is %i\n"), node_id);

if (master_id != NULL)

*master_id = node_id;

}

}

}

/*

* Probably we will need to check the error to know if we need to start

* failover procedure or just fix some situation on the standby.

*/

return NULL;

}

{

if (PQconsumeInput(conn) == 0)

{

PQerrorMessage(conn));

return 0;

}

if (select(sock, &read_set, NULL, NULL, &tmout) == -1)

{

log_warning(

strerror(errno));

return -1;

}

return 1;

}

return -1;

}

return true;

}

char *

get_repmgr_schema(void)

{

" WHERE slot_name = '%s' ",

slot_name);

res = PQexec(conn, sqlquery);

if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)

{

if (strcmp(PQgetvalue(res, 0, 0), "f") == 0)

{

PQclear(res);

return true;

}

slot_name);

log_debug(_("create_replication_slot(): Creating slot '%s' on primary\n"), slot_name);

res = PQexec(conn, sqlquery);

if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)

return true;

}

bool

start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint)

PGresult *res;

sqlquery_snprintf(sqlquery,

time(NULL),

fast_checkpoint ? "TRUE" : "FALSE");

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

char *first_wal_seg_pq = PQgetvalue(res, 0, 0);

size_t buf_sz = strlen(first_wal_seg_pq);

xsnprintf(first_wal_segment, buf_sz + 1, "%s", first_wal_seg_pq);

}

char sqlquery[QUERY_STR_LEN];

PGresult *res;

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

char *last_wal_seg_pq = PQgetvalue(res, 0, 0);

size_t buf_sz = strlen(last_wal_seg_pq);

xsnprintf(last_wal_segment, buf_sz + 1, "%s", last_wal_seg_pq);

}

config_param,

state ? "TRUE" : "FALSE");

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_COMMAND_OK)

int i;

sqlquery_snprintf(sqlquery, "TRUNCATE TABLE %s.repl_nodes", get_repmgr_schema_quoted(witnessconn));

res = PQexec(witnessconn, sqlquery);

if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)

{

PQerrorMessage(witnessconn));

return false;

}

sqlquery_snprintf(sqlquery,

"SELECT id, type, upstream_node_id, name, conninfo, priority, slot_name FROM %s.repl_nodes",

get_repmgr_schema_quoted(masterconn));

res = PQexec(masterconn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

PQerrorMessage(masterconn));

PQclear(res);

return false;

for (i = 0; i < PQntuples(res); i++)

{

bool node_record_created;

node_record_created = create_node_record(witnessconn,

"copy_configuration",

if (node_record_created == false)

{

PQerrorMessage(witnessconn));

return false;

}

maxlen_snprintf(slot_name_buf, "%s", "NULL");

}

sqlquery_snprintf(sqlquery,

"INSERT INTO %s.repl_nodes "

" (id, type, upstream_node_id, cluster, "

slot_name_buf,

priority);

if (action != NULL)

{

}

res = PQexec(conn, sqlquery);

if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)

{

PQclear(res);

return false;

}

" WHERE id = %d",

get_repmgr_schema_quoted(conn),

node);

if (action != NULL)

{

}

res = PQexec(conn, sqlquery);

if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)

{

PQerrorMessage(conn));

PQclear(res);

return false;

" RETURNING event_timestamp ",

get_repmgr_schema_quoted(conn));

res = PQexecParams(conn,

sqlquery,

4,

if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)

{

log_warning(_("Unable to create event record: %s\n"),

PQerrorMessage(conn));

{

/* Store timestamp to send to the notification command */

strncpy(event_timestamp, PQgetvalue(res, 0, 0), MAXLEN);

}

PQclear(res);

*dst_ptr = '\0';

r = system(parsed_command);

if (r != 0)

{

log_warning(_("Unable to execute event notification command\n"));

success = false;

}

}

return success;

}

bool

update_node_record_set_upstream(PGconn *conn, char *cluster_name, int this_node_id, int new_upstream_node_id)

{

new_upstream_node_id,

cluster_name,

this_node_id);

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_COMMAND_OK)

cluster,

node_id);

return PQexec(conn, sqlquery);

}

#ifndef _REPMGR_DBUTILS_H_

#define _REPMGR_DBUTILS_H_

#include "config.h"

#include "strutil.h"

PGconn *establish_db_connection(const char *conninfo,

const bool exit_on_error);

char *get_repmgr_schema(void);

char *get_repmgr_schema_quoted(PGconn *conn);

bool create_replication_slot(PGconn *conn, char *slot_name);

bool start_backup(PGconn *conn, char *first_wal_segment, bool fast_checkpoint);

bool stop_backup(PGconn *conn, char *last_wal_segment);

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 delete_node_record(PGconn *conn, int node, char *action);

bool create_event_record(PGconn *conn, t_configuration_options *options, int node_id, char *event, bool successful, char *details);

bool update_node_record_set_upstream(PGconn *conn, char *cluster_name, int this_node_id, int new_upstream_node_id);

PGresult * get_node_record(PGconn *conn, char *cluster, int node_id);

repmgr (3.0.2-2~bpo70+1) wheezy-backports-sloppy; urgency=low

* Rebuild for wheezy-backports-sloppy to get PostgreSQL 9.4 support.

Package: repmgr

Architecture: all

Depends:

postgresql-9.4-repmgr |

postgresql-9.3-repmgr |

postgresql-9.2-repmgr |

Section: debug

Architecture: all

Depends:

postgresql-9.4-repmgr-dbg |

postgresql-9.3-repmgr-dbg |

postgresql-9.2-repmgr-dbg |

Description: transitional dummy package

This is a transitional dummy package. It can safely be removed.

Architecture: any

Suggests: rsync

Since version 9.0, PostgreSQL allow you to have replicated hot

standby servers which you can query and/or use for high availability.

While the main components of the feature are included with

repmgr allows you to monitor and manage your replicated PostgreSQL

databases as a single cluster.

.

Section: debug

Architecture: any

Replaces: repmgr-dbg (<< 3.0.1-1)

Breaks: repmgr-dbg (<< 3.0.1-1)

Since version 9.0, PostgreSQL allow you to have replicated hot

standby servers which you can query and/or use for high availability.

While the main components of the feature are included with

repmgr allows you to monitor and manage your replicated PostgreSQL

databases as a single cluster.

.

Package: repmgr

Architecture: all

Depends:

postgresql-9.4-repmgr |

postgresql-9.3-repmgr |

postgresql-9.2-repmgr |

Section: debug

Architecture: all

Depends:

postgresql-9.4-repmgr-dbg |

postgresql-9.3-repmgr-dbg |

postgresql-9.2-repmgr-dbg |

1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile

--- a/Makefile

+++ b/Makefile

@@ -15,11 +15,11 @@ all: repmgrd repmgr

create mode 100644 sql/repmgr_test.sql

diff --git a/Makefile b/Makefile

--- a/Makefile

+++ b/Makefile

@@ -6,6 +6,7 @@ repmgrd_OBJS = dbutils.o config.o repmgrd.o log.o strutil.o

PG_LIBS = $(libpq_pgport)

diff --git a/expected/repmgr_funcs.out b/expected/repmgr_funcs.out

new file mode 100644

--- /dev/null

+++ b/expected/repmgr_funcs.out

@@ -0,0 +1,18 @@

regress.patch

makefile-no-libs.patch

#define ERR_SYS_FAILURE 13

#define ERR_BAD_BASEBACKUP 14

#define ERR_INTERNAL 15

#endif /* _ERRCODE_H_ */

/* #define REPMGR_DEBUG */

void

stderr_log_with_level(const char *level_name, int level, const char *fmt, ...)

{

time_t t;

struct tm *tm;

char buff[100];

if (log_level >= level)

{

strftime(buff, 100, "[%Y-%m-%d %H:%M:%S]", tm);

fprintf(stderr, "%s [%s] ", buff, level_name);

vfprintf(stderr, fmt, ap);

fflush(stderr);

}

}

bool

{

int l;

int f;

printf("Assigned level for logger: %d\n", l);

#endif

log_level = l;

else

}

if (facility && *facility)

}

return true;

}

bool

logger_shutdown(void)

{

}

/*

*/

void

{

}

int

detect_log_level(const char *level)

{

if (!strcmp(level, "EMERG"))

return LOG_EMERG;

}

detect_log_facility(const char *facility)

{

int local = 0;

if (!strncmp(facility, "LOCAL", 5) && strlen(facility) == 6)

{

local = atoi(&facility[5]);

switch (local)

#endif

/* Logger initialisation and shutdown */

bool logger_shutdown(void);

extern int log_type;

extern int log_level;

static void do_cluster_cleanup(void);

static void do_check_upstream_config(void);

static void exit_with_errors(void);

/* Global variables */

static const char *keywords[6];

static const char *values[6];

static bool config_file_required = true;

/* Initialization of runtime options */

t_runtime_options runtime_options = T_RUNTIME_OPTIONS_INITIALIZER;

t_configuration_options options = T_CONFIGURATION_OPTIONS_INITIALIZER;

static char *server_mode = NULL;

static char *server_cmd = NULL;

static char *repmgr_slot_name_ptr = NULL;

static char path_buf[MAXLEN] = "";

int

main(int argc, char **argv)

{"pg_bindir", required_argument, NULL, 'b'},

{"rsync-only", no_argument, NULL, 'r'},

{"fast-checkpoint", no_argument, NULL, 'c'},

{"initdb-no-pwprompt", no_argument, NULL, 1},

{"check-upstream-config", no_argument, NULL, 2},

{"recovery-min-apply-delay", required_argument, NULL, 3},

int c, targ;

int action = NO_ACTION;

bool check_upstream_config = false;

bool config_file_parsed = false;

char *ptr = NULL;

/* Prevent getopt_long() from printing an error message */

opterr = 0;

&optindex)) != -1)

{

switch (c)

{

case '?':

exit(SUCCESS);

case 'V':

exit(SUCCESS);

case 'd':

strncpy(runtime_options.dbname, optarg, MAXLEN);

strncpy(runtime_options.host, optarg, MAXLEN);

break;

case 'p':

break;

case 'U':

strncpy(runtime_options.username, optarg, MAXLEN);

strncpy(runtime_options.dest_dir, optarg, MAXFILENAME);

break;

case 'l':

break;

case 'f':

strncpy(runtime_options.config_file, optarg, MAXLEN);

strncpy(runtime_options.remote_user, optarg, MAXLEN);

break;

case 'w':

break;

case 'k':

break;

case 'F':

runtime_options.force = true;

case 'c':

runtime_options.fast_checkpoint = true;

break;

case 1:

runtime_options.initdb_no_pwprompt = true;

break;

if (targ < 1)

{

break;

}

if (ptr && *ptr)

strcmp(ptr, "min") != 0 && strcmp(ptr, "h") != 0 &&

strcmp(ptr, "d") != 0)

{

break;

}

}

initPQExpBuffer(&unknown_option);

appendPQExpBuffer(&unknown_option, _("Unknown option '%s'"), argv[optind - 1]);

}

}

}

/* Exit here already if errors in command line options found */

if (cli_errors.head != NULL)

{

PQExpBufferData unknown_mode;

initPQExpBuffer(&unknown_mode);

appendPQExpBuffer(&unknown_mode, _("Unknown server mode '%s'"), server_mode);

}

}

if (action == NO_ACTION) {

if (server_cmd == NULL)

{

}

else

{

PQExpBufferData unknown_action;

initPQExpBuffer(&unknown_action);

appendPQExpBuffer(&unknown_action, _("Unknown server command '%s'"), server_cmd);

}

}

{

if (runtime_options.host[0])

{

}

else

{

PQExpBufferData too_many_args;

initPQExpBuffer(&too_many_args);

appendPQExpBuffer(&too_many_args, _("too many command-line arguments (first extra is \"%s\")"), argv[optind]);

}

check_parameters_for_action(action);

exit_with_errors();

}

if (!runtime_options.dbname[0])

{

if (getenv("PGDATABASE"))

}

/*

* default PostgreSQL port.

*/

if (!runtime_options.masterport[0])

strncpy(runtime_options.masterport, DEFAULT_MASTER_PORT, MAXLEN);

}

/*

* The configuration file is not required for some actions (e.g. 'standby clone'),

* however if available we'll parse it anyway for options like 'log_level',

* 'use_replication_slots' etc.

*/

/*

* Initialise pg_bindir - command line parameter will override

keywords[3] = "dbname";

values[3] = runtime_options.dbname;

keywords[4] = "application_name";

keywords[5] = NULL;

values[5] = NULL;

* logging level might be specified at, but it often requires detailed

* logging to troubleshoot problems.

*/

if (runtime_options.verbose)

/*

* Node configuration information is not needed for all actions, with

{

maxlen_snprintf(repmgr_slot_name, "repmgr_slot_%i", options.node);

repmgr_slot_name_ptr = repmgr_slot_name;

}

{

log_err(_("Unable to retrieve node information from the database\n%s\n"),

PQerrorMessage(conn));

PQclear(res);

PQfinish(conn);

PGconn *master_conn = NULL;

PGresult *res;

char sqlquery[QUERY_STR_LEN];

/* We need to connect to check configuration */

log_info(_("connecting to database\n"));

}

PQfinish(conn);

if (runtime_options.keep_history > 0)

{

sqlquery_snprintf(sqlquery,

"TRUNCATE TABLE %s.repl_monitor",

get_repmgr_schema_quoted(master_conn));

}

res = PQexec(master_conn, sqlquery);

if (PQresultStatus(res) != PGRES_COMMAND_OK)

{

PQerrorMessage(master_conn));

PQclear(res);

PQfinish(master_conn);

}

PQclear(res);

PQclear(res);

PQfinish(master_conn);

}

bool schema_exists = false;

int ret;

bool record_created;

conn = establish_db_connection(options.conninfo, true);

check_server_version(conn, "master", true, NULL);

/* Check we are a master */

ret = is_standby(conn);

if (ret)

PQfinish(master_conn);

*/

/* Delete any existing record for this node if --force set */

if (runtime_options.force)

{

PGresult *res;

bool node_record_deleted;

res = get_node_record(conn, options.cluster_name, options.node);

if (PQntuples(res))

{

}

}

}

if (record_created == false)

{

PQfinish(conn);

exit(ERR_DB_QUERY);

}

/* Log the event */

create_event_record(conn,

&options,

NULL, NULL);

if (!master_conn)

{

exit(ERR_BAD_CONFIG);

}

{

if (!runtime_options.force)

{

}

PQfinish(master_conn);

PQfinish(conn);

exit(ERR_BAD_CONFIG);

NULL, NULL);

if (!master_conn)

{

exit(ERR_BAD_CONFIG);

}

upstream_conn = establish_db_connection_by_params(keywords, values, true);

/* Verify that upstream node is a supported server version */

server_version_num = check_server_version(upstream_conn, "master", true, NULL);

check_upstream_config(upstream_conn, server_version_num, true);

strncpy(local_config_file, master_config_file, MAXFILENAME);

strncpy(local_hba_file, master_hba_file, MAXFILENAME);

strncpy(local_ident_file, master_ident_file, MAXFILENAME);

/*

* When using rsync only, we need to check the SSH connection early

{

log_err(_("unable to use directory %s ...\n"),

local_data_directory);

r = ERR_BAD_CONFIG;

retval = ERR_BAD_CONFIG;

goto stop_backup;

}

if (runtime_options.rsync_only)

{

PQExpBufferData tablespace_map;

}

/*

* turning off sync rep for this session

*/

if (set_config_bool(upstream_conn, "synchronous_commit", false) == false)

{

}

if (start_backup(upstream_conn, first_wal_segment, runtime_options.fast_checkpoint) == false)

" WHERE spcname NOT IN ('pg_default', 'pg_global')");

res = PQexec(upstream_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

log_err(_("unable to execute tablespace query: %s\n"),

PQerrorMessage(upstream_conn));

PQclear(res);

}

for (i = 0; i < PQntuples(res); i++)

if (unlink(tblspc_symlink.data) < 0 && errno != ENOENT)

{

log_err(_("unable to remove tablespace symlink %s\n"), tblspc_symlink.data);

}

if (symlink(tblspc_dir_dst.data, tblspc_symlink.data) < 0)

{

log_err(_("unable to create tablespace symlink from %s to %s\n"), tblspc_symlink.data, tblspc_dir_dst.data);

}

}

}

{

PQExpBufferData tablespace_map_filename;

FILE *tablespace_map_file;

if (unlink(tablespace_map_filename.data) < 0 && errno != ENOENT)

{

log_err(_("unable to remove tablespace_map file %s\n"), tablespace_map_filename.data);

}

tablespace_map_file = fopen(tablespace_map_filename.data, "w");

if (tablespace_map_file == NULL)

{

log_err(_("unable to create tablespace_map file '%s'\n"), tablespace_map_filename.data);

}

if (fputs(tablespace_map.data, tablespace_map_file) == EOF)

{

log_err(_("unable to write to tablespace_map file '%s'\n"), tablespace_map_filename.data);

}

fclose(tablespace_map_file);

}

}

else

{

if (r != 0)

{

log_warning(_("standby clone: base backup failed\n"));

retval = ERR_BAD_BASEBACKUP;

goto stop_backup;

}

/* If the backup failed then exit */

if (r != 0)

{

log_err(_("unable to take a base backup of the master server\n"));

log_warning(_("destination directory (%s) may need to be cleaned up manually\n"),

local_data_directory);

PQfinish(upstream_conn);

exit(retval);

}

/*

*/

{

char script[MAXLEN];

maxlen_snprintf(script, "rm -rf %s/pg_xlog/*",

local_data_directory);

r = system(script);

local_data_directory);

exit(ERR_BAD_RSYNC);

}

{

}

}

if (runtime_options.rsync_only)

{

log_notice(_("standby clone (using rsync) complete\n"));

* - provide a custom pg_ctl command

*/

if (target_directory_provided)

{

local_data_directory);

}

else

{

}

/* Log the event */

conn = establish_db_connection(options.conninfo, true);

/* Verify that standby is a supported server version */

check_server_version(conn, "standby", true, NULL);

create_event_record(NULL,

&options,

options.node,

false,

details.data);

"Node %i was successfully promoted to master",

options.node);

/* Log the event */

create_event_record(conn,

/* We need to connect to check configuration */

log_info(_("connecting to standby database\n"));

conn = establish_db_connection(options.conninfo, true);

/* Check we are in a standby node */

retval = is_standby(conn);

strncpy(runtime_options.masterport, PQport(master_conn), MAXLEN);

strncpy(runtime_options.username, PQuser(master_conn), MAXLEN);

log_info(_("changing standby's master\n"));

/* Get the data directory full path */

exit(ERR_BAD_CONFIG);

}

fputs(buf, pg_conf);

static void

{

printf(_("\n"));

printf(_("Usage:\n"));

printf(_(" %s [OPTIONS] standby {register|unregister|clone|promote|follow}\n"),

printf(_("\n"));

printf(_("General options:\n"));

printf(_(" -?, --help show this help, then exit\n"));

printf(_(" -V, --version output version information, then exit\n"));

printf(_(" -d, --dbname=DBNAME database to connect to\n"));

printf(_(" -h, --host=HOSTNAME database server host or socket directory\n"));

printf(_(" -p, --port=PORT database server port\n"));

printf(_(" -U, --username=USERNAME database user name to connect as\n"));

printf(_(" -b, --pg_bindir=PATH path to PostgreSQL binaries (optional)\n"));

printf(_(" -D, --data-dir=DIR local directory where the files will be\n" \

" copied to\n"));

printf(_(" -f, --config-file=PATH path to the configuration file\n"));

printf(_(" -R, --remote-user=USERNAME database server username for rsync\n"));

printf(_(" -F, --force force potentially dangerous operations to happen\n"));

printf(_(" --check-upstream-config verify upstream server configuration\n"));

printf(_("COMMANDS:\n"));

printf(_(" master register - registers the master in a cluster\n"));

printf(_(" standby clone [node] - creates a new standby\n"));

if (runtime_options.host[0] || runtime_options.masterport[0] ||

runtime_options.username[0] || runtime_options.dbname[0])

{

}

if (runtime_options.dest_dir[0])

{

}

break;

case STANDBY_REGISTER:

if (runtime_options.host[0] || runtime_options.masterport[0] ||

runtime_options.username[0] || runtime_options.dbname[0])

{

}

if (runtime_options.dest_dir[0])

{

}

break;

case STANDBY_UNREGISTER:

if (runtime_options.host[0] || runtime_options.masterport[0] ||

runtime_options.username[0] || runtime_options.dbname[0])

{

}

if (runtime_options.dest_dir[0])

{

}

break;

case STANDBY_PROMOTE:

if (runtime_options.host[0] || runtime_options.masterport[0] ||

runtime_options.username[0] || runtime_options.dbname[0])

{

}

if (runtime_options.dest_dir[0])

{

}

break;

case STANDBY_FOLLOW:

if (runtime_options.host[0] || runtime_options.masterport[0] ||

runtime_options.username[0] || runtime_options.dbname[0])

{

}

if (runtime_options.dest_dir[0])

{

}

break;

case STANDBY_CLONE:

if (strcmp(runtime_options.host, "") == 0)

{

}

if (strcmp(runtime_options.dbname, "") == 0)

{

}

if (strcmp(runtime_options.username, "") == 0)

{

}

config_file_required = false;

break;

}

if (action != STANDBY_CLONE)

{

if (runtime_options.fast_checkpoint)

{

}

if (runtime_options.ignore_external_config_files)

{

}

if (*runtime_options.recovery_min_apply_delay)

{

}

}

{

maxlen_snprintf(password_buf, " password=%s", password);

}

if (runtime_options.host[0])

{

{

if (server_version_num > 0)

log_err(_("%s requires %s to be PostgreSQL %s or later\n"),

server_type,

MIN_SUPPORTED_VERSION

);

if (i == 0)

{

log_err(_("parameter 'max_replication_slots' must be set to at least 1 to enable replication slots\n"));

if (exit_on_error == true)

{

PQfinish(conn);

runtime_options.wal_keep_segments);

if (server_version_num >= 90400)

{

"do not require 'wal_keep_segments' to be set to a high value "

"(set parameter 'use_replication_slots' in the configuration file to enable)\n"

));

* of what's in 'archive_command', so until 'archive_mode' is on we can't

* properly check it.

*/

if (guc_set(conn, "archive_mode", "=", "on"))

{

i = guc_set(conn, "archive_command", "!=", "");

}

i = guc_set(conn, "hot_standby", "=", "on");

if (i == 0 || i == -1)

{

if (i == 0)

{

log_err(_("parameter 'max_wal_senders' must be set to be at least 1\n"));

}

if (exit_on_error == true)

PGresult *res;

char sqlquery[QUERY_STR_LEN];

begin_transaction(conn);

conn = establish_db_connection_by_params(keywords, values, true);

/* Verify that upstream server is a supported server version */

server_version_num = check_server_version(conn, "upstream server", false, NULL);

config_ok = check_upstream_config(conn, server_version_num, false);

static void

{

}

static void

{

ErrorListCell *cell;

{

}

# Node ID and name

# (Note: we recommend to avoid naming nodes after their initial

# replication funcion, as this will cause confusion when e.g.

conninfo='host=192.168.204.104 dbname=repmgr_db user=repmgr_usr'

# Optional configuration items

# when using cascading replication and a standby is to be connected to an

# upstream standby, specify that node's ID with 'upstream_node'. The node

# must exist before the new standby can be registered. If a standby is

#

# upstream_node=1

# (default: 0)

#

# use_replication_slots=0

# Logging and monitoring settings

# -------------------------------

#

# These settings are only applied when repmgrd is running.

master_response_timeout=60

reconnect_attempts=6

reconnect_interval=10

# Autofailover options

failover=automatic # one of 'automatic', 'manual'

promote_command='repmgr standby promote -f /path/to/repmgr.conf'

follow_command='repmgr standby follow -f /path/to/repmgr.conf -W'

#

# monitor_interval_secs=2

# disappears, we wait 'reconnect_attempts' * 'retry_promote_interval_secs'

# seconds; by default this would be half an hour, as 'retry_promote_interval_secs'

# default value is 300)

#

# retry_promote_interval_secs=300

#define MAXFILENAME 1024

#define ERRBUFF_SIZE 512

#define DEFAULT_WAL_KEEP_SEGMENTS "5000"

#define DEFAULT_DEST_DIR "."

#define DEFAULT_MASTER_PORT "5432"

#define AUTOMATIC_FAILOVER 1

#define NODE_NOT_FOUND -1

#define NO_UPSTREAM_NODE -1

char superuser[MAXLEN];

char wal_keep_segments[MAXLEN];

bool verbose;

bool force;

bool wait_for_master;

bool ignore_rsync_warn;

bool ignore_external_config_files;

char masterport[MAXLEN];

char localport[MAXLEN];

/* parameter used by CLUSTER CLEANUP */

int keep_history;

char recovery_min_apply_delay[MAXLEN];

} t_runtime_options;

extern char repmgr_schema[MAXLEN];

#endif

#include "access/xlogdefs.h"

#include "pqexpbuffer.h"

/* Local info */

PGconn *master_conn = NULL;

bool verbose = false;

bool monitoring_history = false;

t_node_info node_info;

t_configuration_options config = T_CONFIGURATION_OPTIONS_INITIALIZER;

static void usage(void);

static void check_cluster_configuration(PGconn *conn);

static void check_node_configuration(void);

static void standby_monitor(void);

static void witness_monitor(void);

static bool check_connection(PGconn **conn, const char *type, const char *conninfo);

static void update_shared_memory(char *last_wal_standby_applied);

static void update_registration(void);

FILE *fd;

int server_version_num = 0;

{

switch (c)

{

pid_file = optarg;

break;

case '?':

exit(SUCCESS);

case 'V':

exit(SUCCESS);

default:

usage();

* which case we'll need to refactor parse_config() not to abort,

* and return the error message.

*/

if (daemonize)

{

strerror(errno));

}

if (verbose)

if (log_type == REPMGR_SYSLOG)

{

}

/* Initialise the repmgr schema name */

maxlen_snprintf(repmgr_schema, "%s%s", DEFAULT_REPMGR_SCHEMA_PREFIX,

local_options.cluster_name);

if (server_version_num > 0)

{

log_err(_("%s requires PostgreSQL %s or later\n"),

MIN_SUPPORTED_VERSION) ;

}

else

if (node_info.node_id == NODE_NOT_FOUND)

{

log_err(_("No metadata record found for this node - terminating\n"));

terminate(ERR_BAD_CONFIG);

}

appendPQExpBuffer(&errmsg,

_("unable to connect to master node '%s'"),

log_err("%s\n", errmsg.data);

do

{

if (node_info.type == WITNESS)

{

{

standby_monitor();

}

sleep(local_options.monitor_interval_secs);

if (got_SIGHUP)

{

log_warning(

_("unable to determine a valid master server; waiting %i seconds to retry...\n"),

);

PQfinish(master_conn);

}

else

{

char last_wal_standby_received[MAXLEN];

char last_wal_standby_applied[MAXLEN];

char last_wal_standby_applied_timestamp[MAXLEN];

char sqlquery[QUERY_STR_LEN];

XLogRecPtr lsn_master;

{

PQExpBufferData errmsg;

initPQExpBuffer(&errmsg);

appendPQExpBuffer(&errmsg,

log_err("%s\n", errmsg.data);

}

upstream_conn = get_upstream_connection(my_local_conn,

check_connection(&upstream_conn, type, upstream_conninfo);

/*

* This takes up to local_options.reconnect_attempts *

*/

if (PQstatus(upstream_conn) != CONNECTION_OK)

PQfinish(upstream_conn);

/* Check if we still are a standby, we could have been promoted */

do

{

* will require manual resolution as there's no way of determing

* which master is the correct one.

*

* XXX check if the original master is still active and display a

* warning

*/

terminate(1);

break;

if (!check_connection(&my_local_conn, "standby", NULL))

{

}

break;

if (did_retry)

{

}

/* Fast path for the case where no history is requested */

if (!monitoring_history)

return;

/*

* If original master has gone away we'll need to get the new one

* from the upstream node to write monitoring information

/* Get local xlog info */

sqlquery_snprintf(sqlquery,

"SELECT CURRENT_TIMESTAMP, pg_last_xlog_receive_location(), "

res = PQexec(my_local_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

strncpy(last_wal_standby_received, PQgetvalue(res, 0, 1), MAXLEN);

strncpy(last_wal_standby_applied, PQgetvalue(res, 0, 2), MAXLEN);

strncpy(last_wal_standby_applied_timestamp, PQgetvalue(res, 0, 3), MAXLEN);

PQclear(res);

/* Get master xlog info */

res = PQexec(master_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

" last_monitor_time, last_apply_time, "

" last_wal_primary_location, last_wal_standby_location, "

" replication_lag, apply_lag ) "

get_repmgr_schema_quoted(master_conn),

master_options.node, local_options.node,

monitor_standby_timestamp, last_wal_standby_applied_timestamp,

* Execute the query asynchronously, but don't check for a result. We will

* check the result next time we pause for a monitor step.

*/

if (PQsendQuery(master_conn, sqlquery) == 0)

log_warning(_("query could not be sent to master. %s\n"),

PQerrorMessage(master_conn));

t_node_info nodes[FAILOVER_NODES_MAX_CHECK];

/* Store details of the failed node here */

/* Store details of the best candidate for promotion to master here */

/* get a list of standby nodes, including myself */

sprintf(sqlquery,

terminate(ERR_FAILOVER_FAIL);

}

res = PQexec(node_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

log_info(_("unable to retrieve node's last standby location: %s\n"),

PQerrorMessage(node_conn));

log_debug(_("connection details: %s\n"), nodes[i].conninfo_str);

PQclear(res);

PQfinish(node_conn);

}

/* last we get info about this node, and update shared memory */

res = PQexec(my_local_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

res = PQexec(node_conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

"be considered as new master and exit.\n"),

PQerrorMessage(node_conn));

PQclear(res);

PQclear(res);

/* If position is 0/0, keep checking */

continue;

}

/* wait */

sleep(5);

log_debug(_("promote command is: \"%s\"\n"),

local_options.promote_command);

/* wait */

sleep(10);

/*

* The new master may some time to be promoted. The follow command

fflush(stderr);

}

r = system(local_options.follow_command);

if (r != 0)

{

appendPQExpBuffer(&event_details,

log_err("%s\n", event_details.data);

&local_options,

node_info.node_id,

"repmgrd_failover_follow",

terminate(ERR_BAD_CONFIG);

}

/* update internal record for this node*/

node_info = get_node_info(new_master_conn, local_options.cluster_name, local_options.node);

appendPQExpBuffer(&event_details,

_("Node %i now following new upstream node %i"),

node_info.node_id,

best_candidate.node_id);

create_event_record(new_master_conn,

&local_options,

node_info.node_id,

* It might be worth providing a selection of reconnection strategies

* as different behaviour might be desirable in different situations;

* or maybe the option not to reconnect might be required?

*/

static bool

do_upstream_standby_failover(t_node_info upstream_node)

char sqlquery[QUERY_STR_LEN];

int upstream_node_id = node_info.upstream_node_id;

int r;

log_debug(_("do_upstream_standby_failover(): performing failover for node %i\n"),

node_info.node_id);

}

PQclear(res);

}

/* Close the connection to this server */

PQfinish(my_local_conn);

my_local_conn = NULL;

/* Follow new upstream */

r = system(local_options.follow_command);

if (r != 0)

{

terminate(ERR_BAD_CONFIG);

}

if (update_node_record_set_upstream(master_conn, local_options.cluster_name, node_info.node_id, upstream_node_id) == false)

{

terminate(ERR_BAD_CONFIG);

}

my_local_conn = establish_db_connection(local_options.conninfo, true);

return true;

/*

* Check if the node is still available if after

* seconds of retries we cannot reconnect return false

*/

for (connection_retries = 0; connection_retries < local_options.reconnect_attempts; connection_retries++)

{

log_warning(_("connection to %s has been lost, trying to recover... %i seconds before failover decision\n"),

type,

}

else

{

/*

*

* If failure of the local node is detected, attempt to connect

* to the current master server (as stored in the global variable

*/

static bool

{

char sqlquery[QUERY_STR_LEN];

char master_conninfo[MAXLEN];

if (!check_connection(&master_conn, "master", NULL))

{

return false;

}

/*

*/

{

log_err(_("unable to set local node %i as inactive on master: %s\n"),

node_info.node_id,

sqlquery_snprintf(sqlquery,

"SELECT oid FROM pg_class "

" WHERE oid = '%s.repl_nodes'::regclass ",

res = PQexec(conn, sqlquery);

if (PQresultStatus(res) != PGRES_TUPLES_OK)

{

void

usage(void)

{

}

void

{

printf(_("\n"));

printf(_("Usage:\n"));

printf(_("\n"));

printf(_("Options:\n"));

printf(_(" -?, --help show this help, then exit\n"));

printf(_(" -d, --daemonize detach process from foreground\n"));

printf(_(" -p, --pid-file=PATH write a PID file\n"));

printf(_("\n"));

}

unlink(pid_file);

}

exit(retval);

}

{

PGresult *res;

res = get_node_record(conn, cluster, node_id);

#ifndef _VERSION_H_

#define _VERSION_H_

#endif