Fix alignment and syntax

Add sample configuration for systemd support
Allow overriding start, stop and restart commands issued by repmgr
2026-03-23 23:26:30 +00:00 · 2016-09-23 13:45:59 -03:00 · 2016-09-23 13:45:50 -03:00 · 2016-09-23 13:45:32 -03:00 · 2016-08-15 12:31:42 +09:00 · 2016-08-15 12:22:33 +09:00
37 changed files with 1867 additions and 6389 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -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.
@@ -21,11 +21,9 @@ copy of the relevant Copyright Assignment Form.
 Code style
 ----------

-Code in repmgr should be formatted to the same standards as the main PostgreSQL
-project. For more details see:
+Code in repmgr is formatted to a consistent style using the following command:

-    https://www.postgresql.org/docs/current/static/source-format.html
+    astyle --style=ansi --indent=tab --suffix=none *.c *.h

 Contributors should reformat their code similarly before submitting code to
-the project, in order to minimize merge conflicts with other work.
-
+the project, in order to minimize merge conflicts with other work.
--- a/2
+++ b/2
@@ -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
--- a/FAQ.md
+++ b/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.
--- a/77
+++ b/77
@@ -1,80 +1,3 @@
-3.3.3   2017-06
-        repmgr: fix `standby register --force` when updating existing node record (Ian)
-
-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
--- a/17
+++ b/17
@@ -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/
--- a/README.md
+++ b/README.md
@@ -7,8 +7,6 @@ replication capabilities with utilities to set up standby servers, monitor
 replication, and perform administrative tasks such as failover or switchover
 operations.

-The current `repmgr` version (3.3) supports all PostgreSQL versions from
-9.3 to 9.6.

 Overview
 --------
@@ -121,8 +119,7 @@ views:
    status for each node

 The `repmgr` metadata schema can be stored in an existing database or in its own
-dedicated database. Note that the `repmgr` metadata schema cannot reside on a database
-server which is not part of the replication cluster managed by `repmgr`.
+dedicated database.

 A dedicated database superuser is required to own the meta-database as well as carry
 out administrative actions.
@@ -146,27 +143,10 @@ The `repmgr` tools must be installed on each server in the replication cluster.

 A dedicated system user for `repmgr` is *not* required; as many `repmgr` and
 `repmgrd` actions require direct access to the PostgreSQL data directory,
-these commands should be executed by the `postgres` user.
+it should be executed by the `postgres` user.

-Passwordless `ssh` connectivity between all servers in the replication cluster
-is not required, but is necessary in the following cases:
-
-* if you need `repmgr` to copy configuration files from outside the PostgreSQL
-  data directory
-* when using `rsync` to clone a standby
-* to perform switchover operations
-* when executing `repmgr cluster matrix` and `repmgr cluster crosscheck`
-
-In these cases `rsync` is required on all servers too.
-
-* * *
-
-> *TIP*: We recommend using a session multiplexer utility such as `screen` or
-> `tmux` when performing long-running actions (such as cloning a database)
-> on a remote server - this will ensure the `repmgr` action won't be prematurely
-> terminated if your `ssh` session to the server is interrupted or closed.
-
-* * *
+Additionally, we recommend installing `rsync` and enabling passwordless
+`ssh` connectivity between all servers in the replication cluster.

 ### Packages

@@ -189,14 +169,6 @@ system.
  Instructions can be found in the APT section of the PostgreSQL Wiki
  ( https://wiki.postgresql.org/wiki/Apt ).

-  *NOTE*: repmgr 3.3 packages are now only available via a 2ndQuadrant-hosted
-  repository which can be installed like this:
-
-    apt-key adv --fetch-keys http://packages.2ndquadrant.com/repmgr3/apt/0xD3FA41F6.asc
-
-    echo deb http://packages.2ndquadrant.com/repmgr3/apt/ $(lsb_release -cs)-2ndquadrant main > /etc/apt/sources.list.d/repmgr3.list
-
-
 See `PACKAGES.md` for details on building .deb and .rpm packages from the
 `repmgr` source code.

@@ -210,7 +182,7 @@ See `PACKAGES.md` for details on building .deb and .rpm packages from the
 Release tarballs are also available:

    https://github.com/2ndQuadrant/repmgr/releases
-    http://repmgr.org/
+    http://repmgr.org/downloads.php

 `repmgr` is compiled in the same way as a PostgreSQL extension using the PGXS
 infrastructure, e.g.:
@@ -238,29 +210,15 @@ The configuration file will be searched for in the following locations:

 Note that if a file is explicitly specified with `-f/--config-file`, an error will
 be raised if it is not found or not readable and no attempt will be made to check
-default locations; this is to prevent `repmgr` unexpectedly reading the wrong file.
+default locations; this is to prevent `repmgr` reading the wrong file.

 For a full list of annotated configuration items, see the file `repmgr.conf.sample`.

 The following parameters in the configuration file can be overridden with
 command line options:

- `log_level` with `-L/--log-level`
- `pg_bindir` with `-b/--pg_bindir`
-
-
-### Logging
-
-By default `repmgr` and `repmgrd` will log directly to `STDERR`. For `repmgrd`
-we recommend capturing output in a logfile or using your system's log facility;
-see `repmgr.conf.sample` for details.
-
-As a command line utility, `repmgr` will log directly to the console by default
-(this is a change in behaviour from versions before 3.3, where it would always
-log to the same location as `repmgrd`). However in some circumstances, such as
-when `repmgr` is executed by `repmgrd` during a failover event, it makes sense to
-capture `repmgr`'s log output - this can be done by supplying the command-line
-option `--log-to-file` to `repmgr`.
+- `-L/--log-level`
+- `-b/--pg_bindir`


 ### Command line options and environment variables
@@ -297,21 +255,21 @@ Setting up a simple replication cluster with repmgr
 The following section will describe how to set up a basic replication cluster
 with a master and a standby server using the `repmgr` command line tool.
 It is assumed PostgreSQL is installed on both servers in the cluster,
-`rsync` is available and passwordless SSH connections are possible between
+`rsync` is available and password-less SSH connections are possible between
 both servers.

 * * *

 > *TIP*: for testing `repmgr`, it's possible to use multiple PostgreSQL
 > instances running on different ports on the same computer, with
-> passwordless SSH access to `localhost` enabled.
+> password-less SSH access to `localhost` enabled.

 * * *

 ### PostgreSQL configuration

 On the master server, a PostgreSQL instance must be initialised and running.
-The following replication settings may need to be adjusted:
+The following replication settings must be included in `postgresql.conf`:


    # Enable replication connections; set this figure to at least one more
@@ -322,16 +280,17 @@ The following replication settings may need to be adjusted:
    max_wal_senders = 10

    # Ensure WAL files contain enough information to enable read-only queries
-    # on the standby.
-    #
-    #  PostgreSQL 9.5 and earlier: one of 'hot_standby' or 'logical'
-    #  PostgreSQL 9.6 and later: one of 'replica' or 'logical'
-    #    ('hot_standby' will still be accepted as an alias for 'replica')
-    #
-    # See: https://www.postgresql.org/docs/current/static/runtime-config-wal.html#GUC-WAL-LEVEL
+    # on the standby

    wal_level = 'hot_standby'

+    # How much WAL to retain on the master 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
+    # 9.3; from 9.4, replication slots can be used instead (see below).
+
+    wal_keep_segments = 5000
+
    # Enable read-only queries on a standby
    # (Note: this will be ignored on a master but we recommend including
    # it anyway)
@@ -346,15 +305,6 @@ The following replication settings may need to be adjusted:
    # ignores archiving. Use something more sensible.
    archive_command = '/bin/true'

-    # If cloning using rsync, or you have configured `pg_basebackup_options`
-    # in `repmgr.conf` to include the setting `--xlog-method=fetch` (from
-    # PostgreSQL 10 `--wal-method=fetch`), *and* you have not set
-    # `restore_command` in `repmgr.conf`to fetch WAL files from another
-    # source such as Barman, you'll need to set `wal_keep_segments` to a
-    # high enough value to ensure that all WAL files generated while
-    # the standby is being cloned are retained until the standby starts up.
-
-    # wal_keep_segments = 5000

 * * *

@@ -405,8 +355,7 @@ least the following parameters:

 - `cluster`: an arbitrary name for the replication cluster; this must be identical
     on all nodes
- `node`: a unique integer identifying the node; note this must be a positive
-     32 bit signed integer between 1 and 2147483647
+- `node`: a unique integer identifying the node
 - `node_name`: a unique string identifying the node; we recommend a name
     specific to the server (e.g. 'server_1'); avoid names indicating the
     current replication role like 'master' or 'standby' as the server's
@@ -414,8 +363,7 @@ least the following parameters:
 - `conninfo`: a valid connection string for the `repmgr` database on the
     *current* server. (On the standby, the database will not yet exist, but
     `repmgr` needs to know the connection details to complete the setup
-     process). *NOTE* this must be a keyword/value string, not a connection
-     URI; this limitation will be removed in a future `repmgr` version.
+     process).

 `repmgr.conf` should not be stored inside the PostgreSQL data directory,
 as it could be overwritten when setting up or reinitialising the PostgreSQL
@@ -427,24 +375,14 @@ to include this schema name, e.g.

    ALTER USER repmgr SET search_path TO repmgr_test, "$user", public;

-* * *
-
-> *TIP*: for Debian-based distributions we recommend explictly setting
-> `pg_bindir` to the directory where `pg_ctl` and other binaries not in
-> the standard path are located. For PostgreSQL 9.5 this would be
-> `/usr/lib/postgresql/9.5/bin/`.
-
-* * *
-
-
 ### Initialise the master server

 To enable `repmgr` to support a replication cluster, the master node must
-be registered with `repmgr`, which creates the `repmgr` metadatabase and adds
+be registered with `repmgr`, which creates the `repmgr` database and adds
 a metadata record for the server:

    $ repmgr -f repmgr.conf master register
-    NOTICE: master node correctly registered for cluster test with id 1 (conninfo: host=repmgr_node1 user=repmgr dbname=repmgr)
+    [2016-01-07 16:56:46] [NOTICE] master node correctly registered for cluster test with id 1 (conninfo: host=repmgr_node1 user=repmgr dbname=repmgr)

 The metadata record looks like this:

@@ -471,46 +409,19 @@ the values `node`, `node_name` and `conninfo` adjusted accordingly, e.g.:
 Clone the standby with:

    $ repmgr -h repmgr_node1 -U repmgr -d repmgr -D /path/to/node2/data/ -f /etc/repmgr.conf standby clone
-    NOTICE: destination directory '/path/to/node2/data/' provided
-    NOTICE: starting backup...
-    HINT: this may take some time; consider using the -c/--fast-checkpoint option
+    [2016-01-07 17:21:26] [NOTICE] destination directory '/path/to/node2/data/' provided
+    [2016-01-07 17:21:26] [NOTICE] starting backup...
+    [2016-01-07 17:21:26] [HINT] this may take some time; consider using the -c/--fast-checkpoint option
    NOTICE:  pg_stop_backup complete, all required WAL segments have been archived
-    NOTICE: standby clone (using pg_basebackup) complete
-    NOTICE: you can now start your PostgreSQL server
-    HINT: for example : pg_ctl -D /path/to/node2/data/ start
+    [2016-01-07 17:21:28] [NOTICE] standby clone (using pg_basebackup) complete
+    [2016-01-07 17:21:28] [NOTICE] you can now start your PostgreSQL server
+    [2016-01-07 17:21:28] [HINT] for example : pg_ctl -D /path/to/node2/data/ start

 This will clone the PostgreSQL data directory files from the master at `repmgr_node1`
 using PostgreSQL's `pg_basebackup` utility. A `recovery.conf` file containing the
 correct parameters to start streaming from this master server will be created
-automatically.
-
-Note that by default, any configuration files in the master's data directory will be
-copied to the standby. Typically these will be `postgresql.conf`, `postgresql.auto.conf`,
-`pg_hba.conf` and `pg_ident.conf`. These may require modification before the standby
-is started so it functions as desired.
-
-In some cases (e.g. on Debian or Ubuntu Linux installations), PostgreSQL's
-configuration files are located outside of the data directory and will
-not be copied by default. `repmgr` can copy these files, either to the same
-location on the standby server (provided appropriate directory and file permissions
-are available), or into the standby's data directory. This requires passwordless
-SSH access to the master server. Add the option `--copy-external-config-files`
-to the `repmgr standby clone` command; by default files will be copied to
-the same path as on the upstream server. To have them placed in the standby's
-data directory, specify `--copy-external-config-files=pgdata`, but note that
-any include directives in the copied files may need to be updated.
-
-*Caveat*: when copying external configuration files: `repmgr` will only be able
-to detect files which contain active settings. If a file is referenced by
-an include directive but is empty, only contains comments or contains
-settings which have not been activated, the file will not be copied.
-
-* * *
-
-> *TIP*: for reliable configuration file management we recommend using a
-> configuration management tool such as Ansible, Chef, Puppet or Salt.
-
-* * *
+automatically, and unless otherwise specified, the `postgresql.conf` and `pg_hba.conf`
+files will be copied from the master.

 Be aware that when initially cloning a standby, you will need to ensure
 that all required WAL files remain available while the cloning is taking
@@ -518,8 +429,7 @@ place. To ensure this happens when using the default `pg_basebackup` method,
 `repmgr` will set `pg_basebackup`'s `--xlog-method` parameter to `stream`,
 which will ensure all WAL files generated during the cloning process are
 streamed in parallel with the main backup. Note that this requires two
-replication connections to be available (`repmgr` will verify sufficient
-connections are available before attempting to clone).
+replication connections to be available.

 To override this behaviour, in `repmgr.conf` set `pg_basebackup`'s
 `--xlog-method` parameter to `fetch`:
@@ -531,9 +441,6 @@ See the `pg_basebackup` documentation for details:

    https://www.postgresql.org/docs/current/static/app-pgbasebackup.html

-> *NOTE*: From PostgreSQL 10, `pg_basebackup`'s `--xlog-method` parameter
-> has been renamed to `--wal-method`.
-
 Make any adjustments to the standby's PostgreSQL configuration files now,
 then start the server.

@@ -576,8 +483,8 @@ Connect to the master server and execute:

 Register the standby server with:

-    $ repmgr -f /etc/repmgr.conf standby register
-    NOTICE: standby node correctly registered for cluster test with id 2 (conninfo: host=repmgr_node2 user=repmgr dbname=repmgr)
+    repmgr -f /etc/repmgr.conf standby register
+    [2016-01-08 11:13:16] [NOTICE] standby node correctly registered for cluster test with id 2 (conninfo: host=repmgr_node2 user=repmgr dbname=repmgr)

 Connect to the standby server's `repmgr` database and check the `repl_nodes`
 table:
@@ -596,117 +503,13 @@ standby's upstream server is the replication cluster master. While of limited
 use in a simple master/standby replication cluster, this information is required
 to effectively manage cascading replication (see below).

-* * *
-
-> *TIP*: depending on your environment and workload, it may take some time for
-> the standby's node record to propagate from the master to the standby. Some
-> actions (such as starting `repmgrd`) require that the standby's node record
-> is present and up-to-date to function correctly - by providing the option
-> `--wait-sync` to the `repmgr standby register` command, `repmgr` will wait
-> until the record is synchronised before exiting. An optional timeout (in
-> seconds) can be added to this option (e.g. `--wait-sync=60`).
-
-* * *
-
-Under some circumstances you may wish to register a standby which is not
-yet running; this can be the case when using provisioning tools to create
-a complex replication cluster. In this case, by using the `-F/--force`
-option and providing the connection parameters to the master server,
-the standby can be registered.
-
-Similarly, with cascading replication it may be necessary to register
-a standby whose upstream node has not yet been registered - in this case,
-using `-F/--force` will result in the creation of an inactive placeholder
-record for the upstream node, which will however later need to be registered
-with the `-F/--force` option too.
-
-When used with `standby register`, care should be taken that use of the
-`-F/--force` option does not result in an incorrectly configured cluster.
-
-### Using Barman to clone a standby
-
-`repmgr standby clone` also supports Barman, the Backup and
-Replication manager (http://www.pgbarman.org/), as a provider of both
-base backups and WAL files.
-
-Barman support provides the following advantages:
-
- the master node does not need to perform a new backup every time a
-  new standby is cloned;
- a standby node can be disconnected for longer periods without losing
-  the ability to catch up, and without causing accumulation of WAL
-  files on the master node;
- therefore, `repmgr` does not need to use replication slots, and the
-  master node does not need to set `wal_keep_segments`.
-
-> *NOTE*: In view of the above, Barman support is incompatible with
-> the `use_replication_slots` setting in `repmgr.conf`.
-
-In order to enable Barman support for `repmgr standby clone`, you must
-ensure that:
-
- the name of the server configured in Barman is equal to the
-  `cluster` setting in `repmgr.conf`;
- the `barman_server` setting in `repmgr.conf` is set to the SSH
-  hostname of the Barman server;
- the `restore_command` setting in `repmgr.conf` is configured to
-  use a copy of the `barman-wal-restore` script shipped with the
-  `barman-cli` package (see below);
- the Barman catalogue includes at least one valid backup for this
-  server.
-
-> *NOTE*: Barman support is automatically enabled if `barman_server`
-> is set. Normally it is a good practice to use Barman, for instance
-> when fetching a base backup while cloning a standby; in any case,
-> Barman mode can be disabled using the `--without-barman` command
-> line option.
-
-> *NOTE*: if you have a non-default SSH configuration on the Barman
-> server, e.g. using a port other than 22, then you can set those
-> parameters in a dedicated Host section in `~/.ssh/config`
-> corresponding to the value of `barman_server` in `repmgr.conf`. See
-> the "Host" section in `man 5 ssh_config` for more details.
-
-`barman-wal-restore` is a Python script provided by the Barman
-development team as part of the `barman-cli` package (Barman 2.0
-and later; for Barman 1.x the script is provided separately as
-`barman-wal-restore.py`).
-
-`restore_command` must then be set in `repmgr.conf` as follows:
-
-    <script> <Barman hostname> <cluster_name> %f %p
-
-For instance, suppose that we have installed Barman on the `barmansrv`
-host, and that `barman-wal-restore` is located as an executable at
-`/usr/bin/barman-wal-restore`;  `repmgr.conf` should include the following
-lines:
-
-    barman_server=barmansrv
-    restore_command=/usr/bin/barman-wal-restore barmansrv test %f %p
-
-NOTE: to use a non-default Barman configuration file on the Barman server,
-specify this in `repmgr.conf` with `barman_config`:
-
-    barman_config=/path/to/barman.conf
-
-Now we can clone a standby using the Barman server:
-
-    $ repmgr -h node1 -d repmgr -D 9.5/main -f /etc/repmgr.conf standby clone
-    NOTICE: destination directory '9.5/main' provided
-    NOTICE: getting backup from Barman...
-    NOTICE: standby clone (from Barman) complete
-    NOTICE: you can now start your PostgreSQL server
-    HINT: for example : pg_ctl -D 9.5/data start
-    HINT: After starting the server, you need to register this standby with "repmgr standby register"
-
-

 Advanced options for cloning a standby
 --------------------------------------

-The above section demonstrates the simplest possible way to clone a standby
-server. Depending on your circumstances, finer-grained control over the
-cloning process may be necessary.
+The above section demonstrates the simplest possible way to cloneb a standby
+server. Depending on your circumstances, finer-grained controlover the cloning
+process may be necessary.

 ### pg_basebackup options when cloning a standby

@@ -719,7 +522,11 @@ so should be used with care.
 Further options can be passed to the `pg_basebackup` utility via
 the setting `pg_basebackup_options` in `repmgr.conf`. See the PostgreSQL
 documentation for more details of available options:
+<<<<<<< HEAD
+  http://www.postgresql.org/docs/current/static/app-pgbasebackup.html
+=======
  https://www.postgresql.org/docs/current/static/app-pgbasebackup.html
+>>>>>>> 72f9b0145afab1060dd1202c8f8937653c8b2e39

 ### Using rsync to clone a standby

@@ -737,41 +544,34 @@ and destination server as the contents of files existing on both servers need
 to be compared, meaning this method is not necessarily faster than making a
 fresh clone with `pg_basebackup`.

-> *NOTE*: `barman-wal-restore` supports command line switches to
-> control parallelism (`--parallel=N`) and compression (`--bzip2`,
-> `--gzip`).
+### Dealing with PostgreSQL configuration files
+
+By default, `repmgr` will attempt to copy the standard configuration files
+(`postgresql.conf`, `pg_hba.conf` and `pg_ident.conf`) even if they are located
+outside of the data directory (though currently they will be copied
+into the standby's data directory). To prevent this happening, when executing
+`repmgr standby clone` provide the `--ignore-external-config-files` option.
+
+If using `rsync` to clone a standby, additional control over which files
+not to transfer is possible by configuring `rsync_options` in `repmgr.conf`,
+which enables any valid `rsync` options to be passed to that command, e.g.:
+
+    rsync_options='--exclude=postgresql.local.conf'

 ### Controlling `primary_conninfo` in `recovery.conf`

-The `primary_conninfo` setting in `recovery.conf` generated by `repmgr`
-is generated from the following sources, in order of highest to lowest priority:
-
- the upstream node's `conninfo` setting (as defined in the `repl_nodes` table)
- the connection parameters provided to `repmgr standby clone`
- PostgreSQL's standard connection defaults, including any environment variables
-  set on the local node.
+`repmgr` will create the `primary_conninfo` setting in `recovery.conf` based
+on the connection parameters provided to `repmgr standby clone` and PostgreSQL's
+standard connection defaults, including any environment variables set on the
+local node.

 To include specific connection parameters other than the standard host, port,
 username and database values (e.g. `sslmode`), include these in a `conninfo`-style
-string passed to `repmgr` with `-d/--dbname` (see above for details), and/or set
+tring passed to `repmgr` with `-d/--dbname` (see above for details), and/or set
 appropriate environment variables.

 Note that PostgreSQL will always set explicit defaults for `sslmode` and
-`sslcompression` (and from PostgreSQL 10.0 also `target_session_attrs`).
-
-If `application_name` is set in the standby's `conninfo` parameter in
-`repmgr.conf`, this value will be appended to `primary_conninfo`, otherwise
-`repmgr` will set `application_name` to the same value as the `node_name`
-parameter.
-
-By default `repmgr` assumes the user who owns the `repmgr` metadatabase will
-also be the replication user; a different replication user can be specified
-with `--replication-user`.
-
-If the upstream server requires a password, and this was provided via
-`PGPASSWORD`, `.pgpass` etc., by default `repmgr` will include this in
-`primary_conninfo`. Use the command line option `--no-conninfo-password` to
-suppress this.
+`sslcompression`.


 Setting up cascading replication with repmgr
@@ -806,15 +606,15 @@ created standby. Clone this standby (using the connection parameters
 for the existing standby) and register it:

    $ repmgr -h repmgr_node2 -U repmgr -d repmgr -D /path/to/node3/data/ -f /etc/repmgr.conf standby clone
-    NOTICE: destination directory 'node_3/data/' provided
-    NOTICE: starting backup (using pg_basebackup)...
-    HINT: this may take some time; consider using the -c/--fast-checkpoint option
-    NOTICE: standby clone (using pg_basebackup) complete
-    NOTICE: you can now start your PostgreSQL server
-    HINT: for example : pg_ctl -D /path/to/node_3/data start
+    [2016-01-08 13:44:52] [NOTICE] destination directory 'node_3/data/' provided
+    [2016-01-08 13:44:52] [NOTICE] starting backup (using pg_basebackup)...
+    [2016-01-08 13:44:52] [HINT] this may take some time; consider using the -c/--fast-checkpoint option
+    [2016-01-08 13:44:52] [NOTICE] standby clone (using pg_basebackup) complete
+    [2016-01-08 13:44:52] [NOTICE] you can now start your PostgreSQL server
+    [2016-01-08 13:44:52] [HINT] for example : pg_ctl -D /path/to/node_3/data start

    $ repmgr -f /etc/repmgr.conf standby register
-    NOTICE: standby node correctly registered for cluster test with id 3 (conninfo: host=repmgr_node3 dbname=repmgr user=repmgr)
+    [2016-01-08 14:04:32] [NOTICE] standby node correctly registered for cluster test with id 3 (conninfo: host=repmgr_node3 dbname=repmgr user=repmgr)

 After starting the standby, the `repl_nodes` table will look like this:

@@ -826,15 +626,6 @@ After starting the standby, the `repl_nodes` table will look like this:
      3 | standby |                2 | test    | node3 | host=repmgr_node3 dbname=repmgr user=repmgr |           |      100 | t
    (3 rows)

-* * *
-
-> *TIP*: under some circumstances when setting up a cascading replication
-> cluster, you may wish to clone a downstream standby whose upstream node
-> does not yet exist. In this case you can clone from the master (or
-> another upstream node) and provide the parameter `--upstream-conninfo`
-> to explictly set the upstream's `primary_conninfo` string in `recovery.conf`.
-
-* * *

 Using replication slots with repmgr
 -----------------------------------
@@ -920,19 +711,19 @@ Promote the first standby with:

 This will produce output similar to the following:

-    ERROR: connection to database failed: could not connect to server: Connection refused
+    [2016-01-08 16:07:31] [ERROR] connection to database failed: could not connect to server: Connection refused
            Is the server running on host "repmgr_node1" (192.161.2.1) and accepting
            TCP/IP connections on port 5432?
    could not connect to server: Connection refused
            Is the server running on host "repmgr_node1" (192.161.2.1) and accepting
            TCP/IP connections on port 5432?

-    NOTICE: promoting standby
-    NOTICE: promoting server using '/usr/bin/postgres/pg_ctl -D /path/to/node_2/data promote'
+    [2016-01-08 16:07:31] [NOTICE] promoting standby
+    [2016-01-08 16:07:31] [NOTICE] promoting server using '/usr/bin/postgres/pg_ctl -D /path/to/node_2/data promote'
    server promoting
-    NOTICE: STANDBY PROMOTE successful
+    [2016-01-08 16:07:33] [NOTICE] STANDBY PROMOTE successful

-Note: the first `ERROR` is `repmgr` attempting to connect to the current
+Note: the first `[ERROR]` is `repmgr` attempting to connect to the current
 master to verify that it has failed. If a valid master is found, `repmgr`
 will refuse to promote a standby.

@@ -964,7 +755,7 @@ end of the preceding section ("Promoting a standby server with repmgr"),
 execute this:

    $ repmgr -f /etc/repmgr.conf -D /path/to/node_3/data/ -h repmgr_node2 -U repmgr -d repmgr standby follow
-    NOTICE: restarting server using '/usr/bin/postgres/pg_ctl -D /path/to/node_3/data/ -w -m fast restart'
+    [2016-01-08 16:57:06] [NOTICE] restarting server using '/usr/bin/postgres/pg_ctl -D /path/to/node_3/data/ -w -m fast restart'
    waiting for server to shut down.... done
    server stopped
    waiting for server to start.... done
@@ -1011,13 +802,6 @@ both passwordless SSH access and the path of `repmgr.conf` on that server.
 > careful preparation and with adequate attention. In particular you should
 > be confident that your network environment is stable and reliable.
 >
-> Additionally you should be sure that the current master can be shut down
-> quickly and cleanly. In particular, access from applications should be
-> minimalized or preferably blocked completely. Also check that there is
-> no backlog of files waiting to be archived, as PostgreSQL will not shut
-> down until archiving completes, and that any standbys attached to the
-> current primary don't have a significant amount of replication lag.
->
 > We recommend running `repmgr standby switchover` at the most verbose
 > logging level (`--log-level DEBUG --verbose`) and capturing all output
 > to assist troubleshooting any problems.
@@ -1043,26 +827,26 @@ local server, as well as the normal default locations. `repmgr` will check
 this file can be found before performing any further actions.

    $ repmgr -f /etc/repmgr.conf -C /etc/repmgr.conf standby switchover -v
-    NOTICE: using configuration file "/etc/repmgr.conf"
-    NOTICE: switching current node 2 to master server and demoting current master to standby...
-    NOTICE: 5 files copied to /tmp/repmgr-node1-archive
-    NOTICE: connection to database failed: FATAL:  the database system is shutting down
+    [2016-01-27 16:38:33] [NOTICE] using configuration file "/etc/repmgr.conf"
+    [2016-01-27 16:38:33] [NOTICE] switching current node 2 to master server and demoting current master to standby...
+    [2016-01-27 16:38:34] [NOTICE] 5 files copied to /tmp/repmgr-node1-archive
+    [2016-01-27 16:38:34] [NOTICE] connection to database failed: FATAL:  the database system is shutting down

-    NOTICE: current master has been stopped
-    ERROR: connection to database failed: FATAL:  the database system is shutting down
+    [2016-01-27 16:38:34] [NOTICE] current master has been stopped
+    [2016-01-27 16:38:34] [ERROR] connection to database failed: FATAL:  the database system is shutting down

-    NOTICE: promoting standby
-    NOTICE: promoting server using '/usr/local/bin/pg_ctl -D /var/lib/postgresql/9.5/node_2/data promote'
+    [2016-01-27 16:38:34] [NOTICE] promoting standby
+    [2016-01-27 16:38:34] [NOTICE] promoting server using '/usr/local/bin/pg_ctl -D /var/lib/postgresql/9.5/node_2/data promote'
    server promoting
-    NOTICE: STANDBY PROMOTE successful
-    NOTICE: Executing pg_rewind on old master server
-    NOTICE: 5 files copied to /var/lib/postgresql/9.5/data
-    NOTICE: restarting server using '/usr/local/bin/pg_ctl -w -D /var/lib/postgresql/9.5/node_1/data -m fast restart'
+    [2016-01-27 16:38:36] [NOTICE] STANDBY PROMOTE successful
+    [2016-01-27 16:38:36] [NOTICE] Executing pg_rewind on old master server
+    [2016-01-27 16:38:36] [NOTICE] 5 files copied to /var/lib/postgresql/9.5/data
+    [2016-01-27 16:38:36] [NOTICE] restarting server using '/usr/local/bin/pg_ctl -w -D /var/lib/postgresql/9.5/node_1/data -m fast restart'
    pg_ctl: PID file "/var/lib/postgresql/9.5/node_1/data/postmaster.pid" does not exist
    Is server running?
    starting server anyway
-    NOTICE: node 1 is replicating in state "streaming"
-    NOTICE: switchover was successful
+    [2016-01-27 16:38:37] [NOTICE] node 1 is replicating in state "streaming"
+    [2016-01-27 16:38:37] [NOTICE] switchover was successful

 Messages containing the line `connection to database failed: FATAL: the database
 system is shutting down` are not errors - `repmgr` is polling the old master database
@@ -1084,11 +868,11 @@ should have been updated to reflect this:

 ### Caveats

- The functionality provided by `repmgr standby switchover` is primarily aimed
+- The functionality provided `repmgr standby switchover` is primarily aimed
  at a two-server master/standby replication cluster and currently does
  not support additional standbys.
 - `repmgr standby switchover` is designed to use the `pg_rewind` utility,
-  standard in 9.5 and later and available separately in 9.3 and 9.4
+  standard in 9.5 and later and available for seperately in 9.3 and 9.4
  (see note below)
 - `pg_rewind` *requires* that either `wal_log_hints` is enabled, or that
   data checksums were enabled when the cluster was initialized. See the
@@ -1098,6 +882,11 @@ should have been updated to reflect this:
  the `repmgrd` may try and promote a standby by itself.
 - Any other standbys attached to the old master will need to be manually
  instructed to point to the new master (e.g. with `repmgr standby follow`).
+- You must ensure that following a server start using `pg_ctl`, log output
+  is not send to STDERR (the default behaviour). If logging is not configured,
+  We recommend setting `logging_collector=on` in `postgresql.conf` and
+  providing an explicit `-l/--log` setting in `repmgr.conf`'s `pg_ctl_options`
+  parameter.

 We hope to remove some of these restrictions in future versions of `repmgr`.

@@ -1111,7 +900,7 @@ will have diverged slightly following the shutdown of the old master.

 The utility `pg_rewind` provides an efficient way of doing this, however
 is not included in the core PostgreSQL distribution for versions 9.3 and 9.4.
-However, `pg_rewind` is available separately for these versions and we
+Hoever, `pg_rewind` is available separately for these versions and we
 strongly recommend its installation. To use it with versions 9.3 and 9.4,
 provide the command line option `--pg_rewind`, optionally with the
 path to the `pg_rewind` binary location if not installed in the PostgreSQL
@@ -1120,10 +909,6 @@ path to the `pg_rewind` binary location if not installed in the PostgreSQL
 `pg_rewind` for versions 9.3 and 9.4 can be obtained from:
  https://github.com/vmware/pg_rewind

-Note that building this version of `pg_rewind` requires the PostgreSQL source
-code. Also, PostgreSQL 9.3 does not provide `wal_log_hints`, meaning data
-checksums must have been enabled when the database was initialized.
-
 If `pg_rewind` is not available, as a fallback `repmgr` will use `repmgr
 standby clone` to resynchronise the old master's data directory using
 `rsync`. However, in order to ensure all files are synchronised, the
@@ -1143,17 +928,16 @@ This will remove the standby record from `repmgr`'s internal metadata
 table (`repl_nodes`). A `standby_unregister` event notification will be
 recorded in the `repl_events` table.

-Note that this command will not stop the server itself or remove it from
-the replication cluster. Note that if the standby was using a replication
-slot, this will not be removed.
+Note that this command will not stop the server itself or remove
+it from the replication cluster.

-If the standby is not running, the command can be executed on another
-node by providing the id of the node to be unregistered using
-the command line parameter `--node`, e.g. executing the following
-command on the master server will unregister the standby with
-id 3:
+If the standby is not running, the standby record must be manually
+removed from the `repl_nodes` table with e.g.:

-    repmgr standby unregister -f /etc/repmgr.conf --node=3
+    DELETE FROM repmgr_test.repl_nodes WHERE id = 3;
+
+Adjust schema and node ID accordingly. A future `repmgr` release
+will make it possible to unregister failed standbys.


 Automatic failover with `repmgrd`
@@ -1163,22 +947,18 @@ Automatic failover with `repmgrd`
 and which can automate actions such as failover and updating standbys to
 follow the new master.

-To use `repmgrd` for automatic failover, `postgresql.conf` must contain the
-following line:
-
-    shared_preload_libraries = 'repmgr_funcs'
-
-(changing this setting requires a restart of PostgreSQL).
-
-Additionally the following `repmgrd` options must be set in `repmgr.conf`:
+To use `repmgrd` for automatic failover, the following `repmgrd` options must
+be set in `repmgr.conf`:

    failover=automatic
-    promote_command='repmgr standby promote -f /etc/repmgr.conf --log-to-file'
-    follow_command='repmgr standby follow -f /etc/repmgr.conf --log-to-file'
+    promote_command='repmgr standby promote -f /etc/repmgr/repmgr.conf'
+    follow_command='repmgr standby follow -f /etc/repmgr/repmgr.conf'

-Note that the `--log-to-file` option will cause `repmgr`'s output to be logged to
-the destination configured to receive log output for `repmgrd`.
-See `repmgr.conf.sample` for further `repmgrd`-specific settings
+(See `repmgr.conf.sample` for further `repmgrd`-specific settings).
+
+Additionally, `postgresql.conf` must contain the following line:
+
+    shared_preload_libraries = 'repmgr_funcs'

 When `failover` is set to `automatic`, upon detecting failure of the current
 master, `repmgrd` will execute one of `promote_command` or `follow_command`,
@@ -1460,8 +1240,7 @@ The following event types are available:
  * `standby_switchover`
  * `standby_disconnect_manual`
  * `witness_create`
-  * `witness_register`
-  * `witness_unregister`
+  * `witness_create`
  * `repmgrd_start`
  * `repmgrd_shutdown`
  * `repmgrd_failover_promote`
@@ -1481,45 +1260,7 @@ functionality will be included in a feature release (e.g. 3.0.x to 3.1.x).

 In general `repmgr` can be upgraded as-is without any further action required,
 however feature releases may require the `repmgr` database to be upgraded.
-An SQL script will be provided - please check the release notes for details:
-
-* http://repmgr.org/release-notes-3.3.html#UPGRADING
-
-
-Distribution-specific configuration
-----------------------------------
-
-`repmgr` is largely OS-agnostic and can be run on any UNIX-like environment
-including various Linux distributions, Solaris, macOS and the various BSDs.
-
-However, often OS-specific configuration is required, particularly when
-dealing with system service management (e.g. stopping and starting the
-PostgreSQL server), file paths and configuration file locations.
-
-### PostgreSQL server control
-
-By default, `repmgr` will use PostgreSQL's standard `pg_ctl` utility to control
-a running PostgreSQL server. However it may be better to use the operating
-system's service management system, e.g. `systemd`. To specify which service
-control commands are used, the following `repmgr.conf` configuration settings
-are available:
-
-    service_start_command
-    service_stop_command
-    service_restart_command
-    service_reload_command
-    service_promote_command
-
-See `repmgr.conf.sample` for further details.
-
-### Binary directory
-
-Some PostgreSQL system packages, such as those provided for Debian/Ubuntu, like
-to hide some PostgreSQL utility programs outside of the default path. To ensure
-`repmgr` finds all required executables, explicitly set `pg_bindir` to the
-appropriate location, e.g. for PostgreSQL 9.6 on Debian/Ubuntu this would be
-`/usr/lib/postgresql/9.6/bin/`.
-
+An SQL script will be provided - please check the release notes for details.

 Reference
 ---------
@@ -1586,7 +1327,7 @@ which contains connection details for the local database.
    bootstrapping new installations. To update an existing but 'stale'
    data directory (for example belonging to a failed master), `rsync`
    must be used by specifying `--rsync-only`. In this case,
-    passwordless SSH connections between servers are required.
+    password-less SSH connections between servers are required.

 * `standby promote`

@@ -1600,13 +1341,13 @@ which contains connection details for the local database.
    by using `standby follow` (see below); if `repmgrd` is active, it will
    handle this.

-    This command will fail with an error if the current master is still running.
+    This command will not function if the current master is still running.

 * `standby switchover`

    Promotes a standby to master and demotes the existing master to a standby.
    This command must be run on the standby to be promoted, and requires a
-    passwordless SSH connection to the current master. Additionally the
+    password-less SSH connection to the current master. Additionally the
    location of the master's `repmgr.conf` file must be provided with
    `-C/--remote-config-file`.

@@ -1627,7 +1368,7 @@ which contains connection details for the local database.

    Creates a witness server as a separate PostgreSQL instance. This instance
    can be on a separate server or a server running an existing node. The
-    witness server contains a copy of the repmgr metadata tables but will not
+    witness server contain a copy of the repmgr metadata tables but will not
    be set up as a standby; instead it will update its metadata copy each
    time a failover occurs.

@@ -1644,31 +1385,17 @@ which contains connection details for the local database.

    This command also requires the location of the witness server's data
    directory to be provided (`-D/--datadir`) as well as valid connection
-    parameters for the master server. If not explicitly provided,
-    database and user names will be extracted from the `conninfo` string in
-    `repmgr.conf`.
+    parameters for the master server.

    By default this command will create a superuser and a repmgr user.
    The `repmgr` user name will be extracted from the `conninfo` string
    in `repmgr.conf`.

-* `witness register`
-
-    This will set up the witness server configuration, including the witness
-    server's copy of the `repmgr` meta database, on a running PostgreSQL
-    instance and register the witness server with the master. It requires
-    the same command line options as `witness create`.
-
-* `witness unregister`
-
-    Removes the entry for a witness server from the `repl_nodes` table. This
-    command will not shut down the witness server or remove its data directory.
-
 * `cluster show`

    Displays information about each active node in the replication cluster. This
-    command polls each registered server and shows its role (`master` / `standby` /
-    `witness`) or `FAILED` if the node doesn't respond. It polls each server
+    command polls each registered server and shows its role (master / standby /
+    witness) or `FAILED` if the node doesn't respond. It polls each server
    directly and can be run on any node in the cluster; this is also useful
    when analyzing connectivity from a particular node.

@@ -1698,102 +1425,7 @@ which contains connection details for the local database.
        3,1

    The first column is the node's ID, and the second column represents the
-    node's status (0 = available, -1 = failed).
-
-* `cluster matrix` and `cluster crosscheck`
-
-    These commands display connection information for each pair of
-    nodes in the replication cluster.
-
-    - `cluster matrix` runs a `cluster show` on each node and arranges
-      the results in a matrix, recording success or failure;
-
-    - `cluster crosscheck` runs a `cluster matrix` on each node and
-      combines the results in a single matrix, providing a full
-      overview of connections between all databases in the cluster.
-
-    These commands require a valid `repmgr.conf` file on each node.
-    Additionally passwordless `ssh` connections are required between
-    all nodes.
-
-    Example 1 (all nodes up):
-
-        $ repmgr -f /etc/repmgr.conf cluster matrix
-
-        Name   | Id |  1 |  2 |  3
-        -------+----+----+----+----
-         node1 |  1 |  * |  * |  *
-         node2 |  2 |  * |  * |  *
-         node3 |  3 |  * |  * |  *
-
-    Here `cluster matrix` is sufficient to establish the state of each
-    possible connection.
-
-
-    Example 2 (node1 and `node2` up, `node3` down):
-
-        $ repmgr -f /etc/repmgr.conf cluster matrix
-
-        Name   | Id |  1 |  2 |  3
-        -------+----+----+----+----
-         node1 |  1 |  * |  * |  x
-         node2 |  2 |  * |  * |  x
-         node3 |  3 |  ? |  ? |  ?
-
-    Each row corresponds to one server, and indicates the result of
-    testing an outbound connection from that server.
-
-    Since `node3` is down, all the entries in its row are filled with
-    "?", meaning that there we cannot test outbound connections.
-
-    The other two nodes are up; the corresponding rows have "x" in the
-    column corresponding to node3, meaning that inbound connections to
-    that node have failed, and "*" in the columns corresponding to
-    node1 and node2, meaning that inbound connections to these nodes
-    have succeeded.
-
-    In this case, `cluster crosscheck` gives the same result as `cluster
-    matrix`, because from any functioning node we can observe the same
-    state: `node1` and `node2` are up, `node3` is down.
-
-    Example 3 (all nodes up, firewall dropping packets originating
-               from `node1` and directed to port 5432 on node3)
-
-    Running `cluster matrix` from `node1` gives the following output:
-
-        $ repmgr -f /etc/repmgr.conf cluster matrix
-
-        Name   | Id |  1 |  2 |  3
-        -------+----+----+----+----
-         node1 |  1 |  * |  * |  x
-         node2 |  2 |  * |  * |  *
-         node3 |  3 |  ? |  ? |  ?
-
-    (Note this may take some time depending on the `connect_timeout`
-    setting in the registered node `conninfo` strings; default is 1
-    minute which means without modification the above command would
-    take around 2 minutes to run; see comment elsewhere about setting
-    `connect_timeout`)
-
-    The matrix tells us that we cannot connect from `node1` to `node3`,
-    and that (therefore) we don't know the state of any outbound
-    connection from node3.
-
-    In this case, the `cluster crosscheck` command is more informative:
-
-        $ repmgr -f /etc/repmgr.conf cluster crosscheck
-
-        Name   | Id |  1 |  2 |  3
-        -------+----+----+----+----
-         node1 |  1 |  * |  * |  x
-         node2 |  2 |  * |  * |  *
-         node3 |  3 |  * |  * |  *
-
-    What happened is that `cluster crosscheck` merged its own `cluster
-    matrix` with the `cluster matrix` output from `node2`; the latter is
-    able to connect to `node3` and therefore determine the state of
-    outbound connections from that node.
-
+    node's status (0 = master, 1 = standby, -1 = failed).

 * `cluster cleanup`

@@ -1807,45 +1439,27 @@ which contains connection details for the local database.
    the current working directory; no additional arguments are required.


-### Further documentation
-
-As well as this README, the `repmgr` source contains following additional
-documentation files:
-
-* FAQ.md - frequently asked questions
-* CONTRIBUTING.md - how to contribute to `repmgr`
-* PACKAGES.md - details on building packages
-* SSH-RSYNC.md - how to set up passwordless SSH between nodes
-* docs/repmgrd-failover-mechanism.md - how repmgrd picks which node to promote
-* docs/repmgrd-node-fencing.md - how to "fence" a failed master node
-
-
-
-
 ### Error codes

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

-* SUCCESS (0)                Program ran successfully.
-* ERR_BAD_CONFIG (1)         Configuration file could not be parsed or was invalid
-* ERR_BAD_RSYNC (2)          An rsync call made by the program returned an error
-                               (repmgr only)
-* ERR_NO_RESTART (4)         An attempt to restart a PostgreSQL instance failed
-* ERR_DB_CON (6)             Error when trying to connect to a database
-* ERR_DB_QUERY (7)           Error while executing a database query
-* ERR_PROMOTED (8)           Exiting program because the node has been promoted to master
-* ERR_STR_OVERFLOW (10)      String overflow error
-* ERR_FAILOVER_FAIL (11)     Error encountered during failover (repmgrd only)
-* ERR_BAD_SSH (12)           Error when connecting to remote host via SSH (repmgr only)
-* ERR_SYS_FAILURE (13)       Error when forking (repmgrd only)
-* ERR_BAD_BASEBACKUP (14)    Error when executing pg_basebackup (repmgr only)
-* ERR_MONITORING_FAIL (16)   Unrecoverable error encountered during monitoring (repmgrd only)
-* ERR_BAD_BACKUP_LABEL (17)  Corrupt or unreadable backup label encountered (repmgr only)
-* ERR_SWITCHOVER_FAIL (18)   Error encountered during switchover (repmgr only)
-* ERR_BARMAN (19)            Unrecoverable error while accessing the barman server (repmgr only)
-* ERR_REGISTRATION_SYNC (20) After registering a standby, local node record was not
-                                syncrhonised (repmgr only, with --wait option)
+* SUCCESS (0)               Program ran successfully.
+* ERR_BAD_CONFIG (1)        Configuration file could not be parsed or was invalid
+* ERR_BAD_RSYNC (2)         An rsync call made by the program returned an error (repmgr only)
+* ERR_NO_RESTART (4)        An attempt to restart a PostgreSQL instance failed
+* ERR_DB_CON (6)            Error when trying to connect to a database
+* ERR_DB_QUERY (7)          Error while executing a database query
+* ERR_PROMOTED (8)          Exiting program because the node has been promoted to master
+* ERR_STR_OVERFLOW (10)     String overflow error
+* ERR_FAILOVER_FAIL (11)    Error encountered during failover (repmgrd only)
+* ERR_BAD_SSH (12)          Error when connecting to remote host via SSH (repmgr only)
+* ERR_SYS_FAILURE (13)      Error when forking (repmgrd only)
+* ERR_BAD_BASEBACKUP (14)   Error when executing pg_basebackup (repmgr only)
+* ERR_MONITORING_FAIL (16)  Unrecoverable error encountered during monitoring (repmgrd only)
+* ERR_BAD_BACKUP_LABEL (17) Corrupt or unreadable backup label encountered (repmgr only)
+* ERR_SWITCHOVER_FAIL (18)  Error encountered during switchover (repmgr only)
+

 Support and Assistance
 ----------------------
@@ -1891,7 +1505,6 @@ Thanks from the repmgr core team.
 Further reading
 ---------------

-* http://blog.2ndquadrant.com/repmgr-3-2-is-here-barman-support-brand-new-high-availability-features/
 * http://blog.2ndquadrant.com/improvements-in-repmgr-3-1-4/
 * http://blog.2ndquadrant.com/managing-useful-clusters-repmgr/
 * http://blog.2ndquadrant.com/easier_postgresql_90_clusters/
--- a/check_dir.c
+++ b/check_dir.c
@@ -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
--- a/check_dir.h
+++ b/check_dir.h
@@ -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
--- a/compat.c
+++ b/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, '\'');
-}
-
--- a/compat.h
+++ b/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
--- a/config.c
+++ b/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,10 +26,10 @@

 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] = "";
+static char config_file_path[MAXPGPATH];
 static bool config_file_provided = false;
 bool config_file_found = false;

@@ -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,18 @@ _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->stop_command, 0, sizeof(options->stop_command));
+	memset(options->start_command, 0, sizeof(options->start_command));
+	memset(options->restart_command, 0, sizeof(options->restart_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 +257,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 +302,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 +333,35 @@ _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, "stop_command") == 0)
+			strncpy(options->stop_command, value, MAXLEN);
+		else if (strcmp(name, "start_command") == 0)
+			strncpy(options->start_command, value, MAXLEN);
+		else if (strcmp(name, "restart_command") == 0)
+			strncpy(options->restart_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 +371,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 +406,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 +415,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 +439,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 +540,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 +620,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 +648,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 +655,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 +669,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 +721,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 +749,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 +770,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 +782,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 +804,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 +853,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 +936,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 +995,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);
--- a/config.h
+++ b/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,14 @@ 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		stop_command[MAXLEN];
+	char		start_command[MAXLEN];
+	char		restart_command[MAXLEN];
 	char		loglevel[MAXLEN];
 	char		logfacility[MAXLEN];
 	char		rsync_options[QUERY_STR_LEN];
@@ -97,51 +90,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
--- a/dbutils.c
+++ b/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,15 +32,6 @@ 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)
@@ -86,19 +76,6 @@ _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;
 }

@@ -138,12 +115,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 +129,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 +213,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 +278,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)
@@ -428,8 +380,6 @@ int
 get_server_version(PGconn *conn, char *server_version)
 {
 	PGresult   *res;
-	int         server_version_num;
-
 	res = PQexec(conn,
 				 "SELECT current_setting('server_version_num'), "
 				 "       current_setting('server_version')");
@@ -443,12 +393,9 @@ get_server_version(PGconn *conn, char *server_version)
 	}

 	if (server_version != NULL)
-		strcpy(server_version, PQgetvalue(res, 0, 1));
+		strcpy(server_version, PQgetvalue(res, 0, 0));

-	server_version_num = atoi(PQgetvalue(res, 0, 0));
-
-	PQclear(res);
-	return server_version_num;
+	return atoi(PQgetvalue(res, 0, 0));
 }


@@ -461,7 +408,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);

@@ -497,7 +444,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);

@@ -529,7 +476,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);

@@ -556,11 +503,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);
@@ -997,7 +944,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;
@@ -1016,9 +963,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;
 		}

@@ -1030,9 +976,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;
 	}

@@ -1040,26 +985,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;
 	}
@@ -1077,7 +1021,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);

@@ -1137,25 +1081,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);

@@ -1183,19 +1117,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)
@@ -1220,12 +1147,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)
@@ -1240,36 +1174,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()
@@ -1319,8 +1223,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);
@@ -1434,8 +1337,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,
@@ -1529,11 +1431,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)
 	{
@@ -1582,6 +1483,7 @@ create_event_record(PGconn *conn, t_configuration_options *options, int node_id,
 						PQerrorMessage(conn));

 			success = false;
+
 		}
 		else
 		{
@@ -1721,110 +1623,6 @@ create_event_record(PGconn *conn, t_configuration_options *options, int node_id,
 	return success;
 }

-void
-create_checkpoint(PGconn *conn)
-{
-	char		sqlquery[MAXLEN];
-	PGresult   *res;
-
-	sqlquery_snprintf(sqlquery, "CHECKPOINT");
-	log_verbose(LOG_DEBUG, "checkpoint:\n%s\n", sqlquery);
-
-	res = PQexec(conn, sqlquery);
-	if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
-	{
-		log_err(_("Unable to create CHECKPOINT:\n%s\n"),
-				PQerrorMessage(conn));
-		PQfinish(conn);
-		exit(ERR_DB_QUERY);
-	}
-
-	log_notice(_("CHECKPOINT created\n"));
-}
-
-
-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
@@ -1915,8 +1713,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",
@@ -1986,16 +1783,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);
--- a/dbutils.h
+++ b/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,7 +77,7 @@ 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,
@@ -119,25 +117,23 @@ 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);
-void        create_checkpoint(PGconn *conn);

 int		    get_node_replication_state(PGconn *conn, char *node_name, char *output);
 t_server_type parse_node_type(const char *type);
 int			get_data_checksum_version(const char *data_directory);
 #endif
+
--- a/debian/DEBIAN/control
+++ b/debian/DEBIAN/control
@@ -1,5 +1,5 @@
 Package: repmgr-auto
-Version: 3.2dev
+Version: 3.1.3
 Section: database
 Priority: optional
 Architecture: all
--- a/dirmod.c
+++ b/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
--- a/dirmod.h
+++ b/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
--- a/docs/repmgrd-failover-mechanism.md
+++ b/docs/repmgrd-failover-mechanism.md
@@ -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.
-
-
-
-
--- a/docs/repmgrd-node-fencing.md
+++ b/docs/repmgrd-node-fencing.md
@@ -1,160 +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`.
-
-* * *
-
-> *NOTE*: in this self-contained demonstration, `pgbouncer` is running on the
-> database servers, however in a production environment it will make more
-> sense to run `pgbouncer` on either separate nodes or the application server.
-
-* * *
-
-`/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.
--- a/errcode.h
+++ b/errcode.h
@@ -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_ */
--- a/expected/repmgr_funcs.out
+++ b/expected/repmgr_funcs.out
@@ -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;
--- a/expected/repmgr_test.out
+++ b/expected/repmgr_test.out
@@ -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)
-
--- a/log.c
+++ b/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, ...)
 {
@@ -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)
 		{
--- a/log.h
+++ b/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, ...)
@@ -137,6 +132,5 @@ 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_ */
--- a/repmgr.c
+++ b/repmgr.c
--- a/repmgr.conf.sample
+++ b/repmgr.conf.sample
@@ -26,15 +26,12 @@
                 # the server's hostname or another identifier unambiguously
                 # associated with the server to avoid confusion

-# Database connection information as a conninfo string (this must be a
-# keyword/value string, not a connection URI).
+# Database connection information as a conninfo string
+# This must be accessible to all servers in the cluster; for details see:
 #
 #   https://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING
 #
-# All servers in the cluster must be able to access the database
-# using this connection string.
-#
-#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
@@ -69,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
@@ -109,14 +100,11 @@
 # 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
+# repmgr provides options to to override the default pg_ctl commands
+# used to stop, start  and restart the PostgreSQL cluster
 #
 # NOTE: These commands must be runnable on remote nodes as well for switchover
 # to function correctly.
@@ -132,11 +120,9 @@
 #       /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
+# start_command = systemctl start postgresql-9.5
+# stop_command = systemctl stop postgresql-9.5
+# restart_command = systemctl restart postgresql-9.5

 # external command options

@@ -146,15 +132,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
 # ----------------------
@@ -176,11 +155,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
@@ -205,6 +182,9 @@
 #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'
--- a/repmgr.h
+++ b/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,64 @@
 #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_IGNORE_EXTERNAL_CONFIG_FILES 4
 #define OPT_CONFIG_ARCHIVE_DIR           5
 #define OPT_PG_REWIND                    6
+#define OPT_PWPROMPT                     7
 #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
+#define OPT_INITDB_NO_PWPROMPT           9


 /* 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];
 }	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, "", "", ""}

 struct BackupLabel
 {
@@ -187,61 +118,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
--- a/repmgr.sql
+++ b/repmgr.sql
@@ -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;
--- a/repmgrd.c
+++ b/repmgrd.c
@@ -1,7 +1,6 @@
 /*
 * repmgrd.c - Replication manager daemon
- *
- * Copyright (c) 2ndQuadrant, 2010-2017
+ * Copyright (C) 2ndQuadrant, 2010-2016
 *
 * This module connects to the nodes of a replication cluster and monitors
 * how far are they from master
@@ -30,10 +29,18 @@
 #include <stdlib.h>
 #include <unistd.h>

+
+
 #include "repmgr.h"
+#include "config.h"
 #include "log.h"
+#include "strutil.h"
 #include "version.h"

+/* Required PostgreSQL headers */
+#include "access/xlogdefs.h"
+#include "pqexpbuffer.h"
+
 /* Message strings passed in repmgrSharedState->location */

 #define PASSIVE_NODE "PASSIVE_NODE"
@@ -63,7 +70,6 @@ bool		failover_done = false;
 bool		manual_mode_upstream_disconnected = false;

 char	   *pid_file = NULL;
-int			server_version_num = 0;

 static void help(void);
 static void usage(void);
@@ -104,15 +110,17 @@ static void check_and_create_pid_file(const char *pid_file);
 static void
 close_connections()
 {
-	if (PQstatus(master_conn) == CONNECTION_OK && PQisBusy(master_conn) == 1)
+	if (master_conn != NULL && PQisBusy(master_conn) == 1)
 		cancel_query(master_conn, local_options.master_response_timeout);

-
-	if (PQstatus(my_local_conn) == CONNECTION_OK)
+	if (my_local_conn != NULL)
 		PQfinish(my_local_conn);

-	if (PQstatus(master_conn) == CONNECTION_OK)
+	if (master_conn != NULL && master_conn != my_local_conn)
 		PQfinish(master_conn);
+
+	master_conn = NULL;
+	my_local_conn = NULL;
 }


@@ -138,6 +146,8 @@ main(int argc, char **argv)

 	FILE	   *fd;

+	int			server_version_num = 0;
+
 	set_progname(argv[0]);

 	/* Disallow running as root to prevent directory ownership problems */
@@ -198,13 +208,6 @@ main(int argc, char **argv)
 		}
 	}

-
-	/*
-	 * Tell the logger we're a daemon - this will ensure any output logged
-	 * before the logger is initialized will be formatted correctly
-	 */
-	logger_output_mode = OM_DAEMON;
-
 	/*
 	 * Parse the configuration file, if provided. If no configuration file
 	 * was provided, or one was but was incomplete, parse_config() will
@@ -245,7 +248,6 @@ main(int argc, char **argv)
 	}

 	logger_init(&local_options, progname());
-
 	if (verbose)
 		logger_set_verbose();

@@ -310,46 +312,10 @@ main(int argc, char **argv)

 	log_debug("node id is %i, upstream is %i\n", node_info.node_id, node_info.upstream_node_id);

-    /*
-     * Check if node record is active - if not, and `failover=automatic`, the node
-     * won't be considered as a promotion candidate; this often happens when
-     * a failed primary is recloned and the node was not re-registered, giving
-     * the impression failover capability is there when it's not. In this case
-     * abort with an error and a hint about registering.
-     *
-     * If `failover=manual`, repmgrd can continue to passively monitor the node, but
-     * we should nevertheless issue a warning and the same hint.
-     */
-
-    if (node_info.active == false)
-    {
-        char *hint = "Check that 'repmgr (master|standby) register' was executed for this node";
-
-        switch (local_options.failover)
-        {
-            case AUTOMATIC_FAILOVER:
-                log_err(_("This node is marked as inactive and cannot be used for failover\n"));
-                log_hint(_("%s\n"), hint);
-                terminate(ERR_BAD_CONFIG);
-
-            case MANUAL_FAILOVER:
-                log_warning(_("This node is marked as inactive and will be passively monitored only\n"));
-                log_hint(_("%s\n"), hint);
-                break;
-
-            default:
-                /* This should never happen */
-                log_err(_("Unknown failover mode %i\n"), local_options.failover);
-                terminate(ERR_BAD_CONFIG);
-        }
-
-    }
-
 	/*
 	 * MAIN LOOP This loops cycles at startup and once per failover and
-	 * Requisites:
-	 *  - my_local_conn must have an active connection to the monitored node
-	 *  - master_conn must not be open
+	 * Requisites: - my_local_conn needs to be already setted with an active
+	 * connection - no master connection
 	 */
 	do
 	{
@@ -461,7 +427,7 @@ main(int argc, char **argv)
 													local_options.cluster_name,
 													&master_options.node, NULL);

-				if (PQstatus(master_conn) != CONNECTION_OK)
+				if (master_conn == NULL)
 				{
 					PQExpBufferData errmsg;
 					initPQExpBuffer(&errmsg);
@@ -646,15 +612,15 @@ witness_monitor(void)
 			}
 			else
 			{
-				log_info(_("new master found with node ID: %i\n"), master_options.node);
+				log_debug(_("new master found with node ID: %i\n"), master_options.node);
 				connection_ok = true;

 				/*
 				 * Update the repl_nodes table from the new master to reflect the changed
 				 * node configuration
 				 *
-				 * It would be neat to be able to handle this with e.g. table-based
-				 * logical replication if available in core
+				 * XXX it would be neat to be able to handle this with e.g. table-based
+				 * logical replication
 				 */
 				witness_copy_node_records(master_conn, my_local_conn, local_options.cluster_name);

@@ -709,46 +675,26 @@ witness_monitor(void)
 		return;
 	}

-	strncpy(monitor_witness_timestamp, PQgetvalue(res, 0, 0), MAXLEN);
+	strcpy(monitor_witness_timestamp, PQgetvalue(res, 0, 0));
 	PQclear(res);

 	/*
 	 * Build the SQL to execute on master
 	 */
-	if (server_version_num >= 100000)
-	{
-		sqlquery_snprintf(sqlquery,
-						  "INSERT INTO %s.repl_monitor "
-						  "           (primary_node, standby_node, "
-						  "            last_monitor_time, last_apply_time, "
-						  "            last_wal_primary_location, last_wal_standby_location, "
-						  "            replication_lag, apply_lag )"
-						  "      VALUES(%d, %d, "
-						  "             '%s'::TIMESTAMP WITH TIME ZONE, NULL, "
-						  "             pg_catalog.pg_current_wal_lsn(), NULL, "
-						  "             0, 0) ",
-						  get_repmgr_schema_quoted(my_local_conn),
-						  master_options.node,
-						  local_options.node,
-						  monitor_witness_timestamp);
-	}
-	else
-	{
-		sqlquery_snprintf(sqlquery,
-						  "INSERT INTO %s.repl_monitor "
-						  "           (primary_node, standby_node, "
-						  "            last_monitor_time, last_apply_time, "
-						  "            last_wal_primary_location, last_wal_standby_location, "
-						  "            replication_lag, apply_lag )"
-						  "      VALUES(%d, %d, "
-						  "             '%s'::TIMESTAMP WITH TIME ZONE, NULL, "
-						  "             pg_catalog.pg_current_xlog_location(), NULL, "
-						  "             0, 0) ",
-						  get_repmgr_schema_quoted(my_local_conn),
-						  master_options.node,
-						  local_options.node,
-						  monitor_witness_timestamp);
-	}
+	sqlquery_snprintf(sqlquery,
+					  "INSERT INTO %s.repl_monitor "
+					  "           (primary_node, standby_node, "
+					  "            last_monitor_time, last_apply_time, "
+					  "            last_wal_primary_location, last_wal_standby_location, "
+					  "            replication_lag, apply_lag )"
+					  "      VALUES(%d, %d, "
+					  "             '%s'::TIMESTAMP WITH TIME ZONE, NULL, "
+					  "             pg_catalog.pg_current_xlog_location(), NULL, "
+					  "             0, 0) ",
+					  get_repmgr_schema_quoted(my_local_conn),
+					  master_options.node,
+					  local_options.node,
+					  monitor_witness_timestamp);

 	/*
 	 * Execute the query asynchronously, but don't check for a result. We will
@@ -770,14 +716,13 @@ static void
 standby_monitor(void)
 {
 	PGresult   *res;
-	char		sqlquery[QUERY_STR_LEN];
-
 	char		monitor_standby_timestamp[MAXLEN];
 	char		last_wal_primary_location[MAXLEN];
 	char		last_xlog_receive_location[MAXLEN];
 	char		last_xlog_replay_location[MAXLEN];
 	char		last_xact_replay_timestamp[MAXLEN];
-	bool		receiving_streamed_wal = true;
+	bool		last_xlog_receive_location_gte_replayed;
+	char		sqlquery[QUERY_STR_LEN];

 	XLogRecPtr	lsn_master_current_xlog_location;
 	XLogRecPtr	lsn_last_xlog_receive_location;
@@ -793,10 +738,12 @@ standby_monitor(void)
 	PGconn	   *upstream_conn;
 	char		upstream_conninfo[MAXCONNINFO];
 	int			upstream_node_id;
+	t_node_info upstream_node;

 	int			active_master_id;
 	const char *upstream_node_type = NULL;

+	bool		receiving_streamed_wal = true;


 	/*
@@ -850,12 +797,13 @@ standby_monitor(void)
 	/*
 	 * Check that the upstream node is still available
 	 * If not, initiate failover process
-	 *
-	 * This takes up to local_options.reconnect_attempts *
-	 * local_options.reconnect_interval seconds
 	 */

 	check_connection(&upstream_conn, upstream_node_type, upstream_conninfo);
+	/*
+	 * This takes up to local_options.reconnect_attempts *
+	 * local_options.reconnect_interval seconds
+	 */

 	if (PQstatus(upstream_conn) != CONNECTION_OK)
 	{
@@ -974,8 +922,6 @@ standby_monitor(void)
 			 * Failover handling is handled differently depending on whether
 			 * the failed node is the master or a cascading standby
 			 */
-			t_node_info upstream_node;
-
 			upstream_node = get_node_info(my_local_conn, local_options.cluster_name, upstream_node_id);

 			if (upstream_node.type == MASTER)
@@ -1033,8 +979,8 @@ standby_monitor(void)
 				 *
 				 * We should log a message so the user knows of the situation at hand.
 				 *
-				 * XXX check if the original master is still active and display a warning
-				 * XXX add event notification
+				 * XXX check if the original master is still active and display a
+				 * warning
 				 */
 				log_err(_("It seems this server was promoted manually (not by repmgr) so you might by in the presence of a split-brain.\n"));
 				log_err(_("Check your cluster and manually fix any anomaly.\n"));
@@ -1079,6 +1025,9 @@ standby_monitor(void)
 	 * from the upstream node to write monitoring information
 	 */

+	/* XXX not used? */
+	upstream_node = get_node_info(my_local_conn, local_options.cluster_name, upstream_node_id);
+
 	sprintf(sqlquery,
 			"SELECT id "
 			"  FROM %s.repl_nodes "
@@ -1130,48 +1079,19 @@ standby_monitor(void)
 	if (wait_connection_availability(master_conn, local_options.master_response_timeout) != 1)
 		return;

-	/* Get local xlog info
-	 *
-	 * If receive_location is NULL, we're in archive recovery and not streaming WAL
-	 * If receive_location is less than replay location, we were streaming WAL but are
-	 *   somehow disconnected and evidently in archive recovery
-	 */
+	/* Get local xlog info */

-	if (server_version_num >= 100000)
-	{
-		sqlquery_snprintf(sqlquery,
-						  " SELECT ts, "
-						  "        CASE WHEN (receive_location IS NULL OR receive_location < replay_location) "
-						  "          THEN replay_location "
-						  "          ELSE receive_location"
-						  "        END AS receive_location,"
-						  "        replay_location, "
-						  "        replay_timestamp, "
-						  "        COALESCE(receive_location, '0/0') >= replay_location AS receiving_streamed_wal "
-						  "   FROM (SELECT CURRENT_TIMESTAMP AS ts, "
-						  "         pg_catalog.pg_last_wal_receive_lsn()  AS receive_location, "
-						  "         pg_catalog.pg_last_wal_replay_lsn()   AS replay_location, "
-						  "         pg_catalog.pg_last_xact_replay_timestamp() AS replay_timestamp "
-						  "        ) q ");
-
-	}
-	else
-	{
-		sqlquery_snprintf(sqlquery,
-						  " SELECT ts, "
-						  "        CASE WHEN (receive_location IS NULL OR receive_location < replay_location) "
-						  "          THEN replay_location "
-						  "          ELSE receive_location"
-						  "        END AS receive_location,"
-						  "        replay_location, "
-						  "        replay_timestamp, "
-						  "        COALESCE(receive_location, '0/0') >= replay_location AS receiving_streamed_wal "
-						  "   FROM (SELECT CURRENT_TIMESTAMP AS ts, "
-						  "         pg_catalog.pg_last_xlog_receive_location() AS receive_location, "
-						  "         pg_catalog.pg_last_xlog_replay_location()  AS replay_location, "
-						  "         pg_catalog.pg_last_xact_replay_timestamp() AS replay_timestamp "
-						  "        ) q ");
-	}
+	sqlquery_snprintf(sqlquery,
+					  " SELECT ts, "
+					  "        receive_location, "
+					  "        replay_location, "
+					  "        replay_timestamp, "
+					  "        receive_location >= replay_location "
+					  "   FROM (SELECT CURRENT_TIMESTAMP AS ts, "
+					  "         pg_catalog.pg_last_xlog_receive_location() AS receive_location, "
+					  "         pg_catalog.pg_last_xlog_replay_location()  AS replay_location, "
+					  "         pg_catalog.pg_last_xact_replay_timestamp() AS replay_timestamp "
+					  "        ) q ");


 	res = PQexec(my_local_conn, sqlquery);
@@ -1183,33 +1103,52 @@ standby_monitor(void)
 		return;
 	}

-	strncpy(monitor_standby_timestamp,  PQgetvalue(res, 0, 0), MAXLEN);
+	strncpy(monitor_standby_timestamp, PQgetvalue(res, 0, 0), MAXLEN);
 	strncpy(last_xlog_receive_location, PQgetvalue(res, 0, 1), MAXLEN);
-	strncpy(last_xlog_replay_location,  PQgetvalue(res, 0, 2), MAXLEN);
+	strncpy(last_xlog_replay_location, PQgetvalue(res, 0, 2), MAXLEN);
 	strncpy(last_xact_replay_timestamp, PQgetvalue(res, 0, 3), MAXLEN);

-	receiving_streamed_wal = (strcmp(PQgetvalue(res, 0, 4), "t") == 0)
+	last_xlog_receive_location_gte_replayed = (strcmp(PQgetvalue(res, 0, 4), "t") == 0)
 		? true
 		: false;

-	if (receiving_streamed_wal == false)
+	/*
+	 * If pg_last_xlog_receive_location is NULL, this means we're in archive
+	 * recovery and will need to calculate lag based on pg_last_xlog_replay_location
+	 */
+
+	/*
+	 * Replayed WAL is greater than received streamed WAL
+	 */
+	if (PQgetisnull(res, 0, 1))
 	{
-		log_verbose(LOG_DEBUG, _("standby %i not connected to streaming replication"), local_options.node);
+		receiving_streamed_wal = false;
 	}

 	PQclear(res);

+	/*
+	 * In the unusual event of a standby becoming disconnected from the primary,
+	 * while this repmgrd remains connected to the primary,  subtracting
+	 * "last_xlog_replay_location" from "lsn_last_xlog_receive_location" and coercing to
+	 * (long long unsigned int) will result in a meaningless, very large
+	 * value which will overflow a BIGINT column and spew error messages into the
+	 * PostgreSQL log. In the absence of a better strategy, skip attempting
+	 * to insert a monitoring record.
+	 */
+	if (receiving_streamed_wal == true && last_xlog_receive_location_gte_replayed == false)
+	{
+		log_verbose(LOG_WARNING,
+					"Replayed WAL newer than received WAL - is this standby connected to its upstream?\n");
+	}
+
 	/*
 	 * Get master xlog position
 	 *
 	 * TODO: investigate whether pg_current_xlog_insert_location() would be a better
 	 * choice; see: https://github.com/2ndQuadrant/repmgr/issues/189
 	 */
-
-	if (server_version_num >= 100000)
-		sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_current_wal_lsn()");
-	else
-		sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_current_xlog_location()");
+	sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_current_xlog_location()");

 	res = PQexec(master_conn, sqlquery);
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
@@ -1223,20 +1162,24 @@ standby_monitor(void)
 	PQclear(res);

 	lsn_master_current_xlog_location = lsn_to_xlogrecptr(last_wal_primary_location, NULL);
-	lsn_last_xlog_receive_location = lsn_to_xlogrecptr(last_xlog_receive_location, NULL);
 	lsn_last_xlog_replay_location = lsn_to_xlogrecptr(last_xlog_replay_location, NULL);

-	if (lsn_last_xlog_receive_location >= lsn_last_xlog_replay_location)
+	/* Calculate apply lag */
+	if (last_xlog_receive_location_gte_replayed == false)
 	{
-		apply_lag = (long long unsigned int)lsn_last_xlog_receive_location - lsn_last_xlog_replay_location;
+		/*
+		 * We're not receiving streaming WAL - in this case the receive location
+		 * equals the last replayed location
+		 */
+		apply_lag = 0;
+		strncpy(last_xlog_receive_location, last_xlog_replay_location, MAXLEN);
+		lsn_last_xlog_receive_location = lsn_to_xlogrecptr(last_xlog_replay_location, NULL);
 	}
 	else
 	{
-		/* This should never happen, but in case it does set apply lag to zero */
-		log_warning("Standby receive (%s) location appears less than standby replay location (%s)\n",
-					last_xlog_receive_location,
-					last_xlog_replay_location);
-		apply_lag = 0;
+		lsn_last_xlog_receive_location = lsn_to_xlogrecptr(last_xlog_receive_location, NULL);
+
+		apply_lag = (long long unsigned int)lsn_last_xlog_receive_location - lsn_last_xlog_replay_location;
 	}


@@ -1247,7 +1190,7 @@ standby_monitor(void)
 	}
 	else
 	{
-		/* This should never happen, but in case it does set replication lag to zero */
+		/* This should never happen, but in case it does set lag to zero */
 		log_warning("Master xlog (%s) location appears less than standby receive location (%s)\n",
 					last_wal_primary_location,
 					last_xlog_receive_location);
@@ -1284,7 +1227,6 @@ standby_monitor(void)
 					  last_xlog_receive_location,
 					  replication_lag,
 					  apply_lag);
-
 	/*
 	 * Execute the query asynchronously, but don't check for a result. We will
 	 * check the result next time we pause for a monitor step.
@@ -1292,23 +1234,8 @@ standby_monitor(void)
 	log_verbose(LOG_DEBUG, "standby_monitor:() %s\n", sqlquery);

 	if (PQsendQuery(master_conn, sqlquery) == 0)
-	{
-		log_warning(_("query could not be sent to master: %s\n"),
+		log_warning(_("query could not be sent to master. %s\n"),
 					PQerrorMessage(master_conn));
-	}
-	else
-	{
-		sqlquery_snprintf(sqlquery,
-						  "SELECT %s.repmgr_update_last_updated();",
-						  get_repmgr_schema_quoted(my_local_conn));
-		res = PQexec(my_local_conn, sqlquery);
-
-		/* not critical if the above query fails*/
-		if (PQresultStatus(res) != PGRES_TUPLES_OK)
-			log_warning(_("unable to set last_updated: %s\n"), PQerrorMessage(my_local_conn));
-
-		PQclear(res);
-	}
 }


@@ -1324,7 +1251,7 @@ do_master_failover(void)
 	PGresult   *res;
 	char		sqlquery[QUERY_STR_LEN];

-	int			total_active_nodes = 0;
+	int			total_nodes = 0;
 	int			visible_nodes = 0;
 	int			ready_nodes = 0;

@@ -1355,7 +1282,7 @@ do_master_failover(void)
 			"SELECT id, conninfo, type, upstream_node_id "
 			"  FROM %s.repl_nodes "
 			" WHERE cluster = '%s' "
-			"   AND active IS TRUE "
+		        "   AND active IS TRUE "
 			"   AND priority > 0 "
 			" ORDER BY priority DESC, id "
 			" LIMIT %i ",
@@ -1371,25 +1298,32 @@ do_master_failover(void)
 		terminate(ERR_DB_QUERY);
 	}

-	total_active_nodes = PQntuples(res);
-	log_debug(_("%d active nodes registered\n"), total_active_nodes);
+	/*
+	 * total nodes that are registered
+	 */
+	total_nodes = PQntuples(res);
+	log_debug(_("%d active nodes registered\n"), total_nodes);

 	/*
 	 * Build an array with the nodes and indicate which ones are visible and
 	 * ready
 	 */
-	for (i = 0; i < total_active_nodes; i++)
+	for (i = 0; i < total_nodes; i++)
 	{
-		char node_type[MAXLEN];
-
-		nodes[i] = (t_node_info) T_NODE_INFO_INITIALIZER;
-
 		nodes[i].node_id = atoi(PQgetvalue(res, i, 0));

 		strncpy(nodes[i].conninfo_str, PQgetvalue(res, i, 1), MAXCONNINFO);
-		strncpy(node_type, PQgetvalue(res, i, 2), MAXLEN);

-		nodes[i].type = parse_node_type(node_type);
+		nodes[i].type = parse_node_type(PQgetvalue(res, i, 2));
+
+		/* Copy details of the failed node */
+		/* XXX only node_id is actually used later */
+		if (nodes[i].type == MASTER)
+		{
+			failed_master.node_id = nodes[i].node_id;
+			failed_master.xlog_location = nodes[i].xlog_location;
+			failed_master.is_ready = nodes[i].is_ready;
+		}

 		nodes[i].upstream_node_id = atoi(PQgetvalue(res, i, 3));

@@ -1400,42 +1334,11 @@ do_master_failover(void)
 		nodes[i].is_visible = false;
 		nodes[i].is_ready = false;

-		log_debug(_("node=%i conninfo=\"%s\" type=%s\n"),
-				  nodes[i].node_id,
-				  nodes[i].conninfo_str,
-				  node_type);
+		nodes[i].xlog_location = InvalidXLogRecPtr;

-		/* Copy details of the failed master node */
-		if (nodes[i].type == MASTER)
-		{
-			/* XXX only node_id is currently used */
-			failed_master.node_id = nodes[i].node_id;
-
-			/*
-			 * XXX experimental
-			 *
-			 * Currently an attempt is made to connect to the master,
-			 * which is very likely to be a waste of time at this point, as we'll
-			 * have spent the last however many seconds trying to do just that
-			 * in check_connection() before deciding it's gone away.
-			 *
-			 * If the master did come back at this point, the voting algorithm should decide
-			 * it's the "best candidate" anyway and no standby will promote itself or
-			 * attempt to follow* another server.
-			 *
-			 * If we don't try and connect to the master here (and the code generally
-			 * assumes it's failed anyway) but it does come back any time from here
-			 * onwards, promotion will fail and the promotion candidate will
-			 * notice the reappearance.
-			 *
-			 * TLDR version: by skipping the master connection attempt (and the chances
-			 * the master would reappear between the last attempt in check_connection()
-			 * and now are minimal) we can remove useless cycles during the failover process;
-			 * if the master does reappear it will be caught before later anyway.
-			 */
-
-			continue;
-		}
+		log_debug(_("node=%d conninfo=\"%s\" type=%s\n"),
+				  nodes[i].node_id, nodes[i].conninfo_str,
+				  PQgetvalue(res, i, 2));

 		node_conn = establish_db_connection(nodes[i].conninfo_str, false);

@@ -1456,13 +1359,13 @@ do_master_failover(void)
 	PQclear(res);

 	log_debug(_("total nodes counted: registered=%d, visible=%d\n"),
-			  total_active_nodes, visible_nodes);
+			  total_nodes, visible_nodes);

 	/*
 	 * Am I on the group that should keep alive? If I see less than half of
-	 * total_active_nodes then I should do nothing
+	 * total_nodes then I should do nothing
 	 */
-	if (visible_nodes < (total_active_nodes / 2.0))
+	if (visible_nodes < (total_nodes / 2.0))
 	{
 		log_err(_("Unable to reach most of the nodes.\n"
 				  "Let the other standby servers decide which one will be the master.\n"
@@ -1471,7 +1374,7 @@ do_master_failover(void)
 	}

 	/* Query all available nodes to determine readiness and LSN */
-	for (i = 0; i < total_active_nodes; i++)
+	for (i = 0; i < total_nodes; i++)
 	{
 		log_debug("checking node %i...\n", nodes[i].node_id);

@@ -1500,11 +1403,7 @@ do_master_failover(void)
 			terminate(ERR_FAILOVER_FAIL);
 		}

-		if (server_version_num >= 100000)
-			sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_last_wal_receive_lsn()");
-		else
-			sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_last_xlog_receive_location()");
-
+		sqlquery_snprintf(sqlquery, "SELECT pg_catalog.pg_last_xlog_receive_location()");
 		res = PQexec(node_conn, sqlquery);
 		if (PQresultStatus(res) != PGRES_TUPLES_OK)
 		{
@@ -1536,12 +1435,7 @@ do_master_failover(void)
 	}

 	/* last we get info about this node, and update shared memory */
-
-	if (server_version_num >= 100000)
-		sprintf(sqlquery, "SELECT pg_catalog.pg_last_wal_receive_lsn()");
-	else
-		sprintf(sqlquery, "SELECT pg_catalog.pg_last_xlog_receive_location()");
-
+	sprintf(sqlquery, "SELECT pg_catalog.pg_last_xlog_receive_location()");
 	res = PQexec(my_local_conn, sqlquery);
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
@@ -1558,7 +1452,7 @@ do_master_failover(void)
 	PQclear(res);

 	/* Wait for each node to come up and report a valid LSN */
-	for (i = 0; i < total_active_nodes; i++)
+	for (i = 0; i < total_nodes; i++)
 	{
 		/*
 		 * ensure witness server is marked as ready, and skip
@@ -1591,6 +1485,7 @@ do_master_failover(void)
 		 */
 		if (PQstatus(node_conn) != CONNECTION_OK)
 		{
+			/* XXX */
 			log_info(_("At this point, it could be some race conditions "
 					   "that are acceptable, assume the node is restarting "
 					   "and starting failover procedure\n"));
@@ -1717,7 +1612,7 @@ do_master_failover(void)
 	/*
 	 * determine which one is the best candidate to promote to master
 	 */
-	for (i = 0; i < total_active_nodes; i++)
+	for (i = 0; i < total_nodes; i++)
 	{
 		/* witness server can never be a candidate */
 		if (nodes[i].type == WITNESS)
@@ -1806,8 +1701,6 @@ do_master_failover(void)
 				{
 					log_notice(_("Original master reappeared before this standby was promoted - no action taken\n"));

-					/* XXX log an event here?  */
-
 					PQfinish(master_conn);
 					master_conn = NULL;

@@ -1944,10 +1837,8 @@ do_master_failover(void)
 		termPQExpBuffer(&event_details);
 	}

-	/*
-	 * setting "failover_done" to true will cause the node's monitoring loop
-	 * to restart in the appropriate mode for the node's (possibly new) role
-	 */
+	/* to force it to re-calculate mode and master node */
+	// ^ ZZZ check that behaviour ^
 	failover_done = true;
 }

@@ -2123,7 +2014,7 @@ check_connection(PGconn **conn, const char *type, const char *conninfo)
 		{
 			if (conninfo == NULL)
 			{
-				log_err("INTERNAL ERROR: *conn == NULL && conninfo == NULL\n");
+				log_err("INTERNAL ERROR: *conn == NULL && conninfo == NULL");
 				terminate(ERR_INTERNAL);
 			}
 			*conn = establish_db_connection(conninfo, false);
@@ -2163,21 +2054,18 @@ check_connection(PGconn **conn, const char *type, const char *conninfo)
 /*
 * set_local_node_status()
 *
- * Attempt to connect to the current master server (as stored in the global
- * variable `master_conn`) and set the local node's status to the result
- * of `is_standby(my_local_conn)`. Normally this will be used to mark
- * a node as failed, but in some circumstances we may be marking it
- * as recovered.
+ * If failure of the local node is detected, attempt to connect
+ * to the current master server (as stored in the global variable
+ * `master_conn`) and update its record to failed.
 */

 static bool
 set_local_node_status(void)
 {
-	PGresult   *res;
+	PGresult       *res;
 	char		sqlquery[QUERY_STR_LEN];
-	int			active_master_node_id = NODE_NOT_FOUND;
+	int		active_master_node_id = NODE_NOT_FOUND;
 	char		master_conninfo[MAXLEN];
-	bool		local_node_status;

 	if (!check_connection(&master_conn, "master", NULL))
 	{
@@ -2236,29 +2124,24 @@ set_local_node_status(void)

 	/*
 	 * Attempt to set the active record to the correct value.
+	 * First
 	 */

-	local_node_status = (is_standby(my_local_conn) == 1);
-
 	if (!update_node_record_status(master_conn,
 					    local_options.cluster_name,
 					    node_info.node_id,
 					    "standby",
 					    node_info.upstream_node_id,
-					    local_node_status))
+					    is_standby(my_local_conn)==1))
 	{
-		log_err(_("unable to set local node %i as %s on master: %s\n"),
+		log_err(_("unable to set local node %i as inactive on master: %s\n"),
 				node_info.node_id,
-				local_node_status == false ? "inactive" : "active",
 				PQerrorMessage(master_conn));

 		return false;
 	}

-	log_notice(_("marking this node (%i) as %s on master\n"),
-			   node_info.node_id,
-			   local_node_status == false ? "inactive" : "active");
-
+	log_notice(_("marking this node (%i) as inactive on master\n"), node_info.node_id);
 	return true;
 }

@@ -2399,13 +2282,13 @@ lsn_to_xlogrecptr(char *lsn, bool *format_ok)
 	if (format_ok != NULL)
 		*format_ok = true;

-	return (XLogRecPtr) ((uint64) xlogid) << 32 | (uint64) xrecoff;
+	return (((XLogRecPtr) xlogid * 16 * 1024 * 1024 * 255) + xrecoff);
 }

 void
 usage(void)
 {
-	log_err(_("%s: replication management daemon for PostgreSQL\n"), progname());
+	log_err(_("%s: Replicator manager daemon \n"), progname());
 	log_err(_("Try \"%s --help\" for more information.\n"), progname());
 }

--- a/sql/Makefile
+++ b/sql/Makefile
@@ -1,7 +1,7 @@
 #
 # Makefile
 #
-# Copyright (c) 2ndQuadrant, 2010-2017
+# Copyright (c) 2ndQuadrant, 2010-2016
 #

 MODULE_big = repmgr_funcs
--- a/sql/repmgr_funcs.sql.in
+++ b/sql/repmgr_funcs.sql.in
@@ -1,6 +1,6 @@
 /*
 * repmgr_function.sql
- * Copyright (c) 2ndQuadrant, 2010-2017
+ * Copyright (c) 2ndQuadrant, 2010-2016
 *
 */

--- a/sql/repmgr_test.sql
+++ b/sql/repmgr_test.sql
@@ -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();
--- a/sql/uninstall_repmgr_funcs.sql
+++ b/sql/uninstall_repmgr_funcs.sql
@@ -1,6 +1,6 @@
 /*
 * uninstall_repmgr_funcs.sql
- * Copyright (c) 2ndQuadrant, 2010-2017
+ * Copyright (c) 2ndQuadrant, 2010-2016
 *
 */

--- a/strutil.c
+++ b/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;
-}
--- a/strutil.h
+++ b/strutil.h
@@ -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_ */
--- a/uninstall_repmgr.sql
+++ b/uninstall_repmgr.sql
@@ -1,7 +1,7 @@
 /*
 * uninstall_repmgr.sql
 *
- * Copyright (c) 2ndQuadrant, 2010-2017
+ * Copyright (C) 2ndQuadrant, 2010-2016
 *
 */

--- a/version.h
+++ b/version.h
@@ -1,6 +1,6 @@
 #ifndef _VERSION_H_
 #define _VERSION_H_

-#define REPMGR_VERSION "3.3.2"
+#define REPMGR_VERSION "3.1.5"

 #endif
Author	SHA1	Message	Date
Martin	3802b917e0	Fix alignment and syntax	2016-09-23 13:45:59 -03:00
Jarkko Oranen	4f7a2a0614	Add sample configuration for systemd support	2016-09-23 13:45:50 -03:00
Jarkko Oranen	06c7fe04b0	Allow overriding start, stop and restart commands issued by repmgr This commit introduces three new options: - start_command - stop_command - restart_command If these are set, repmgr will issue the specified command instead of the default pg_ctl commands	2016-09-23 13:45:32 -03:00
Ian Barwick	1fe01e9168	Update HISTORY	2016-08-15 12:31:42 +09:00
Ian Barwick	ed1136f443	Reinstate deprecated command line options and add warnings -l/--local-port will be removed in 3.2, not 3.1.x. --initdb-no-pwprompt already has no effect.	2016-08-15 12:22:33 +09:00
Ian Barwick	a7ed60a533	Update README.md Note default usage of `pg_basebackup --xlog-method=stream`.	2016-08-15 10:20:12 +09:00
Renaud Fortier	fc5a18410d	Update README.md I think this will improve the readme.	2016-08-15 10:20:07 +09:00
Ian Barwick	fd52c8ec3c	Update HISTORY	2016-08-12 09:58:04 +09:00
Ian Barwick	47f1c6fa84	Revert "Improved "repmgr-auto" Debian package" This reverts commit `5b91a5e2e5`.	2016-08-12 09:55:47 +09:00
Ian Barwick	fba89ef37c	repmgr: set default user for -R/--remote-user	2016-08-12 09:32:40 +09:00
Ian Barwick	4cc6cbe32f	`repmgr standby clone` historically accepts a hostname as third parameter	2016-08-12 09:20:54 +09:00
Ian Barwick	c715077c29	Clean up command line option handling and help output - properly distinguish between the command line option -? and getopt's unknown option marker '?' - remove deprecated command line options --initdb-no-pwprompt and -l/--local-port - add witness command summary in help output	2016-08-11 17:33:05 +09:00
Ian Barwick	c178d8ed27	Refactor standby monitoring query Addresses GitHub #224	2016-08-11 17:28:59 +09:00
Ian Barwick	d4d06f43f7	When the output of a remote command isn't required, ensure it's consumed anyway This fixes a regression introduced with commit `85f68e9f77` Also clean up some code made redundant by same.	2016-08-11 08:52:27 +09:00
Ian Barwick	0d346a9f54	Update HISTORY Also remove code comment obsoleted by previous commit	2016-08-09 15:41:09 +09:00
Gianni Ciolli	abb16e4366	Now STANDBY SWITCHOVER and STANDBY FOLLOW log an event notification on success and also on some failures, precisely those when it makes sense or it is reasonably possible to do so.	2016-08-09 15:40:59 +09:00
Gianni Ciolli	59b1924d5b	Only collect remote command output if the caller requires it This addresses GitHub #216 and #167.	2016-08-09 15:34:57 +09:00
Ian Barwick	c88ea62643	Update HISTORY	2016-08-09 12:28:51 +09:00
Gianni Ciolli	5b91a5e2e5	Improved "repmgr-auto" Debian package * Version set to 3.2dev * Binaries are placed in PGBINDIR and then linked from /usr/bin, instead of being placed into /usr/bin directly. This is necessary for the switchover command, because it requires pg_rewind, which is placed in PGBINDIR too.	2016-08-09 12:28:22 +09:00
Ian Barwick	c2a1a35282	Bump version 3.1.5	2016-08-09 12:21:06 +09:00
Ian Barwick	2b8b74ae75	Update HISTORY	2016-08-09 12:20:38 +09:00
Ian Barwick	08ef4d4be6	Improve handling of failover events when `failover` is set to `manual` - prevent repmgrd from repeatedly executing the failover code - add event notification 'standby_disconnect_manual' - update documentation This addresses GitHub #221.	2016-08-09 12:20:20 +09:00
Ian Barwick	1a0049f086	repmgrd: prevent endless loops in failover with manual node The LSN reported by the shared memory function defaults to "0/0" (InvalidXLogRecPtr) - this indicates that the repmgrd on that node hasn't been able to update it yet. However during failover several places in the code assumed this is an error, which would cause an endless loop waiting for updates which would never come. To get around this without changing function definitions, we can store an explicit message in the shared memory location field so the caller can tell whether the other node hasn't yet updated the field, or encountered situation which means it should not be considered as a promotion candidate (which in most cases will be because `failover` is set to `manual`. Resolves GitHub #222.	2016-08-09 12:20:03 +09:00
Ian Barwick	af6f0fc2cf	Fix repmgrd's command line help option parsing As in commit `d0c05e6f46`, properly distinguish between the command line option -? and getopt's unknown option marker '?'	2016-08-08 21:19:13 +09:00
Ian Barwick	893d67473d	Document `repmgr cluster show --csv`	2016-08-01 16:13:03 +09:00
Ian Barwick	a922cd5558	Suppress connection error display in `repmgr cluster show` This prevents connection error messages being mixed in with `repmgr cluster show` output. Error message output can still be enabled with the --verbose flag. Fixes GitHub #215	2016-08-01 15:01:23 +09:00
Ian Barwick	7bbc664230	Miscellaneous code cleanup and typo fixes	2016-07-28 16:39:32 +09:00
Ian Barwick	a6998fe0f9	Update README Default log level is NOTICE, not INFO.	2016-07-28 16:39:21 +09:00
Ian Barwick	dadfdcc51f	Rename RECOVERY_FILE to RECOVERY_COMMAND_FILE This is for consistency with the PostgreSQL source code (see: src/backend/access/transam/xlog.c ), but as it's not exported we need to define it ourselves anyway.	2016-07-26 09:21:38 +09:00
Ian Barwick	b8823d5c1f	Update README Add note about 2ndQuadrant RPM repository.	2016-07-13 09:55:34 +09:00
Ian Barwick	e59b57376d	Update code comments	2016-07-12 10:59:48 +09:00
Ian Barwick	3db87e6a31	Remove unused error code ERR_BAD_PASSWORD	2016-07-12 10:59:42 +09:00
Ian Barwick	94d05619c3	README: update error code list	2016-07-12 10:59:37 +09:00
Ian Barwick	807c7c926c	Update README with details about conninfo parameter handling From 3.1.4 `repmgr` will behave like other PostgreSQL utilities when handling database connection parameters, in particular accepting a conninfo string and honouring libpq connection defaults.	2016-07-12 10:59:30 +09:00
Ian Barwick	df68f1f3f6	Make more consistent use of conninfo parameters Removed the existing keyword array which has a fixed, limited number of parameters and replace it with a dynamic array which can be used to store as many parameters as reported by libpq.	2016-07-12 10:59:26 +09:00
Ian Barwick	d4c75bb6c7	Add missing space when setting "application_name"	2016-07-12 10:59:20 +09:00
Ian Barwick	94d4e1128d	Improve default host/dbname handling repmgr disallows socket connections anyway (the whole point of providing the host is to connect to a remote machine) so don't show that as a fallback default in the -?/--help output.	2016-07-12 10:59:13 +09:00
Ian Barwick	dbd82ba687	Enable a conninfo string to be passed to repmgr in the -d/--dbname parameter This matches the behaviour of other PostgreSQL utilities such as pg_basebackup, psql et al. Note that unlike psql, but like pg_basebackup, repmgr does not accept a "left-over" parameter as a conninfo string; this could be added later. Parameters specified in the conninfo string will override any parameters supplied correcly (e.g. `-d "host=foo"` will override `-h bar`).	2016-07-12 10:59:09 +09:00
Ian Barwick	0888fbc538	Generate "primary_conninfo" using the primary connection's parameters Having successfully connected to the primary, we can use the actual parameters reported by libpq to create "primary_conninfo", rather than the limited subset previously defined by repmgr. Assuming that the user can pass a conninfo string to repmgr (see following commit), this makes it possible to provide other connection parameters, e.g. related to SSL usage.	2016-07-12 10:59:05 +09:00
Ian Barwick	92a84bd950	Remove now-superfluous wildcard in rmtree() call	2016-07-07 09:54:50 +09:00
Ian Barwick	a3318d65d2	Bump version 3.1.4	2016-07-07 08:49:42 +09:00
Ian Barwick	374e9811c9	Merge branch 'master' of github.com:2ndQuadrant/repmgr into REL3_1_STABLE	2016-07-06 16:43:39 +09:00
Ian Barwick	16896510dc	Fix log formatting	2016-05-17 17:24:30 +09:00
Ian Barwick	1c155a1088	Update HISTORY	2016-05-17 11:12:18 +09:00
Ian Barwick	31d57f4122	Update Makefile Add include file dependencies (see caveat in file). Also update comments.	2016-05-16 19:15:58 +09:00
Ian Barwick	7b313b9d71	README.md: improve documentation of `repl_status` view	2016-05-16 13:51:08 +09:00
Ian Barwick	cf126642bd	repmgrd: handle situations where streaming replication is inactive	2016-05-16 12:31:31 +09:00
Ian Barwick	52281fcde8	repmgrd: rename some variables to better match the system functions they're populated from	2016-05-16 12:31:06 +09:00
Ian Barwick	de573edaaa	Remove extraneous PQfinish()	2016-05-16 12:23:39 +09:00
Ian Barwick	4cb7f301ad	Correct check for wal_level in 9.3	2016-05-16 12:23:33 +09:00
Ian Barwick	87d8de4441	Remove unneeded column	2016-05-16 12:23:25 +09:00
Ian Barwick	6db742f81e	repmgrd: better handling of missing upstream_node_id Ensure we default to master node.	2016-05-16 12:23:20 +09:00
Ian Barwick	c79933685c	Add missing newlines in log messages	2016-05-16 12:23:15 +09:00
Ian Barwick	04ba672b9f	repmgrd: avoid additional connection to local instance in do_master_failover()	2016-05-16 12:23:09 +09:00
Ian Barwick	4f4111063a	Suppress gnu_printf format warning	2016-05-16 12:23:03 +09:00
Ian Barwick	3a3a536e6d	repmgrd: rename variable for clarity	2016-05-16 12:22:58 +09:00
Ian Barwick	6f7206a5a1	Don't follow the promotion candidate standby if the primary reappears	2016-05-16 12:22:49 +09:00
Ian Barwick	f9fd1dd227	Don't terminate a standby's repmgrd if self-promotion fails due to master reappearing Per GitHub #173	2016-05-16 12:22:40 +09:00
Martin	8140ba9c27	The commit fixes problems not taking in account while working on the issue with rsync returning non-zero status on vanishing files on commit `83e5f98171`. Alvaro Herrera gave me some tips which pointed me in the correct direction. This was reported by sungjae lee <sj860908@gmail.com>	2016-05-16 12:22:27 +09:00
Ian Barwick	32dba444e1	Enable long option --pgdata as alias for -D/--data-dir pg_ctl provides -D/--pgdata; we want to be as close to the core utilities as possible.	2016-05-16 12:22:17 +09:00
Ian Barwick	8212ff8d8a	Bump version 3.1.3	2016-05-12 07:54:42 +09:00
Martin	1ccd0edad2	We were not checking the return code after rsyncing the tablespaces. This fixes #168	2016-04-17 17:59:50 -03:00
Martin	59b31dd1ca	Ignore rsync error code for vanished files. It's very common to come over vanish files during a backup or rsync o the data directory (dropped index, temp tables, etc.) This fixes #149	2016-04-17 17:59:50 -03:00
Ian Barwick	300b9f0cc2	Fix pre-9.6 wal_level check	2016-04-12 16:18:29 +09:00
Ian Barwick	0efee4cf65	Fix hint message formatting	2016-04-12 16:07:38 +09:00
Ian Barwick	0cb2584886	Bump version 3.1.2	2016-04-12 15:56:39 +09:00
Ian Barwick	b88d27248c	Use "immediately_reserve" parameter in pg_create_physical_replication_slot (9.6)	2016-04-12 15:56:06 +09:00
Ian Barwick	683c54325e	Enable repmgr to be compiled with PostgreSQL 9.6	2016-04-12 15:55:51 +09:00
Ian Barwick	70d398cd47	Update HISTORY	2016-04-12 15:53:40 +09:00
Ian Barwick	7b7d80e5f2	Update HISTORY	2016-04-12 15:53:33 +09:00
Ian Barwick	96b0e26084	Remove duplicate inclusion from header file	2016-04-06 14:16:00 +09:00
Ian Barwick	91c498f6f1	Update HISTORY	2016-04-06 11:57:46 +09:00
Ian Barwick	d48093e732	Preserver failover slots when cloning a standby, if enabled	2016-04-06 11:20:27 +09:00
Ian Barwick	3f0d1754a4	MAXFILENAME -> MAXPGPATH	2016-04-06 11:20:27 +09:00
Craig Ringer	f27979bbe1	WIP support for preserving failover slots	2016-04-06 11:20:27 +09:00
Ian Barwick	e9445a5d5e	Make self-referencing foreign key on repl_nodes table deferrable	2016-04-01 15:20:36 +09:00
Ian Barwick	9a2717b5e3	Improve debugging output for node resyncing We'll need this for testing.	2016-04-01 15:20:32 +09:00
Ian Barwick	dd6ea1cd77	Rename copy_configuration () to witness_copy_node_records() As it's witness-specific. Per suggestion from Martín.	2016-04-01 11:30:08 +09:00
Ian Barwick	de5908c122	Make witness server node update an atomic operation If the connection to the primary is lost, roll back to the previously known state. TRUNCATE is of course not MVCC-friendly, but that shouldn't matter here as only one process should ever be looking at this table.	2016-04-01 11:15:27 +09:00
Ian Barwick	4b5c84921c	Replace MAXFILENAME with MAXPGPATH	2016-03-31 20:11:10 +09:00
Ian Barwick	aaa8d70cef	Comment out configuration items in sample config file The configured values are either the defaults, or examples which may not work in a real environment. If this file is being used as a template, the onus is on the user to uncomment and check all desired parameters.	2016-03-31 15:14:30 +09:00
Gianni Ciolli	ca31b846e7	Rewording comment for clarity.	2016-03-31 15:01:29 +09:00
Ian Barwick	a27cecb559	Update HISTORY	2016-03-31 14:59:03 +09:00
Ian Barwick	cf0cdfa6a1	Bump version 3.1.2rc1	2016-03-31 14:56:49 +09:00
Ian Barwick	31489d92c0	Check directory entity filetype in a more portable way	2016-03-30 20:21:41 +09:00
Ian Barwick	b7fd13aed2	Fix pg_ctl path generation in do_standby_switchover()	2016-03-30 16:46:57 +09:00
Ian Barwick	3c4bf27aa7	Add headers as dependencies in Makefile	2016-03-30 15:06:15 +09:00
Ian Barwick	0ebd9c15d9	Regularly sync witness server repl_nodes table. Although the witness server will resync the repl_nodes table following a failover, other operations (e.g. removing or cloning a standby) were previously not reflected in the witness server's copy of this table. As a short-term workaround, automatically resync the table at regular intervals (defined by the configuration file parameter "witness_repl_nodes_sync_interval_secs", default 30 seconds).	2016-03-30 15:06:12 +09:00
Nikolay Shaplov	f9dba283d4	Better use /24 network mask in this example	2016-03-30 15:05:29 +09:00
Ian Barwick	205f1cebbb	It's unlikely this situation will occur on a witness server Which is why the error message is for master/standby only.	2016-03-30 15:05:26 +09:00
Ian Barwick	4d97c1ebf7	Add hint about registering the server after cloning it. This step is easy to forget.	2016-03-30 15:05:20 +09:00
Ian Barwick	12c395e91f	README: Add note about 'repmgr_funcs'	2016-03-30 15:05:17 +09:00
Ian Barwick	bd1e4f71d6	repmgrd: fix error message	2016-03-30 15:05:10 +09:00
Ian Barwick	cb49071ea4	Fix code comment	2016-03-30 15:05:06 +09:00
Ian Barwick	5ad674edff	Bump version 3.1.1	2016-02-23 15:56:24 +09:00
Ian Barwick	ac09bad89c	Minor fixes to README.md	2016-02-23 14:37:59 +09:00
Ian Barwick	009d92fec8	Ensure witness node is registered before the repl_nodes table is copied This fixes a bug introduced into the previous commit, where the witness node was registered last to prevent a spurious node record being created even if witness server creation failed.	2016-02-23 14:37:54 +09:00
Martin	b3d8a68a1d	Fix a few paragraphs from the README.md.	2016-02-23 14:37:48 +09:00
Ian Barwick	05b47cb2a8	Prevent repmgr/repmgrd running as root	2016-02-23 14:37:44 +09:00
Ian Barwick	dc542a1b7d	Better handling of errors during witness creation Ensure witness is only registered after all steps for creation have been successfully completed. Also write an event record if connection could not be made to the witness server after initial creation. This addresses GitHub issue #146.	2016-02-23 14:37:39 +09:00
Ian Barwick	6ce8058749	witness creation: extract database and user names from the local conninfo string 99.9% of the time they'll be the same as the primary connection, but it's more consistent to use the provided local conninfo string (from which the port is already extracted).	2016-02-23 14:37:31 +09:00
Ian Barwick	2edcac77f0	README.md: update witness server section	2016-02-23 14:37:27 +09:00
Ian Barwick	f740374392	Add '-P/--pwprompt' option for "repmgr create witness" Optionally prompt for superuser and repmgr user when creating a witness. This ensures a password can be provided if the primary's pg_hba.conf mandates it. This deprecates '--initdb-no-pwprompt'; and changes the default behaviour of "repmgr create witness", which previously required a superuser password unless '--initdb-no-pwprompt' was supplied. This behaviour is more consistent with other PostgreSQL utilities such as createuser. Partial fix for GitHub issue #145.	2016-02-23 14:37:23 +09:00