Update version number for minor release 2.0.3

Make consistent with same option added in 3.0. '-c' is similar to
pg_basebackup's '-c, --checkpoint=fast|spread' option; we may also
want to use -X for something more pg_xlog-related in future.

Also add missing 'break' statement

HISTORY

@@ -1,3 +1,23 @@
+2.0.3   2015-04-16
+        Add -S/--superuser option for witness database creation Ian)
+        Add -c/--fast-checkpoint option for cloning (Christoph)
+        Add option "--initdb-no-pwprompt" (Ian)
+
+2.0.2   2015-02-17
+        Add "--checksum" in rsync when using "--force" (Jaime)
+        Use createdb/createuser instead of psql (Jaime)
+        Fixes to witness creation and monitoring (wamonite)
+        Use default master port if none supplied (Martín)
+        Documentation fixes and improvements (Ian)
+
+2.0.1   2014-07-16
+        Documentation fixes and new QUICKSTART file (Ian)
+        Explicitly specify directories to ignore when cloning (Ian)
+        Fix log level for some log messages (Ian)
+        RHEL/CentOS specfile, init script and Makefile fixes (Nathan Van Overloop)
+        Debian init script and config file documentation fixes (József Kószó)
+        Typo fixes (Riegie Godwin Jeyaranchen, PriceChild)
+
 2.0stable 2014-01-30
         Documentation fixes (Christian)
         General refactoring, code quality improvements and stabilization work (Christian)
@@ -17,7 +37,7 @@
         Add a ssh_options parameter (Jay Taylor)
 
 2.0beta1 2012-07-27
-        Make CLONE command try to make an exact copy including $PGDATA location (Cedric) 
+        Make CLONE command try to make an exact copy including $PGDATA location (Cedric)
         Add detection of master failure (Jaime)
         Add the notion of a witness server (Jaime)
         Add autofailover capabilities (Jaime)
@@ -44,7 +64,7 @@
 1.1.0   2011-03-09
         Make options -U, -R and -p not mandatory (Jaime)
 
-1.1.0b1 2011-02-24 
+1.1.0b1 2011-02-24
         Fix missing "--force" option in help (Greg Smith)
         Correct warning message for wal_keep_segments (Bas van Oostveen)
         Add Debian build/usage docs (Bas, Hannu Krosing, Cedric Villemain)

Makefile

@@ -36,12 +36,24 @@ endif
 install: install_prog install_ext
 
 install_prog:
-	$(INSTALL_PROGRAM) repmgrd$(X) '$(DESTDIR)$(bindir)'
+	mkdir -p '$(DESTDIR)$(bindir)'
-	$(INSTALL_PROGRAM) repmgr$(X) '$(DESTDIR)$(bindir)'
+	$(INSTALL_PROGRAM) repmgrd$(X) '$(DESTDIR)$(bindir)/'
+	$(INSTALL_PROGRAM) repmgr$(X) '$(DESTDIR)$(bindir)/'
 
 install_ext:
 	$(MAKE) -C sql install
 
+install_rhel:
+	mkdir -p '$(DESTDIR)/etc/init.d/'
+	$(INSTALL_PROGRAM) RHEL/repmgrd.init '$(DESTDIR)/etc/init.d/repmgrd'
+	mkdir -p '$(DESTDIR)/etc/sysconfig/'
+	$(INSTALL_PROGRAM) RHEL/repmgrd.sysconfig '$(DESTDIR)/etc/sysconfig/repmgrd'
+	mkdir -p '$(DESTDIR)/etc/repmgr/'
+	$(INSTALL_PROGRAM) repmgr.conf.sample '$(DESTDIR)/etc/repmgr/'
+	mkdir -p '$(DESTDIR)/usr/bin/'
+	$(INSTALL_PROGRAM) repmgrd$(X) '$(DESTDIR)/usr/bin/'
+	$(INSTALL_PROGRAM) repmgr$(X) '$(DESTDIR)/usr/bin/'
+
 ifneq (,$(DATA)$(DATA_built))
 	@for file in $(addprefix $(srcdir)/, $(DATA)) $(DATA_built); do \
 	  echo "$(INSTALL_DATA) $$file '$(DESTDIR)$(datadir)/$(datamoduledir)'"; \
@@ -67,3 +79,4 @@ deb: repmgrd repmgr
 	mv debian.deb ../postgresql-repmgr-9.0_1.0.0.deb
 	rm -rf ./debian/usr
 
+

QUICKSTART.md

@@ -0,0 +1,304 @@
+repmgr: Quickstart guide
+========================
+
+`repmgr` is an open-source tool suite for mananaging replication and failover
+among multiple PostgreSQL server nodes. It enhances PostgreSQL's built-in
+hot-standby capabilities with a set of administration tools for monitoring
+replication, setting up standby servers and performing failover/switchover
+operations.
+
+This quickstart guide assumes you are familiar with PostgreSQL replication
+setup and Linux/UNIX system administration. For a more detailed tutorial
+covering setup on a variety of different systems, see the README.rst file.
+
+Conceptual Overview
+-------------------
+
+`repmgr` provides two binaries:
+
+ - `repmgr`: a command-line client to manage replication and `repmgr` configuration
+ - `repmgrd`: an optional daemon process which runs on standby nodes to monitor
+   replication and node status
+
+Each PostgreSQL node requires a `repmgr.conf` configuration file; additionally
+it must be "registered" using the `repmgr` command-line client. `repmgr` stores
+information about managed nodes in a custom schema on the node's current master
+database.
+
+
+Requirements
+------------
+
+`repmgr` works with PostgreSQL 9.0 and later. All server nodes must be running the
+same PostgreSQL major version, and preferably should be running the same minor
+version.
+
+`repmgr` will work on any Linux or UNIX-like environment capable of running
+PostgreSQL. `rsync` must also be installed.
+
+
+Installation
+------------
+
+`repmgr` must be installed on each PostgreSQL server node.
+
+* Packages
+ - RPM packages for RedHat-based distributions are available from PGDG
+ - Debian/Ubuntu provide .deb packages.
+
+  It is also possible to build .deb packages directly from the `repmgr` source;
+  see README.rst for further details.
+
+* Source installation
+ - `repmgr` source code is hosted at github (https://github.com/2ndQuadrant/repmgr);
+   tar.gz files can be downloaded from https://github.com/2ndQuadrant/repmgr/releases .
+
+   `repmgr` can be built easily using PGXS:
+
+       sudo make USE_PGXS=1 install
+
+
+Configuration
+-------------
+
+### Server configuration
+
+Password-less SSH logins must be enabled for the database system user (typically `postgres`)
+between all server nodes to enable `repmgr` to copy required files.
+
+### PostgreSQL configuration
+
+The master PostgreSQL node needs to be configured for replication with the
+following settings:
+
+    wal_level = 'hot_standby'      # minimal, archive, hot_standby, or logical
+    archive_mode = on              # allows archiving to be done
+    archive_command = 'cd .'       # command to use to archive a logfile segment
+    max_wal_senders = 10           # max number of walsender processes
+    wal_keep_segments = 5000       # in logfile segments, 16MB each; 0 disables
+    hot_standby = on               # "on" allows queries during recovery
+
+Note that `repmgr` expects a default of 5000 wal_keep_segments, although this
+value can be overridden when executing the `repmgr` client.
+
+Additionally, `repmgr` requires a dedicated PostgreSQL superuser account
+and a database in which to store monitoring and replication data. The `repmgr`
+user account will also be used for replication connections from the standby,
+so a seperate replication user with the `REPLICATION` privilege is not required.
+The database can in principle be any database, including the default `postgres`
+one, however it's probably advisable to create a dedicated database for `repmgr`
+usage.
+
+
+### repmgr configuration
+
+Each PostgreSQL node requires a `repmgr.conf` configuration file containing
+identification and database connection information:
+
+    cluster=test
+    node=1
+    node_name=node1
+    conninfo='host=repmgr_node1 user=repmgr_usr dbname=repmgr_db'
+    pg_bindir=/path/to/postgres/bin
+
+* `cluster`: common name for the replication cluster; this must be the same on all nodes
+* `node`: a unique, abitrary integer identifier
+* `name`: a unique, human-readable name
+* `conninfo`: a standard conninfo string enabling repmgr to connect to the
+   control database; user and name must be the same on all nodes, while other
+   parameters such as port may differ. The `host` parameter *must* be a hostname
+   resolvable by all nodes on the cluster.
+* `pg_bindir`: (optional) location of PostgreSQL binaries, if not in the default $PATH
+
+Note that the configuration file should *not* be stored inside the PostgreSQL
+data directory. The configuration file can be specified with the
+`-f, --config-file=PATH` option and can have any arbitrary name. If no
+configuration file is specified, `repmgr` will search for `repmgr.conf`
+in the current working directory.
+
+Each node configuration needs to be registered with `repmgr`, either using the
+`repmgr` command line tool, or the `repmgrd` daemon; for details see below. Details
+about each node are inserted into the `repmgr` database (for details see below).
+
+
+Replication setup and monitoring
+--------------------------------
+
+For the purposes of this guide, we'll assume the database user will be
+`repmgr_usr` and the database will be `repmgr_db`, and that the following
+environment variables are set on each node:
+
+ - $HOME: the PostgreSQL system user's home directory
+ - $PGDATA: the PostgreSQL data directory
+
+
+Master setup
+------------
+
+1. Configure PostgreSQL
+
+  - create user and database:
+
+	```
+	CREATE ROLE repmgr_usr LOGIN SUPERUSER;
+	CREATE DATABASE repmgr_db OWNER repmgr_usr;
+	```
+
+  - configure `postgresql.conf` for replication (see above)
+
+  - update `pg_hba.conf`, e.g.:
+
+	```
+	host    repmgr_db       repmgr_usr  192.168.1.0/24         trust
+	host    replication     repmgr_usr  192.168.1.0/24         trust
+	```
+
+  Restart the PostgreSQL server after making these changes.
+2. Create the `repmgr` configuration file:
+
+        $ cat $HOME/repmgr/repmgr.conf
+        cluster=test
+        node=1
+        node_name=node1
+        conninfo='host=repmgr_node1 user=repmgr_usr dbname=repmgr_db'
+        pg_bindir=/path/to/postgres/bin
+
+   (For an annotated `repmgr.conf` file, see `repmgr.conf.sample` in the
+   repository's root directory).
+
+3. Register the master node with `repmgr`:
+
+        $ repmgr -f $HOME/repmgr/repmgr.conf --verbose master register
+        [2014-07-04 10:43:42] [INFO] repmgr mgr connecting to master database
+        [2014-07-04 10:43:42] [INFO] repmgr connected to master, checking its state
+        [2014-07-04 10:43:42] [INFO] master register: creating database objects inside the repmgr_test schema
+        [2014-07-04 10:43:43] [NOTICE] Master node correctly registered for cluster test with id 1 (conninfo: host=localhost user=repmgr_usr dbname=repmgr_db)
+
+
+Slave/standby setup
+-------------------
+
+1. Use `repmgr` to clone the master:
+
+        $ repmgr -D $PGDATA -d repmgr_db -U repmgr_usr -R postgres --verbose standby clone 192.168.1.2
+        Opening configuration file: ./repmgr.conf
+        [2014-07-04 10:49:00] [ERROR] Did not find the configuration file './repmgr.conf', continuing
+        [2014-07-04 10:49:00] [INFO] repmgr connecting to master database
+        [2014-07-04 10:49:00] [INFO] repmgr connected to master, checking its state
+        [2014-07-04 10:49:00] [INFO] Successfully connected to primary. Current installation size is 1807 MB
+        [2014-07-04 10:49:00] [NOTICE] Starting backup...
+        [2014-07-04 10:49:00] [INFO] creating directory "/path/to/data/"...
+        (...)
+        [2014-07-04 10:53:19] [NOTICE] Finishing backup...
+        NOTICE:  pg_stop_backup complete, all required WAL segments have been archived
+        [2014-07-04 10:53:21] [INFO] repmgr requires primary to keep WAL files 0000000100000000000000AD until at least 0000000100000000000000AD
+        [2014-07-04 10:53:21] [NOTICE] repmgr standby clone complete
+        [2014-07-04 10:53:21] [NOTICE] HINT: You can now start your postgresql server
+        [2014-07-04 10:53:21] [NOTICE] for example : /etc/init.d/postgresql start
+
+  -R is the database system user on the master node. At this point it does not matter
+  if the `repmgr.conf` file is not found.
+
+  This will clone the PostgreSQL database files from the master, including its
+  `postgresql.conf` and `pg_hba.conf` files, and additionally automatically create
+  the `recovery.conf` file containing the correct parameters to start streaming
+  from the primary node.
+
+2. Start the PostgreSQL server
+
+3. Create the `repmgr` configuration file:
+
+        $ cat $HOME/repmgr/repmgr.conf
+        cluster=test
+        node=2
+        node_name=node2
+        conninfo='host=repmgr_node2 user=repmgr_usr dbname=repmgr_db'
+        pg_bindir=/path/to/postgres/bin
+
+4. Register the master node with `repmgr`:
+
+        $ repmgr -f $HOME/repmgr/repmgr.conf --verbose standby register
+        Opening configuration file: /path/to/repmgr/repmgr.conf
+        [2014-07-04 11:48:13] [INFO] repmgr connecting to standby database
+        [2014-07-04 11:48:13] [INFO] repmgr connected to standby, checking its state
+        [2014-07-04 11:48:13] [INFO] repmgr connecting to master database
+        [2014-07-04 11:48:13] [INFO] finding node list for cluster 'test'
+        [2014-07-04 11:48:13] [INFO] checking role of cluster node 'host=repmgr_node1 user=repmgr_usr dbname=repmgr_db'
+        [2014-07-04 11:48:13] [INFO] repmgr connected to master, checking its state
+        [2014-07-04 11:48:13] [INFO] repmgr registering the standby
+        [2014-07-04 11:48:13] [INFO] repmgr registering the standby complete
+        [2014-07-04 11:48:13] [NOTICE] Standby node correctly registered for cluster test with id 2 (conninfo: host=localhost user=repmgr_usr dbname=repmgr_db)
+
+Monitoring
+----------
+
+`repmgrd` is a management and monitoring daemon which runs on standby nodes
+and which and can automate remote actions. It can be started simply with e.g.:
+
+    repmgrd -f $HOME/repmgr/repmgr.conf --verbose > $HOME/repmgr/repmgr.log 2>&1
+
+or alternatively:
+
+    repmgrd -f $HOME/repmgr/repmgr.conf --verbose --monitoring-history > $HOME/repmgr/repmgrd.log 2>&1
+
+which will track advance or lag of the replication in every standby in the
+`repl_monitor` table.
+
+Example log output:
+
+    [2014-07-04 11:55:17] [INFO] repmgrd Connecting to database 'host=localhost user=repmgr_usr dbname=repmgr_db'
+    [2014-07-04 11:55:17] [INFO] repmgrd Connected to database, checking its state
+    [2014-07-04 11:55:17] [INFO] repmgrd Connecting to primary for cluster 'test'
+    [2014-07-04 11:55:17] [INFO] finding node list for cluster 'test'
+    [2014-07-04 11:55:17] [INFO] checking role of cluster node 'host=repmgr_node1 user=repmgr_usr dbname=repmgr_db'
+    [2014-07-04 11:55:17] [INFO] repmgrd Checking cluster configuration with schema 'repmgr_test'
+    [2014-07-04 11:55:17] [INFO] repmgrd Checking node 2 in cluster 'test'
+    [2014-07-04 11:55:17] [INFO] Reloading configuration file and updating repmgr tables
+    [2014-07-04 11:55:17] [INFO] repmgrd Starting continuous standby node monitoring
+
+
+Failover
+--------
+
+To promote a standby to master, on the standby execute e.g.:
+
+    repmgr -f  $HOME/repmgr/repmgr.conf --verbose standby promote
+
+`repmgr` will attempt to connect to the current master to verify that it
+is not available (if it is, `repmgr` will not promote the standby).
+
+Other standby servers need to be told to follow the new master with:
+
+    repmgr -f  $HOME/repmgr/repmgr.conf --verbose standby follow
+
+See file `autofailover_quick_setup.rst` for details on setting up
+automated failover.
+
+
+repmgr database schema
+----------------------
+
+`repmgr` creates a small schema for its own use in the database specified in
+each node's conninfo configuration parameter. This database can in principle
+be any database. The schema name is the global `cluster` name prefixed
+with `repmgr_`, so for the example setup above the schema name is
+`repmgr_test`.
+
+The schema contains two tables:
+
+* `repl_nodes`
+  stores information about all registered servers in the cluster
+* `repl_monitor`
+  stores monitoring information about each node
+
+and one view, `repl_status`, which summarizes the latest monitoring information
+for each node.
+
+
+Further reading
+---------------
+
+* http://blog.2ndquadrant.com/announcing-repmgr-2-0/
+* http://blog.2ndquadrant.com/managing-useful-clusters-repmgr/
+* http://blog.2ndquadrant.com/easier_postgresql_90_clusters/
+

README.rst

@@ -23,7 +23,7 @@ databases as a single cluster.  repmgr includes two components:
 Supported Releases
 ------------------
 
-repmgr works with PostgreSQL versions 9.0 and superior.
+repmgr works with PostgreSQL versions 9.0 and later.
 
 There are currently no incompatibilities when upgrading repmgr from 9.0 to 9.1,
 so your 9.0 configuration will work with 9.1
@@ -77,7 +77,7 @@ and run::
   
 And if a previously failed node becomes available again, such as
 the lost node1 above, you can get it to resynchronize by only copying
-over changes made while it was down using.  That hapens with what's
+over changes made while it was down.  That happens with what's
 called a forced clone, which overwrites existing data rather than
 assuming it starts with an empty database directory tree::
 
@@ -131,19 +131,19 @@ If you need to remove the source code temporary files from this directory,
 that can be done like this::
 
   make USE_PGXS=1 clean
-  
+
 See below for building notes specific to RedHat Linux variants.
 
 Using a full source code tree
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 In this method, the repmgr distribution is copied into the PostgreSQL source
-code tree, assumed to be at the ${postgresql_sources} for this example.
+code tree, assumed to be under ${postgresql_sources} for this example.
 The resulting subdirectory must be named ``contrib/repmgr``, without any
 version number::
 
   cp repmgr.tar.gz ${postgresql_sources}/contrib
-  cd ${postgresql_sources}/contrib 
+  cd ${postgresql_sources}/contrib
   tar xvzf repmgr-1.0.tar.gz
   cd repmgr
   make
@@ -237,7 +237,7 @@ If you already tried to build repmgr before doing this, you'll need to do::
 
     make USE_PGXS=1 clean
 
-To get rid of leftover files from the wrong architecture.
+to get rid of leftover files from the wrong architecture.
 
 Notes on Ubuntu, Debian or other Debian-based Builds
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -279,8 +279,8 @@ Confirm software was built correctly
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You should now find the repmgr programs available in the subdirectory where
-the rest of your PostgreSQL installation is at.  You can confirm the software
+the rest of your PostgreSQL binary files are located.  You can confirm the
-is available by checking its version::
+software is available by checking its version::
 
   repmgr --version
   repmgrd --version
@@ -374,10 +374,10 @@ Usage walkthrough
 This assumes you've already followed the steps in "Installation Outline" to
 install repmgr and repmgrd on the system.
 
-A normal production installation of ``repmgr`` will normally involve two
+A typical production installation of ``repmgr`` might involve two PostgreSQL
-different systems running on the same port, typically the default of 5432, 
+instances on seperate servers, both running under the ``postgres`` user account
-with both using files owned by the ``postgres`` user account.  This
+and both using the default port (5432). This walkthrough assumes the following
-walkthrough assumes the following setup:
+setup:
 
 * A primary (master) server called "node1," running as the "postgres" user 
   who is also the owner of the files. This server is operating on port 5432.  This
@@ -427,7 +427,7 @@ system you already have superuser access to.
 Clearing the PostgreSQL installation on the Standby
 ---------------------------------------------------
 
-To setup a new streaming replica, startin by removing any PostgreSQL
+To setup a new streaming replica, start by removing any PostgreSQL
 installation on the existing standby nodes.
 
 * Stop any server on "node2" and "node3".  You can confirm the database
@@ -625,18 +625,18 @@ Now restore to the original configuration by stopping
 primary server, then bringing up "node2" as a standby with a valid
 ``recovery.conf`` file.
 
-Stop the "node2" server::
+Stop the "node2" server and type the following on "node1" server::
 
   repmgr -f /var/lib/pgsql/repmgr/repmgr.conf standby promote
 
-Now the original primary, "node1" is acting again as primary.
+Now the original primary, "node1", is acting again as primary.
 
-Start the "node2" server and type this on "node1"::
+Start the "node2" server and type this on "node2"::
 
   repmgr standby clone --force -h node2 -p 5432 -U postgres -R postgres --verbose
 
-Verify the roles have reversed by attempting to insert a record on "node"
+Verify the roles have reversed by attempting to insert a record on "node1"
-and on "node1".
+and on "node2".
 
 The servers are now again acting as primary on "node1" and standby on "node2".
 
@@ -660,7 +660,7 @@ You can usually leave out changes to the port number in this case too.
 
 * A database exists on "prime" called "testdb."
 
-* The Postgress installation in each of the above is defined as $PGDATA, 
+* The Postgres installation in each of the above is defined as $PGDATA, 
   which is represented here with ``/data/prime`` as the "prime" server and 
   ``/data/standby`` as the "standby" server.
 
@@ -890,7 +890,7 @@ The output from this program looks like this::
 
   Configuration options:
     -D, --data-dir=DIR         local directory where the files will be copied to
-    -f, --config_file=PATH     path to the configuration file
+    -f, --config-file=PATH     path to the configuration file
     -R, --remote-user=USERNAME database server username for rsync
     -w, --wal-keep-segments=VALUE  minimum value for the GUC wal_keep_segments (default: 5000)
     -I, --ignore-rsync-warning ignore rsync partial transfer warning
@@ -1014,7 +1014,7 @@ The output from this program looks like this::
     --version                 output version information, then exit
     --verbose                 output verbose activity information
     --monitoring-history      track advance or lag of the replication in every standby in repl_monitor
-    -f, --config_file=PATH    database to connect to
+    -f, --config-file=PATH    path to the configuration file
   
   repmgrd monitors a cluster of servers.
 

RHEL/repmgr.spec

@@ -0,0 +1,57 @@
+Summary: repmgr
+Name: repmgr
+Version: 2.0
+Release: 2
+License: GPLv3
+Group: System Environment/Daemons
+URL: http://repmgr.org 
+Packager: Nathan Van Overloop <nathan.van.overloop@nexperteam.be>
+Vendor: 2ndQuadrant Limited
+Distribution: centos
+Source0: %{name}-%{version}.tar.gz
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
+
+%description
+repmgr for centos6
+
+%prep
+%setup
+
+%build
+export PATH=$PATH:/usr/pgsql-9.3/bin/
+%{__make} USE_PGXS=1
+
+%install
+[ "%{buildroot}" != "/" ] && %{__rm} -rf %{buildroot}
+
+export PATH=$PATH:/usr/pgsql-9.3/bin/
+%{__make} USE_PGXS=1 install DESTDIR=%{buildroot} INSTALL="install -p"
+%{__make} USE_PGXS=1 install_prog DESTDIR=%{buildroot} INSTALL="install -p"
+%{__make} USE_PGXS=1 install_rhel DESTDIR=%{buildroot} INSTALL="install -p"
+
+
+%clean
+[ "%{buildroot}" != "/" ] && %{__rm} -rf %{buildroot}
+ 
+
+%files
+%defattr(-,root,root)
+/usr/bin/repmgr
+/usr/bin/repmgrd
+/usr/pgsql-9.3/bin/repmgr
+/usr/pgsql-9.3/bin/repmgrd
+/usr/pgsql-9.3/lib/repmgr_funcs.so
+/usr/pgsql-9.3/share/contrib/repmgr.sql
+/usr/pgsql-9.3/share/contrib/repmgr_funcs.sql
+/usr/pgsql-9.3/share/contrib/uninstall_repmgr.sql
+/usr/pgsql-9.3/share/contrib/uninstall_repmgr_funcs.sql
+%attr(0755,root,root)/etc/init.d/repmgrd 
+%attr(0644,root,root)/etc/sysconfig/repmgrd
+%attr(0644,root,root)/etc/repmgr/repmgr.conf.sample
+
+%changelog
+* Thu Jun 05 2014 Nathan Van Overloop <nathan.van.overloop@nexperteam.be> 2.0.2
+- fix witness creation to create db and user if needed
+* Fri Apr 04 2014 Nathan Van Overloop <nathan.van.overloop@nexperteam.be> 2.0.1
+- initial build for RHEL6
+

RHEL/repmgrd.init

@@ -0,0 +1,133 @@
+#!/bin/sh
+#
+# chkconfig: - 75 16
+# description: Enable repmgrd replication management and monitoring daemon for PostgreSQL
+# processname: repmgrd
+# pidfile="/var/run/${NAME}.pid"
+
+# Source function library.
+INITD=/etc/rc.d/init.d
+. $INITD/functions
+
+# Get function listing for cross-distribution logic.
+TYPESET=`typeset -f|grep "declare"`
+
+# Get network config.
+. /etc/sysconfig/network
+
+DESC="PostgreSQL replication management and monitoring daemon"
+NAME=repmgrd
+
+REPMGRD_ENABLED=no
+REPMGRD_OPTS=
+REPMGRD_USER=postgres
+REPMGRD_BIN=/usr/pgsql-9.3/bin/repmgrd
+REPMGRD_PIDFILE=/var/run/repmgrd.pid
+REPMGRD_LOCK=/var/lock/subsys/${NAME}
+REPMGRD_LOG=/var/lib/pgsql/9.3/data/pg_log/repmgrd.log
+
+# Read configuration variable file if it is present
+[ -r /etc/sysconfig/$NAME ] && . /etc/sysconfig/$NAME
+
+# For SELinux we need to use 'runuser' not 'su'
+if [ -x /sbin/runuser ]
+then
+    SU=runuser
+else
+    SU=su
+fi
+
+test -x $REPMGRD_BIN || exit 0
+
+case "$REPMGRD_ENABLED" in
+    [Yy]*)
+	break
+	;;
+    *)
+	exit 0
+	;;
+esac
+
+
+if [ -z "${REPMGRD_OPTS}" ]
+then
+    echo "Not starting ${NAME}, REPMGRD_OPTS not set in /etc/sysconfig/${NAME}"
+    exit 0
+fi
+
+start()
+{
+    REPMGRD_START=$"Starting ${NAME} service: "
+
+    # Make sure startup-time log file is valid
+    if [ ! -e "${REPMGRD_LOG}" -a ! -h "${REPMGRD_LOG}" ]
+    then
+        touch "${REPMGRD_LOG}" || exit 1
+        chown ${REPMGRD_USER}:postgres "${REPMGRD_LOG}"
+        chmod go-rwx "${REPMGRD_LOG}"
+        [ -x /sbin/restorecon ] && /sbin/restorecon "${REPMGRD_LOG}"
+    fi
+
+    echo -n "${REPMGRD_START}"
+    $SU -l $REPMGRD_USER -c "${REPMGRD_BIN} ${REPMGRD_OPTS} -p ${REPMGRD_PIDFILE} &" >> "${REPMGRD_LOG}" 2>&1 < /dev/null
+    sleep 2
+    pid=`head -n 1 "${REPMGRD_PIDFILE}" 2>/dev/null`
+    if [ "x${pid}" != "x" ]
+    then
+        success "${REPMGRD_START}"
+        touch "${REPMGRD_LOCK}"
+        echo $pid > "${REPMGRD_PIDFILE}"
+        echo
+    else
+        failure "${REPMGRD_START}"
+        echo
+        script_result=1
+    fi
+}
+
+stop()
+{
+    echo -n $"Stopping ${NAME} service: "
+    if [ -e "${REPMGRD_LOCK}" ]
+    then
+        killproc ${NAME}
+        ret=$? 
+        if [ $ret -eq 0 ]
+        then
+            echo_success
+            rm -f "${REPMGRD_PIDFILE}"
+            rm -f "${REPMGRD_LOCK}"
+        else
+            echo_failure
+            script_result=1
+        fi
+    else
+        # not running; per LSB standards this is "ok"   
+        echo_success
+    fi
+    echo
+}
+
+
+# See how we were called.
+case "$1" in
+  start)
+        start
+        ;;
+  stop)
+        stop
+        ;;
+  status)
+        status -p $REPMGRD_PIDFILE $NAME
+        script_result=$?
+        ;;
+  restart)
+        stop
+	start
+        ;;
+  *)
+        echo $"Usage: $0 {start|stop|status|restart}"
+        exit 2
+esac
+
+exit $script_result

RHEL/repmgrd.sysconfig

@@ -0,0 +1,21 @@
+# default settings for repmgrd. This file is source by /bin/sh from
+# /etc/init.d/repmgrd
+
+# disable repmgrd by default so it won't get started upon installation
+# valid values: yes/no
+REPMGRD_ENABLED=no
+
+# Options for repmgrd (required)
+#REPMGRD_OPTS="--verbose -d -f /var/lib/pgsql/repmgr/repmgr.conf"
+
+# User to run repmgrd as
+#REPMGRD_USER=postgres
+
+# repmgrd binary
+#REPMGRD_BIN=/usr/bin/repmgr
+
+# pid file
+#REPMGRD_PIDFILE=/var/lib/pgsql/repmgr/repmgrd.pid
+
+# log file
+#REPMGRD_LOG=/var/lib/pgsql/repmgr/repmgrd.log

autofailover_quick_setup.rst

@@ -49,19 +49,19 @@ cluster to communicate with other repmgrd daemons.
 
 8. Start the repmgrd daemons in all nodes
 
-**Note** A complete Hight-Availability design need at least 3 servers to still have
+**Note** A complete High-Availability design needs at least 3 servers to still have
 a backup node after a first failure.
 
 Install PostgreSQL
 ------------------
 
 You can install PostgreSQL using any of the recommended methods. You should ensure
-it's 9.0 or superior.
+it's 9.0 or later.
 
 Install repmgr
 --------------
 
-Install repmgr following the steps in the README.
+Install repmgr following the steps in the README file.
 
 Configure PostreSQL
 -------------------
@@ -73,7 +73,7 @@ Edit the file postgresql.conf and modify the parameters::
   listen_addresses='*'
   wal_level = 'hot_standby'
   archive_mode = on
-  archive_command = 'cd .'	 # we can also use exit 0, anything that 
+  archive_command = 'cd .'	 # we can also use exit 0, anything that
                              # just does nothing
   max_wal_senders = 10
   wal_keep_segments = 5000   # 80 GB required on pg_xlog
@@ -217,7 +217,7 @@ Edit the repmgr.conf of the node to remove from automatic processing and change:
 Then, signal repmgrd daemon::
 
 	su - postgres
-	kill -HUP `pidoff repmgrd`
+	kill -HUP `pidof repmgrd`
 
 Usage
 =====

check_dir.c

@@ -44,9 +44,9 @@
 int
 check_dir(char *dir)
 {
-	DIR        *chkdir;
+	DIR		   *chkdir;
-	struct 		dirent *file;
+	struct dirent *file;
-	int         result = 1;
+	int			result = 1;
 
 	errno = 0;
 
@@ -58,7 +58,7 @@ check_dir(char *dir)
 	while ((file = readdir(chkdir)) != NULL)
 	{
 		if (strcmp(".", file->d_name) == 0 ||
-		        strcmp("..", file->d_name) == 0)
+			strcmp("..", file->d_name) == 0)
 		{
 			/* skip this and parent directory */
 			continue;
@@ -71,6 +71,7 @@ check_dir(char *dir)
 	}
 
 #ifdef WIN32
+
 	/*
 	 * This fix is in mingw cvs (runtime/mingwex/dirent.c rev 1.4), but not in
 	 * released version
@@ -82,29 +83,29 @@ check_dir(char *dir)
 	closedir(chkdir);
 
 	if (errno != 0)
-		return -1;          /* some kind of I/O error? */
+		return -1;				/* some kind of I/O error? */
 
 	return result;
 }
 
 
 /*
- * Create directory
+ * Create directory with error log message when failing
  */
 bool
-create_directory(char *dir)
+create_dir(char *dir)
 {
 	if (mkdir_p(dir, 0700) == 0)
 		return true;
 
 	log_err(_("Could not create directory \"%s\": %s\n"),
-	        dir, strerror(errno));
+			dir, strerror(errno));
 
 	return false;
 }
 
 bool
-set_directory_permissions(char *dir)
+set_dir_permissions(char *dir)
 {
 	return (chmod(dir, 0700) != 0) ? false : true;
 }
@@ -127,10 +128,10 @@ mkdir_p(char *path, mode_t omode)
 {
 	struct stat sb;
 	mode_t		numask,
-	            oumask;
+				oumask;
 	int			first,
-	            last,
+				last,
-	            retval;
+				retval;
 	char	   *p;
 
 	p = path;
@@ -149,8 +150,8 @@ mkdir_p(char *path, mode_t omode)
 				return 1;
 		}
 		else if (p[1] == ':' &&
-		         ((p[0] >= 'a' && p[0] <= 'z') ||
+				 ((p[0] >= 'a' && p[0] <= 'z') ||
-		          (p[0] >= 'A' && p[0] <= 'Z')))
+				  (p[0] >= 'A' && p[0] <= 'Z')))
 		{
 			/* local drive */
 			p += 2;
@@ -221,9 +222,9 @@ bool
 is_pg_dir(char *dir)
 {
 	const size_t buf_sz = 8192;
-	char		 path[buf_sz];
+	char		path[buf_sz];
-	struct stat	 sb;
+	struct stat sb;
-	int		r;
+	int			r;
 
 	/* test pgdata */
 	xsnprintf(path, buf_sz, "%s/PG_VERSION", dir);
@@ -241,67 +242,67 @@ is_pg_dir(char *dir)
 
 
 bool
-create_pgdir(char *dir, bool force)
+create_pg_dir(char *dir, bool force)
 {
-	bool	pg_dir = false;
+	bool		pg_dir = false;
 
 	/* Check this directory could be used as a PGDATA dir */
 	switch (check_dir(dir))
 	{
-	case 0:
+		case 0:
-		/* dir not there, must create it */
+			/* dir not there, must create it */
-		log_info(_("creating directory \"%s\"...\n"), dir);
+			log_info(_("creating directory \"%s\"...\n"), dir);
 
-		if (!create_directory(dir))
+			if (!create_dir(dir))
-		{
+			{
-			log_err(_("couldn't create directory \"%s\"...\n"),
+				log_err(_("couldn't create directory \"%s\"...\n"),
-			        dir);
+						dir);
-			return false;
+				return false;
-		}
+			}
-		break;
-	case 1:
-		/* Present but empty, fix permissions and use it */
-		log_info(_("checking and correcting permissions on existing directory %s ...\n"),
-		         dir);
-
-		if (!set_directory_permissions(dir))
-		{
-			log_err(_("could not change permissions of directory \"%s\": %s\n"),
-			        dir, strerror(errno));
-			return false;
-		}
-		break;
-	case 2:
-		/* Present and not empty */
-		log_warning(_("directory \"%s\" exists but is not empty\n"),
-		            dir);
-
-		pg_dir = is_pg_dir(dir);
-
-		/*
-		 * we use force to reduce the time needed to restore a node which
-		 * turn async after a failover or anything else
-		 */
-		if (pg_dir && force)
-		{
-			/* Let it continue */
 			break;
-		}
+		case 1:
-		else if (pg_dir && !force)
+			/* Present but empty, fix permissions and use it */
-		{
+			log_info(_("checking and correcting permissions on existing directory %s ...\n"),
-			log_warning(_("\nThis looks like a PostgreSQL directory.\n"
+					 dir);
-			              "If you are sure you want to clone here, "
-			              "please check there is no PostgreSQL server "
-			              "running and use the --force option\n"));
-			return false;
-		}
 
-		return false;
+			if (!set_dir_permissions(dir))
-	default:
+			{
-		/* Trouble accessing directory */
+				log_err(_("could not change permissions of directory \"%s\": %s\n"),
-		log_err(_("could not access directory \"%s\": %s\n"),
+						dir, strerror(errno));
-		        dir, strerror(errno));
+				return false;
-		return false;
+			}
+			break;
+		case 2:
+			/* Present and not empty */
+			log_warning(_("directory \"%s\" exists but is not empty\n"),
+						dir);
+
+			pg_dir = is_pg_dir(dir);
+
+			/*
+			 * we use force to reduce the time needed to restore a node which
+			 * turn async after a failover or anything else
+			 */
+			if (pg_dir && force)
+			{
+				/* Let it continue */
+				break;
+			}
+			else if (pg_dir && !force)
+			{
+				log_warning(_("\nThis looks like a PostgreSQL directory.\n"
+							  "If you are sure you want to clone here, "
+							  "please check there is no PostgreSQL server "
+							  "running and use the --force option\n"));
+				return false;
+			}
+
+			return false;
+		default:
+			/* Trouble accessing directory */
+			log_err(_("could not access directory \"%s\": %s\n"),
+					dir, strerror(errno));
+			return false;
 	}
 	return true;
 }

check_dir.h

@@ -20,11 +20,11 @@
 #ifndef _REPMGR_CHECK_DIR_H_
 #define _REPMGR_CHECK_DIR_H_
 
-int mkdir_p(char *path, mode_t omode);
+int			mkdir_p(char *path, mode_t omode);
-int  check_dir(char *dir);
+int			check_dir(char *dir);
-bool create_directory(char *dir);
+bool		create_dir(char *dir);
-bool set_directory_permissions(char *dir);
+bool		set_dir_permissions(char *dir);
-bool is_pg_dir(char *dir);
+bool		is_pg_dir(char *dir);
-bool create_pgdir(char *dir, bool force);
+bool		create_pg_dir(char *dir, bool force);
 
 #endif

config.c

@@ -23,13 +23,14 @@
 #include "repmgr.h"
 
 void
-parse_config(const char *config_file, t_configuration_options *options)
+parse_config(const char *config_file, t_configuration_options * options)
 {
-	char *s, buff[MAXLINELENGTH];
+	char	   *s,
-	char name[MAXLEN];
+				buff[MAXLINELENGTH];
-	char value[MAXLEN];
+	char		name[MAXLEN];
+	char		value[MAXLEN];
 
-	FILE *fp = fopen (config_file, "r");
+	FILE	   *fp = fopen(config_file, "r");
 
 	/* Initialize */
 	memset(options->cluster_name, 0, sizeof(options->cluster_name));
@@ -56,17 +57,18 @@ parse_config(const char *config_file, t_configuration_options *options)
 	options->retry_promote_interval_secs = 300;
 
 	/*
-	 * Since some commands don't require a config file at all, not
+	 * Since some commands don't require a config file at all, not having one
-	 * having one isn't necessarily a problem.
+	 * isn't necessarily a problem.
 	 */
 	if (fp == NULL)
 	{
-		log_err(_("Did not find the configuration file '%s', continuing\n"), config_file);
+		log_err(_("Did not find the configuration file '%s', continuing\n"),
+				config_file);
 		return;
 	}
 
 	/* Read next line */
-	while ((s = fgets (buff, sizeof buff, fp)) != NULL)
+	while ((s = fgets(buff, sizeof buff, fp)) != NULL)
 	{
 		/* Skip blank lines and comments */
 		if (buff[0] == '\n' || buff[0] == '#')
@@ -77,22 +79,23 @@ parse_config(const char *config_file, t_configuration_options *options)
 
 		/* Copy into correct entry in parameters struct */
 		if (strcmp(name, "cluster") == 0)
-			strncpy (options->cluster_name, value, MAXLEN);
+			strncpy(options->cluster_name, value, MAXLEN);
 		else if (strcmp(name, "node") == 0)
 			options->node = atoi(value);
 		else if (strcmp(name, "conninfo") == 0)
-			strncpy (options->conninfo, value, MAXLEN);
+			strncpy(options->conninfo, value, MAXLEN);
 		else if (strcmp(name, "rsync_options") == 0)
-			strncpy (options->rsync_options, value, QUERY_STR_LEN);
+			strncpy(options->rsync_options, value, QUERY_STR_LEN);
 		else if (strcmp(name, "ssh_options") == 0)
-			strncpy (options->ssh_options, value, QUERY_STR_LEN);
+			strncpy(options->ssh_options, value, QUERY_STR_LEN);
 		else if (strcmp(name, "loglevel") == 0)
-			strncpy (options->loglevel, value, MAXLEN);
+			strncpy(options->loglevel, value, MAXLEN);
 		else if (strcmp(name, "logfacility") == 0)
-			strncpy (options->logfacility, value, MAXLEN);
+			strncpy(options->logfacility, value, MAXLEN);
 		else if (strcmp(name, "failover") == 0)
 		{
-			char failoverstr[MAXLEN];
+			char		failoverstr[MAXLEN];
+
 			strncpy(failoverstr, value, MAXLEN);
 
 			if (strcmp(failoverstr, "manual") == 0)
@@ -120,9 +123,9 @@ parse_config(const char *config_file, t_configuration_options *options)
 		else if (strcmp(name, "reconnect_interval") == 0)
 			options->reconnect_intvl = atoi(value);
 		else if (strcmp(name, "pg_bindir") == 0)
-			strncpy (options->pg_bindir, value, MAXLEN);
+			strncpy(options->pg_bindir, value, MAXLEN);
 		else if (strcmp(name, "pg_ctl_options") == 0)
-			strncpy (options->pgctl_options, value, MAXLEN);
+			strncpy(options->pgctl_options, value, MAXLEN);
 		else if (strcmp(name, "logfile") == 0)
 			strncpy(options->logfile, value, MAXLEN);
 		else if (strcmp(name, "monitor_interval_secs") == 0)
@@ -134,10 +137,10 @@ parse_config(const char *config_file, t_configuration_options *options)
 	}
 
 	/* Close file */
-	fclose (fp);
+	fclose(fp);
 
 	/* Check config settings */
-	if (strnlen(options->cluster_name, MAXLEN)==0)
+	if (*options->cluster_name == '\0')
 	{
 		log_err(_("Cluster name is missing. Check the configuration file.\n"));
 		exit(ERR_BAD_CONFIG);
@@ -176,22 +179,27 @@ parse_config(const char *config_file, t_configuration_options *options)
 
 
 char *
-trim (char *s)
+trim(char *s)
 {
 	/* Initialize start, end pointers */
-	char *s1 = s, *s2 = &s[strlen (s) - 1];
+	char	   *s1 = s,
+			   *s2 = &s[strlen(s) - 1];
+
+	/* If string is empty, no action needed */
+	if(s2 < s1)
+		return s;
 
 	/* Trim and delimit right side */
-	while ( (isspace (*s2)) && (s2 >= s1) )
+	while ((isspace(*s2)) && (s2 >= s1))
 		--s2;
-	*(s2+1) = '\0';
+	*(s2 + 1) = '\0';
 
 	/* Trim left side */
-	while ( (isspace (*s1)) && (s1 < s2) )
+	while ((isspace(*s1)) && (s1 < s2))
 		++s1;
 
 	/* Copy finished string */
-	memmove (s, s1, s2 - s1);
+	memmove(s, s1, s2 - s1);
 	s[s2 - s1 + 1] = '\0';
 
 	return s;
@@ -200,13 +208,13 @@ trim (char *s)
 void
 parse_line(char *buff, char *name, char *value)
 {
-	int i = 0;
+	int			i = 0;
-	int j = 0;
+	int			j = 0;
 
 	/*
 	 * first we find the name of the parameter
 	 */
-	for ( ; i < MAXLEN; ++i)
+	for (; i < MAXLEN; ++i)
 	{
 		if (buff[i] != '=')
 			name[j++] = buff[i];
@@ -219,7 +227,7 @@ parse_line(char *buff, char *name, char *value)
 	 * Now the value
 	 */
 	j = 0;
-	for ( ++i ; i < MAXLEN; ++i)
+	for (++i; i < MAXLEN; ++i)
 		if (buff[i] == '\'')
 			continue;
 		else if (buff[i] != '\n')
@@ -231,9 +239,9 @@ parse_line(char *buff, char *name, char *value)
 }
 
 bool
-reload_configuration(char *config_file, t_configuration_options *orig_options)
+reload_config(char *config_file, t_configuration_options * orig_options)
 {
-	PGconn	*conn;
+	PGconn	   *conn;
 
 	t_configuration_options new_options;
 
@@ -291,7 +299,7 @@ reload_configuration(char *config_file, t_configuration_options *orig_options)
 	}
 
 	/* Test conninfo string */
-	conn = establishDBConnection(new_options.conninfo, false);
+	conn = establish_db_connection(new_options.conninfo, false);
 	if (!conn || (PQstatus(conn) != CONNECTION_OK))
 	{
 		log_warning(_("conninfo string is not valid, will keep current configuration.\n"));
@@ -313,16 +321,16 @@ reload_configuration(char *config_file, t_configuration_options *orig_options)
 	orig_options->master_response_timeout = new_options.master_response_timeout;
 	orig_options->reconnect_attempts = new_options.reconnect_attempts;
 	orig_options->reconnect_intvl = new_options.reconnect_intvl;
+
 	/*
 	 * XXX These ones can change with a simple SIGHUP?
-
+	 *
-		strcpy (orig_options->loglevel, new_options.loglevel);
+	 * strcpy (orig_options->loglevel, new_options.loglevel); strcpy
-		strcpy (orig_options->logfacility, new_options.logfacility);
+	 * (orig_options->logfacility, new_options.logfacility);
-
+	 *
-		logger_shutdown();
+	 * logger_shutdown(); XXX do we have progname here ? logger_init(progname,
-		XXX do we have progname here ?
+	 * orig_options.loglevel, orig_options.logfacility);
-		logger_init(progname, orig_options.loglevel, orig_options.logfacility);
+	 */
-	*/
 
 	return true;
 }

config.h

@@ -25,33 +25,33 @@
 
 typedef struct
 {
-	char cluster_name[MAXLEN];
+	char		cluster_name[MAXLEN];
-	int node;
+	int			node;
-	char conninfo[MAXLEN];
+	char		conninfo[MAXLEN];
-	int failover;
+	int			failover;
-	int priority;
+	int			priority;
-	char node_name[MAXLEN];
+	char		node_name[MAXLEN];
-	char promote_command[MAXLEN];
+	char		promote_command[MAXLEN];
-	char follow_command[MAXLEN];
+	char		follow_command[MAXLEN];
-	char loglevel[MAXLEN];
+	char		loglevel[MAXLEN];
-	char logfacility[MAXLEN];
+	char		logfacility[MAXLEN];
-	char rsync_options[QUERY_STR_LEN];
+	char		rsync_options[QUERY_STR_LEN];
-	char ssh_options[QUERY_STR_LEN];
+	char		ssh_options[QUERY_STR_LEN];
-	int  master_response_timeout;
+	int			master_response_timeout;
-	int  reconnect_attempts;
+	int			reconnect_attempts;
-	int  reconnect_intvl;
+	int			reconnect_intvl;
-	char pg_bindir[MAXLEN];
+	char		pg_bindir[MAXLEN];
-	char pgctl_options[MAXLEN];
+	char		pgctl_options[MAXLEN];
-	char logfile[MAXLEN];
+	char		logfile[MAXLEN];
-	int monitor_interval_secs;
+	int			monitor_interval_secs;
-	int retry_promote_interval_secs;
+	int			retry_promote_interval_secs;
-} t_configuration_options;
+}	t_configuration_options;
 
 #define T_CONFIGURATION_OPTIONS_INITIALIZER { "", -1, "", MANUAL_FAILOVER, -1, "", "", "", "", "", "", "", -1, -1, -1, "", "", "", 0, 0 }
 
-void parse_config(const char *config_file, t_configuration_options *options);
+void		parse_config(const char *config_file, t_configuration_options * options);
-void parse_line(char *buff, char *name, char *value);
+void		parse_line(char *buff, char *name, char *value);
-char *trim(char *s);
+char	   *trim(char *s);
-bool reload_configuration(char *config_file, t_configuration_options *orig_options);
+bool		reload_config(char *config_file, t_configuration_options * orig_options);
 
 #endif

dbutils.c

@@ -26,11 +26,11 @@
 #include "log.h"
 
 PGconn *
-establishDBConnection(const char *conninfo, const bool exit_on_error)
+establish_db_connection(const char *conninfo, const bool exit_on_error)
 {
 	/* Make a connection to the database */
-	PGconn *conn = NULL;
+	PGconn	   *conn = NULL;
-	char    connection_string[MAXLEN];
+	char		connection_string[MAXLEN];
 
 	strcpy(connection_string, conninfo);
 	strcat(connection_string, " fallback_application_name='repmgr'");
@@ -40,7 +40,7 @@ establishDBConnection(const char *conninfo, const bool exit_on_error)
 	if ((PQstatus(conn) != CONNECTION_OK))
 	{
 		log_err(_("Connection to database failed: %s\n"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 
 		if (exit_on_error)
 		{
@@ -53,16 +53,17 @@ establishDBConnection(const char *conninfo, const bool exit_on_error)
 }
 
 PGconn *
-establishDBConnectionByParams(const char *keywords[], const char *values[],const bool exit_on_error)
+establish_db_connection_by_params(const char *keywords[], const char *values[],
+								  const bool exit_on_error)
 {
 	/* Make a connection to the database */
-	PGconn *conn = PQconnectdbParams(keywords, values, true);
+	PGconn	   *conn = PQconnectdbParams(keywords, values, true);
 
 	/* Check to see that the backend connection was successfully made */
 	if ((PQstatus(conn) != CONNECTION_OK))
 	{
 		log_err(_("Connection to database failed: %s\n"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 		if (exit_on_error)
 		{
 			PQfinish(conn);
@@ -84,7 +85,7 @@ is_standby(PGconn *conn)
 	if (res == NULL || PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
 		log_err(_("Can't query server mode: %s"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 		result = -1;
 	}
 	else if (PQntuples(res) == 1 && strcmp(PQgetvalue(res, 0, 0), "t") == 0)
@@ -104,7 +105,7 @@ is_witness(PGconn *conn, char *schema, char *cluster, int node_id)
 	char		sqlquery[QUERY_STR_LEN];
 
 	sqlquery_snprintf(sqlquery, "SELECT witness from %s.repl_nodes where cluster = '%s' and id = %d",
-	                  schema, cluster, node_id);
+					  schema, cluster, node_id);
 	res = PQexec(conn, sqlquery);
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
@@ -124,6 +125,7 @@ bool
 is_pgup(PGconn *conn, int timeout)
 {
 	char		sqlquery[QUERY_STR_LEN];
+
 	/* Check the connection status twice in case it changes after reset */
 	bool		twice = false;
 
@@ -134,15 +136,15 @@ is_pgup(PGconn *conn, int timeout)
 		{
 			if (twice)
 				return false;
-			PQreset(conn);  /* reconnect */
+			PQreset(conn);		/* reconnect */
 			twice = true;
 		}
 		else
 		{
 			/*
-			* Send a SELECT 1 just to check if the connection is OK
+			 * Send a SELECT 1 just to check if the connection is OK
-			*/
+			 */
-			if (!CancelQuery(conn, timeout))
+			if (!cancel_query(conn, timeout))
 				goto failed;
 			if (wait_connection_availability(conn, timeout) != 1)
 				goto failed;
@@ -151,7 +153,7 @@ is_pgup(PGconn *conn, int timeout)
 			if (PQsendQuery(conn, sqlquery) == 0)
 			{
 				log_warning(_("PQsendQuery: Query could not be sent to primary. %s\n"),
-				            PQerrorMessage(conn));
+							PQerrorMessage(conn));
 				goto failed;
 			}
 			if (wait_connection_availability(conn, timeout) != 1)
@@ -159,11 +161,15 @@ is_pgup(PGconn *conn, int timeout)
 
 			break;
 
-failed:
+	failed:
-			/* we need to retry, because we might just have loose the connection once */
+
+			/*
+			 * we need to retry, because we might just have loose the
+			 * connection once
+			 */
 			if (twice)
 				return false;
-			PQreset(conn);  /* reconnect */
+			PQreset(conn);		/* reconnect */
 			twice = true;
 		}
 	}
@@ -176,23 +182,23 @@ failed:
  * if 8 or inferior returns an empty string
  */
 char *
-pg_version(PGconn *conn, char* major_version)
+pg_version(PGconn *conn, char *major_version)
 {
-	PGresult	*res;
+	PGresult   *res;
 
-	int					 major_version1;
+	int			major_version1;
-	char				*major_version2;
+	char	   *major_version2;
 
 	res = PQexec(conn,
-	             "WITH pg_version(ver) AS "
+				 "WITH pg_version(ver) AS "
-	             "(SELECT split_part(version(), ' ', 2)) "
+				 "(SELECT split_part(version(), ' ', 2)) "
-	             "SELECT split_part(ver, '.', 1), split_part(ver, '.', 2) "
+				 "SELECT split_part(ver, '.', 1), split_part(ver, '.', 2) "
-	             "FROM pg_version");
+				 "FROM pg_version");
 
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
 		log_err(_("Version check PQexec failed: %s"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 		PQclear(res);
 		return NULL;
 	}
@@ -204,7 +210,7 @@ pg_version(PGconn *conn, char* major_version)
 	{
 		/* form a major version string */
 		xsnprintf(major_version, MAXVERSIONSTR, "%d.%s", major_version1,
-		          major_version2);
+				  major_version2);
 	}
 	else
 		strcpy(major_version, "");
@@ -217,21 +223,21 @@ pg_version(PGconn *conn, char* major_version)
 
 int
 guc_set(PGconn *conn, const char *parameter, const char *op,
-           const char *value)
+		const char *value)
 {
-	PGresult	*res;
+	PGresult   *res;
 	char		sqlquery[QUERY_STR_LEN];
 	int			retval = 1;
 
 	sqlquery_snprintf(sqlquery, "SELECT true FROM pg_settings "
-	                  " WHERE name = '%s' AND setting %s '%s'",
+					  " WHERE name = '%s' AND setting %s '%s'",
-	                  parameter, op, value);
+					  parameter, op, value);
 
 	res = PQexec(conn, sqlquery);
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
 		log_err(_("GUC setting check PQexec failed: %s"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 		retval = -1;
 	}
 	else if (PQntuples(res) == 0)
@@ -249,22 +255,22 @@ guc_set(PGconn *conn, const char *parameter, const char *op,
  * the pg datatype so that the comparison can be done properly.
  */
 int
-guc_set_typed(PGconn *conn, const char *parameter, const char *op, 
+guc_set_typed(PGconn *conn, const char *parameter, const char *op,
-                 const char *value, const char *datatype)
+			  const char *value, const char *datatype)
 {
-	PGresult	*res;
+	PGresult   *res;
 	char		sqlquery[QUERY_STR_LEN];
 	int			retval = 1;
 
 	sqlquery_snprintf(sqlquery, "SELECT true FROM pg_settings "
-	                  " WHERE name = '%s' AND setting::%s %s '%s'::%s",
+					  " WHERE name = '%s' AND setting::%s %s '%s'::%s",
-	                  parameter, datatype, op, value, datatype);
+					  parameter, datatype, op, value, datatype);
 
 	res = PQexec(conn, sqlquery);
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
 		log_err(_("GUC setting check PQexec failed: %s"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 		retval = -1;
 	}
 	else if (PQntuples(res) == 0)
@@ -281,20 +287,20 @@ guc_set_typed(PGconn *conn, const char *parameter, const char *op,
 const char *
 get_cluster_size(PGconn *conn)
 {
-	PGresult	*res;
+	PGresult   *res;
-	const char	*size = NULL;
+	const char *size = NULL;
-	char		 sqlquery[QUERY_STR_LEN];
+	char		sqlquery[QUERY_STR_LEN];
 
 	sqlquery_snprintf(
-	    sqlquery,
+					  sqlquery,
-	    "SELECT pg_size_pretty(SUM(pg_database_size(oid))::bigint) "
+				 "SELECT pg_size_pretty(SUM(pg_database_size(oid))::bigint) "
-	    "	 FROM pg_database ");
+					  "	 FROM pg_database ");
 
 	res = PQexec(conn, sqlquery);
 	if (PQresultStatus(res) != PGRES_TUPLES_OK)
 	{
 		log_err(_("Get cluster size PQexec failed: %s"),
-		        PQerrorMessage(conn));
+				PQerrorMessage(conn));
 	}
 	else
 	{
@@ -309,23 +315,23 @@ get_cluster_size(PGconn *conn)
  * get a connection to master by reading repl_nodes, creating a connection
  * to each node (one at a time) and finding if it is a master or a standby
  *
- * NB: If master_conninfo_out may be NULL.  If it is non-null, it is assumed to
+ * NB: If master_conninfo_out may be NULL.	If it is non-null, it is assumed to
  * point to allocated memory of MAXCONNINFO in length, and the master server
  * connection string is placed there.
  */
 PGconn *
-getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
+get_master_connection(PGconn *standby_conn, char *schema, char *cluster,
-                    int *master_id, char *master_conninfo_out)
+					  int *master_id, char *master_conninfo_out)
 {
-	PGconn		*master_conn	 = NULL;
+	PGconn	   *master_conn = NULL;
-	PGresult	*res1;
+	PGresult   *res1;
-	PGresult	*res2;
+	PGresult   *res2;
-	char		 sqlquery[QUERY_STR_LEN];
+	char		sqlquery[QUERY_STR_LEN];
-	char		 master_conninfo_stack[MAXCONNINFO];
+	char		master_conninfo_stack[MAXCONNINFO];
-	char		*master_conninfo = &*master_conninfo_stack;
+	char	   *master_conninfo = &*master_conninfo_stack;
-	char		 schema_quoted[MAXLEN];
+	char		schema_quoted[MAXLEN];
 
-	int		 i;
+	int			i;
 
 	/*
 	 * If the caller wanted to get a copy of the connection info string, sub
@@ -340,8 +346,8 @@ getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
 	 * Assemble the unquoted schema name
 	 */
 	{
-		char *identifier = PQescapeIdentifier(standby_conn, schema,
+		char	   *identifier = PQescapeIdentifier(standby_conn, schema,
-		                                      strlen(schema));
+													strlen(schema));
 
 		maxlen_snprintf(schema_quoted, "%s", identifier);
 		PQfreemem(identifier);
@@ -349,17 +355,17 @@ getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
 
 	/* find all nodes belonging to this cluster */
 	log_info(_("finding node list for cluster '%s'\n"),
-	         cluster);
+			 cluster);
 
 	sqlquery_snprintf(sqlquery, "SELECT id, conninfo FROM %s.repl_nodes "
-	                  " WHERE cluster = '%s' and not witness",
+					  " WHERE cluster = '%s' and not witness",
-	                  schema_quoted, cluster);
+					  schema_quoted, cluster);
 
 	res1 = PQexec(standby_conn, sqlquery);
 	if (PQresultStatus(res1) != PGRES_TUPLES_OK)
 	{
 		log_err(_("Can't get nodes info: %s\n"),
-		        PQerrorMessage(standby_conn));
+				PQerrorMessage(standby_conn));
 		PQclear(res1);
 		return NULL;
 	}
@@ -370,23 +376,23 @@ getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
 		*master_id = atoi(PQgetvalue(res1, i, 0));
 		strncpy(master_conninfo, PQgetvalue(res1, i, 1), MAXCONNINFO);
 		log_info(_("checking role of cluster node '%s'\n"),
-		         master_conninfo);
+				 master_conninfo);
-		master_conn = establishDBConnection(master_conninfo, false);
+		master_conn = establish_db_connection(master_conninfo, false);
 
 		if (PQstatus(master_conn) != CONNECTION_OK)
 			continue;
 
 		/*
 		 * Can't use the is_standby() function here because on error that
-		 * function closes the connection passed and exits.  This still
+		 * function closes the connection passed and exits.  This still needs
-		 * needs to close master_conn first.
+		 * to close master_conn first.
 		 */
 		res2 = PQexec(master_conn, "SELECT pg_is_in_recovery()");
 
 		if (PQresultStatus(res2) != PGRES_TUPLES_OK)
 		{
 			log_err(_("Can't get recovery state from this node: %s\n"),
-			        PQerrorMessage(master_conn));
+					PQerrorMessage(master_conn));
 			PQclear(res2);
 			PQfinish(master_conn);
 			continue;
@@ -408,14 +414,13 @@ getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
 		}
 	}
 
-	/* If we finish this loop without finding a master then
+	/*
-	 * we doesn't have the info or the master has failed (or we
+	 * If we finish this loop without finding a master then we doesn't have
-	 * reached max_connections or superuser_reserved_connections,
+	 * the info or the master has failed (or we reached max_connections or
-	 * anything else I'm missing?).
+	 * superuser_reserved_connections, anything else I'm missing?).
 	 *
-	 * Probably we will need to check the error to know if we need
+	 * Probably we will need to check the error to know if we need to start
-	 * to start failover procedure or just fix some situation on the
+	 * failover procedure or just fix some situation on the standby.
-	 * standby.
 	 */
 	PQclear(res1);
 	return NULL;
@@ -423,17 +428,19 @@ getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
 
 
 /*
- * wait until current query finishes ignoring any results, this could be an async command
+ * wait until current query finishes ignoring any results, this could be an
- * or a cancelation of a query
+ * async command or a cancelation of a query
  * return 1 if Ok; 0 if any error ocurred; -1 if timeout reached
  */
 int
 wait_connection_availability(PGconn *conn, long long timeout)
 {
 	PGresult   *res;
-	fd_set      read_set;
+	fd_set		read_set;
-	int         sock = PQsocket(conn);
+	int			sock = PQsocket(conn);
-	struct timeval tmout, before, after;
+	struct timeval tmout,
+				before,
+				after;
 	struct timezone tz;
 
 	/* recalc to microseconds */
@@ -450,10 +457,11 @@ wait_connection_availability(PGconn *conn, long long timeout)
 
 		if (PQisBusy(conn) == 0)
 		{
-			do {
+			do
+			{
 				res = PQgetResult(conn);
 				PQclear(res);
-			} while(res != NULL);
+			} while (res != NULL);
 
 			break;
 		}
@@ -469,8 +477,8 @@ wait_connection_availability(PGconn *conn, long long timeout)
 		if (select(sock, &read_set, NULL, NULL, &tmout) == -1)
 		{
 			log_warning(
-				_("wait_connection_availability: select() returned with error: %s"),
+						_("wait_connection_availability: select() returned with error: %s"),
-				strerror(errno));
+						strerror(errno));
 			return -1;
 		}
 		gettimeofday(&after, &tz);
@@ -491,10 +499,10 @@ wait_connection_availability(PGconn *conn, long long timeout)
 
 
 bool
-CancelQuery(PGconn *conn, int timeout)
+cancel_query(PGconn *conn, int timeout)
 {
-	char errbuf[ERRBUFF_SIZE];
+	char		errbuf[ERRBUFF_SIZE];
-	PGcancel *pgcancel;
+	PGcancel   *pgcancel;
 
 	if (wait_connection_availability(conn, timeout) != 1)
 		return false;
@@ -505,9 +513,8 @@ CancelQuery(PGconn *conn, int timeout)
 		return false;
 
 	/*
-	 * PQcancel can only return 0 if socket()/connect()/send()
+	 * PQcancel can only return 0 if socket()/connect()/send() fails, in any
- 	 * fails, in any of those cases we can assume something
+	 * of those cases we can assume something bad happened to the connection
-	 * bad happened to the connection
 	 */
 	if (PQcancel(pgcancel, errbuf, ERRBUFF_SIZE) == 0)
 	{

dbutils.h

@@ -22,23 +22,25 @@
 
 #include "strutil.h"
 
-PGconn *establishDBConnection(const char *conninfo, const bool exit_on_error);
+PGconn *establish_db_connection(const char *conninfo,
-PGconn *establishDBConnectionByParams(const char *keywords[],
+						const bool exit_on_error);
-                                      const char *values[],
+PGconn *establish_db_connection_by_params(const char *keywords[],
-                                      const bool exit_on_error);
+								  const char *values[],
-int     is_standby(PGconn *conn);
+								  const bool exit_on_error);
-int     is_witness(PGconn *conn, char *schema, char *cluster, int node_id);
+int			is_standby(PGconn *conn);
-bool	is_pgup(PGconn *conn, int timeout);
+int			is_witness(PGconn *conn, char *schema, char *cluster, int node_id);
-char   *pg_version(PGconn *conn, char* major_version);
+bool		is_pgup(PGconn *conn, int timeout);
-int		guc_set(PGconn *conn, const char *parameter, const char *op,
+char	   *pg_version(PGconn *conn, char *major_version);
-                   const char *value);
+int guc_set(PGconn *conn, const char *parameter, const char *op,
-int		guc_set_typed(PGconn *conn, const char *parameter, const char *op,
+		const char *value);
-                   const char *value, const char *datatype);
+int guc_set_typed(PGconn *conn, const char *parameter, const char *op,
+			  const char *value, const char *datatype);
 
-const char	 *get_cluster_size(PGconn *conn);
+const char *get_cluster_size(PGconn *conn);
-PGconn *getMasterConnection(PGconn *standby_conn, char *schema, char *cluster,
+PGconn *get_master_connection(PGconn *standby_conn, char *schema, char *cluster,
-                            int *master_id, char *master_conninfo_out);
+					  int *master_id, char *master_conninfo_out);
+
+int			wait_connection_availability(PGconn *conn, long long timeout);
+bool		cancel_query(PGconn *conn, int timeout);
 
-int wait_connection_availability(PGconn *conn, long long timeout);
-bool CancelQuery(PGconn *conn, int timeout);
 #endif

debian/DEBIAN/control

@@ -3,7 +3,7 @@ Version: 2.0beta2
 Section: database
 Priority: optional
 Architecture: all
-Depends: rsync, postgresql-9.0 | postgresql-9.1 | postgresql-9.2 | postgresql-9.3
+Depends: rsync, postgresql-9.0 | postgresql-9.1 | postgresql-9.2 | postgresql-9.3 | postgresql-9.4
 Maintainer: Jaime Casanova <jaime@2ndQuadrant.com>
 Description: PostgreSQL replication setup, magament and monitoring
  has two main executables

debian/repmgr.repmgrd.default

@@ -6,7 +6,7 @@
 REPMGRD_ENABLED=no
 
 # Options for repmgrd (required)
-#REPMGRD_OPTS="--config_file /path/to/repmgr.conf"
+#REPMGRD_OPTS="--config-file /path/to/repmgr.conf"
 
 # User to run repmgrd as
 #REPMGRD_USER=postgres

debian/repmgr.repmgrd.init

@@ -50,7 +50,7 @@ do_start()
 	#   0 if daemon has been started
 	#   1 if daemon was already running
 	#   other if daemon could not be started or a failure occured
-	start-stop-daemon --start --quiet --chuid $REPMGRD_USER --make-pidfile --pidfile $REPMGRD_PIDFILE --exec $REPMGRD_BIN -- $REPMGRD_OPTS
+	start-stop-daemon --start --quiet --background --chuid $REPMGRD_USER --make-pidfile --pidfile $REPMGRD_PIDFILE --exec $REPMGRD_BIN -- $REPMGRD_OPTS
 }
 
 do_stop()
@@ -90,7 +90,7 @@ case "$1" in
 	$0 start
 	;;
   status)
-	status_of_proc -p $PIDFILE $DAEMON $NAME && exit 0 || exit $?
+	status_of_proc -p $REPMGRD_PIDFILE $REPMGRD_BIN $NAME && exit 0 || exit $?
 	;;
   *)
 	echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload|status}" >&2

errcode.h

@@ -34,7 +34,7 @@
 #define ERR_BAD_PASSWORD 9
 #define ERR_STR_OVERFLOW 10
 #define ERR_FAILOVER_FAIL 11
-#define ERR_BAD_SSH	12
+#define ERR_BAD_SSH 12
 #define ERR_SYS_FAILURE 13
 
-#endif	/* _ERRCODE_H_ */
+#endif   /* _ERRCODE_H_ */

log.c

@@ -39,24 +39,23 @@
 
 /* #define REPMGR_DEBUG */
 
-void stderr_log_with_level(const char *level_name, int level, const char *fmt, ...) {
+void
-	size_t len = strlen(fmt);
+stderr_log_with_level(const char *level_name, int level, const char *fmt, ...)
-	char fmt1[len + 150];
+{
-	time_t t;
+	time_t		t;
-	struct tm *tm;
+	struct tm  *tm;
-	char buff[100];
+	char		buff[100];
-	va_list ap;
+	va_list		ap;
 
-	if(log_level >= level) {
+	if (log_level >= level)
+	{
 		time(&t);
 		tm = localtime(&t);
+		strftime(buff, 100, "[%Y-%m-%d %H:%M:%S]", tm);
+		fprintf(stderr, "%s [%s] ", buff, level_name);
 
 		va_start(ap, fmt);
-
+		vfprintf(stderr, fmt, ap);
-		strftime(buff, 100, "[%Y-%m-%d %H:%M:%S]", tm);
-		snprintf(fmt1, len + 150, "%s [%s] %s", buff, level_name, fmt);
-		vfprintf(stderr, fmt1, ap);
-
 		va_end(ap);
 
 		fflush(stderr);
@@ -64,20 +63,20 @@ void stderr_log_with_level(const char *level_name, int level, const char *fmt, .
 }
 
 
-static int detect_log_level(const char* level);
+static int	detect_log_level(const char *level);
-static int detect_log_facility(const char* facility);
+static int	detect_log_facility(const char *facility);
 
-int log_type = REPMGR_STDERR;
+int			log_type = REPMGR_STDERR;
-int log_level = LOG_NOTICE;
+int			log_level = LOG_NOTICE;
 
-bool logger_init(t_configuration_options *opts, const char* ident, const char* level, const char* facility)
+bool
+logger_init(t_configuration_options * opts, const char *ident, const char *level, const char *facility)
 {
-
+	int			l;
-	int l;
+	int			f;
-	int f;
 
 #ifdef HAVE_SYSLOG
-	int syslog_facility = DEFAULT_SYSLOG_FACILITY;
+	int			syslog_facility = DEFAULT_SYSLOG_FACILITY;
 #endif
 
 #ifdef REPMGR_DEBUG
@@ -134,17 +133,17 @@ bool logger_init(t_configuration_options *opts, const char* ident, const char* l
 
 	if (log_type == REPMGR_SYSLOG)
 	{
-		setlogmask (LOG_UPTO (log_level));
+		setlogmask(LOG_UPTO(log_level));
-		openlog (ident, LOG_CONS | LOG_PID | LOG_NDELAY, syslog_facility);
+		openlog(ident, LOG_CONS | LOG_PID | LOG_NDELAY, syslog_facility);
 
 		stderr_log_notice(_("Setup syslog (level: %s, facility: %s)\n"), level, facility);
 	}
-
 #endif
 
 	if (*opts->logfile)
 	{
-		FILE *fd;
+		FILE	   *fd;
+
 		fd = freopen(opts->logfile, "a", stderr);
 
 		if (fd == NULL)
@@ -158,9 +157,9 @@ bool logger_init(t_configuration_options *opts, const char* ident, const char* l
 
 }
 
-bool logger_shutdown(void)
+bool
+logger_shutdown(void)
 {
-
 #ifdef HAVE_SYSLOG
 	if (log_type == REPMGR_SYSLOG)
 		closelog();
@@ -174,13 +173,15 @@ bool logger_shutdown(void)
  * options, which might increase requested logging over what's specified
  * in the regular configuration file.
  */
-void logger_min_verbose(int minimum)
+void
+logger_min_verbose(int minimum)
 {
 	if (log_level < minimum)
 		log_level = minimum;
 }
 
-int detect_log_level(const char* level)
+int
+detect_log_level(const char *level)
 {
 	if (!strcmp(level, "DEBUG"))
 		return LOG_DEBUG;
@@ -202,40 +203,42 @@ int detect_log_level(const char* level)
 	return 0;
 }
 
-int detect_log_facility(const char* facility)
+int
+detect_log_facility(const char *facility)
 {
-	int local = 0;
+	int			local = 0;
+
 	if (!strncmp(facility, "LOCAL", 5) && strlen(facility) == 6)
 	{
 
-		local = atoi (&facility[5]);
+		local = atoi(&facility[5]);
 
 		switch (local)
 		{
-		case 0:
+			case 0:
-			return LOG_LOCAL0;
+				return LOG_LOCAL0;
-			break;
+				break;
-		case 1:
+			case 1:
-			return LOG_LOCAL1;
+				return LOG_LOCAL1;
-			break;
+				break;
-		case 2:
+			case 2:
-			return LOG_LOCAL2;
+				return LOG_LOCAL2;
-			break;
+				break;
-		case 3:
+			case 3:
-			return LOG_LOCAL3;
+				return LOG_LOCAL3;
-			break;
+				break;
-		case 4:
+			case 4:
-			return LOG_LOCAL4;
+				return LOG_LOCAL4;
-			break;
+				break;
-		case 5:
+			case 5:
-			return LOG_LOCAL5;
+				return LOG_LOCAL5;
-			break;
+				break;
-		case 6:
+			case 6:
-			return LOG_LOCAL6;
+				return LOG_LOCAL6;
-			break;
+				break;
-		case 7:
+			case 7:
-			return LOG_LOCAL7;
+				return LOG_LOCAL7;
-			break;
+				break;
 		}
 
 	}

log.h

@@ -25,7 +25,15 @@
 #define REPMGR_SYSLOG 1
 #define REPMGR_STDERR 2
 
-void stderr_log_with_level(const char *level_name, int level, const char *fmt, ...) __attribute__ ((format (PG_PRINTF_ATTRIBUTE, 3, 4)));
+#if (PG_VERSION_NUM >= 90100)
+void
+stderr_log_with_level(const char *level_name, int level, const char *fmt,...)
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 4)));
+#else
+void
+stderr_log_with_level(const char *level_name, int level, const char *fmt,...)
+__attribute__((format(printf, 3, 4)));
+#endif
 
 /* Standard error logging */
 #define stderr_log_debug(...) stderr_log_with_level("DEBUG", LOG_DEBUG, __VA_ARGS__)
@@ -88,17 +96,16 @@ void stderr_log_with_level(const char *level_name, int level, const char *fmt, .
 		if (log_type == REPMGR_SYSLOG) syslog(LOG_ALERT, __VA_ARGS__); \
 		else stderr_log_alert(__VA_ARGS__); \
 	}
-
 #else
 
-#define	LOG_EMERG	0	/* system is unusable */
+#define LOG_EMERG	0			/* system is unusable */
-#define	LOG_ALERT	1	/* action must be taken immediately */
+#define LOG_ALERT	1			/* action must be taken immediately */
-#define	LOG_CRIT	2	/* critical conditions */
+#define LOG_CRIT	2			/* critical conditions */
-#define	LOG_ERR		3	/* error conditions */
+#define LOG_ERR		3			/* error conditions */
-#define	LOG_WARNING	4	/* warning conditions */
+#define LOG_WARNING 4			/* warning conditions */
-#define	LOG_NOTICE	5	/* normal but significant condition */
+#define LOG_NOTICE	5			/* normal but significant condition */
-#define	LOG_INFO	6	/* informational */
+#define LOG_INFO	6			/* informational */
-#define	LOG_DEBUG	7	/* debug-level messages */
+#define LOG_DEBUG	7			/* debug-level messages */
 
 #define log_debug(...) stderr_log_debug(__VA_ARGS__)
 #define log_info(...) stderr_log_info(__VA_ARGS__)
@@ -108,16 +115,18 @@ void stderr_log_with_level(const char *level_name, int level, const char *fmt, .
 #define log_crit(...) stderr_log_crit(__VA_ARGS__)
 #define log_alert(...) stderr_log_alert(__VA_ARGS__)
 #define log_emerg(...) stderr_log_emerg(__VA_ARGS__)
-
 #endif
 
 
 /* Logger initialisation and shutdown */
-bool logger_shutdown(void);
+bool		logger_shutdown(void);
-bool logger_init(t_configuration_options *opts, const char* ident, const char* level, const char* facility);
-void logger_min_verbose(int minimum);
 
-extern int log_type;
+bool logger_init(t_configuration_options * opts, const char *ident,
-extern int log_level;
+			const char *level, const char *facility);
+
+void		logger_min_verbose(int minimum);
+
+extern int	log_type;
+extern int	log_level;
 
 #endif

repmgr.h

@@ -50,25 +50,28 @@
 typedef struct
 {
 
-	char dbname[MAXLEN];
+	char		dbname[MAXLEN];
-	char host[MAXLEN];
+	char		host[MAXLEN];
-	char username[MAXLEN];
+	char		username[MAXLEN];
-	char dest_dir[MAXFILENAME];
+	char		dest_dir[MAXFILENAME];
-	char config_file[MAXFILENAME];
+	char		config_file[MAXFILENAME];
-	char remote_user[MAXLEN];
+	char		remote_user[MAXLEN];
-	char wal_keep_segments[MAXLEN];
+	char		superuser[MAXLEN];
-	bool verbose;
+	char		wal_keep_segments[MAXLEN];
-	bool force;
+	bool		verbose;
-	bool wait_for_master;
+	bool		force;
-	bool ignore_rsync_warn;
+	bool		wait_for_master;
+	bool		ignore_rsync_warn;
+	bool		initdb_no_pwprompt;
+	bool		fast_checkpoint;
 
-	char masterport[MAXLEN];
+	char		masterport[MAXLEN];
-	char localport[MAXLEN];
+	char		localport[MAXLEN];
 
 	/* parameter used by CLUSTER CLEANUP */
-	int keep_history;
+	int			keep_history;
-} t_runtime_options;
+}	t_runtime_options;
 
-#define T_RUNTIME_OPTIONS_INITIALIZER { "", "", "", "", "", "", DEFAULT_WAL_KEEP_SEGMENTS, false, false, false, false, "", "", 0 }
+#define T_RUNTIME_OPTIONS_INITIALIZER { "", "", "", "", "", "", "", DEFAULT_WAL_KEEP_SEGMENTS, false, false, false, false, false, false, "", "", 0}
 
 #endif

sql/repmgr_funcs.c

@@ -18,7 +18,7 @@
 #include "utils/timestamp.h"
 
 /* same definition as the one in xlog_internal.h */
-#define MAXFNAMELEN 	64
+#define MAXFNAMELEN		64
 
 PG_MODULE_MAGIC;
 
@@ -27,32 +27,32 @@ PG_MODULE_MAGIC;
  */
 typedef struct repmgrSharedState
 {
-    LWLockId    lock;           		/* protects search/modification */
+	LWLockId	lock;			/* protects search/modification */
-    char		location[MAXFNAMELEN];	/* last known xlog location */
+	char		location[MAXFNAMELEN];	/* last known xlog location */
 	TimestampTz last_updated;
-} repmgrSharedState;
+}	repmgrSharedState;
 
 /* Links to shared memory state */
 static repmgrSharedState *shared_state = NULL;
 
 static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
 
-void        _PG_init(void);
+void		_PG_init(void);
-void        _PG_fini(void);
+void		_PG_fini(void);
 
 static void repmgr_shmem_startup(void);
 static Size repmgr_memsize(void);
 
 static bool repmgr_set_standby_location(char *locationstr);
 
-Datum repmgr_update_standby_location(PG_FUNCTION_ARGS);
+Datum		repmgr_update_standby_location(PG_FUNCTION_ARGS);
-Datum repmgr_get_last_standby_location(PG_FUNCTION_ARGS);
+Datum		repmgr_get_last_standby_location(PG_FUNCTION_ARGS);
 
 PG_FUNCTION_INFO_V1(repmgr_update_standby_location);
 PG_FUNCTION_INFO_V1(repmgr_get_last_standby_location);
 
-Datum repmgr_update_last_updated(PG_FUNCTION_ARGS);
+Datum		repmgr_update_last_updated(PG_FUNCTION_ARGS);
-Datum repmgr_get_last_updated(PG_FUNCTION_ARGS);
+Datum		repmgr_get_last_updated(PG_FUNCTION_ARGS);
 
 PG_FUNCTION_INFO_V1(repmgr_update_last_updated);
 PG_FUNCTION_INFO_V1(repmgr_get_last_updated);
@@ -68,9 +68,9 @@ _PG_init(void)
 	 * In order to create our shared memory area, we have to be loaded via
 	 * shared_preload_libraries.  If not, fall out without hooking into any of
 	 * the main system.  (We don't throw error here because it seems useful to
-	 * allow the repmgr functions to be created even when the
+	 * allow the repmgr functions to be created even when the module isn't
-	 * module isn't active.  The functions must protect themselves against
+	 * active.	The functions must protect themselves against being called
-	 * being called then, however.)
+	 * then, however.)
 	 */
 	if (!process_shared_preload_libraries_in_progress)
 		return;
@@ -120,15 +120,15 @@ repmgr_shmem_startup(void)
 	LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
 
 	shared_state = ShmemInitStruct("repmgr shared state",
-						   sizeof(repmgrSharedState),
+								   sizeof(repmgrSharedState),
-						   &found);
+								   &found);
 
 	if (!found)
 	{
 		/* First time through ... */
 		shared_state->lock = LWLockAssign();
 		snprintf(shared_state->location,
-				sizeof(shared_state->location), "%X/%X", 0, 0);
+				 sizeof(shared_state->location), "%X/%X", 0, 0);
 	}
 
 	LWLockRelease(AddinShmemInitLock);
@@ -141,20 +141,20 @@ repmgr_shmem_startup(void)
 static Size
 repmgr_memsize(void)
 {
-    return MAXALIGN(sizeof(repmgrSharedState));
+	return MAXALIGN(sizeof(repmgrSharedState));
 }
 
 
 static bool
 repmgr_set_standby_location(char *locationstr)
 {
-    /* Safety check... */
+	/* Safety check... */
-    if (!shared_state)
+	if (!shared_state)
-        return false;
+		return false;
 
-    LWLockAcquire(shared_state->lock, LW_EXCLUSIVE);
+	LWLockAcquire(shared_state->lock, LW_EXCLUSIVE);
 	strncpy(shared_state->location, locationstr, MAXFNAMELEN);
-    LWLockRelease(shared_state->lock);
+	LWLockRelease(shared_state->lock);
 
 	return true;
 }
@@ -166,7 +166,7 @@ repmgr_set_standby_location(char *locationstr)
 Datum
 repmgr_get_last_standby_location(PG_FUNCTION_ARGS)
 {
-	char location[MAXFNAMELEN];
+	char		location[MAXFNAMELEN];
 
 	/* Safety check... */
 	if (!shared_state)
@@ -184,14 +184,14 @@ repmgr_get_last_standby_location(PG_FUNCTION_ARGS)
 Datum
 repmgr_update_standby_location(PG_FUNCTION_ARGS)
 {
-	text       *location = PG_GETARG_TEXT_P(0);
+	text	   *location = PG_GETARG_TEXT_P(0);
-	char       *locationstr;
+	char	   *locationstr;
 
-    /* Safety check... */
+	/* Safety check... */
-    if (!shared_state)
+	if (!shared_state)
-        PG_RETURN_BOOL(false);
+		PG_RETURN_BOOL(false);
 
-    locationstr = text_to_cstring(location);
+	locationstr = text_to_cstring(location);
 
 	PG_RETURN_BOOL(repmgr_set_standby_location(locationstr));
 }
@@ -220,9 +220,9 @@ repmgr_get_last_updated(PG_FUNCTION_ARGS)
 {
 	TimestampTz last_updated;
 
-    /* Safety check... */
+	/* Safety check... */
-    if (!shared_state)
+	if (!shared_state)
-        PG_RETURN_NULL();
+		PG_RETURN_NULL();
 
 	LWLockAcquire(shared_state->lock, LW_EXCLUSIVE);
 	last_updated = shared_state->last_updated;

strutil.c

@@ -25,29 +25,27 @@
 #include "log.h"
 #include "strutil.h"
 
-static int xvsnprintf(char *str, size_t size, const char *format, va_list ap) __attribute__ ((format (PG_PRINTF_ATTRIBUTE, 3, 0)));
+#if (PG_VERSION_NUM >= 90100)
-
+static int
-/* Add strnlen on platforms that don't have it, like OS X */
+xvsnprintf(char *str, size_t size, const char *format, va_list ap)
-#ifndef strnlen
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
-size_t
+#else
-strnlen(const char *s, size_t n)
+static int
-{
+xvsnprintf(char *str, size_t size, const char *format, va_list ap)
-	const char *end = (const char *) memchr(s, '\0', n);
+__attribute__((format(printf, 3, 0)));
-	return(end ? end - s : n);
-}
 #endif
 
 static int
 xvsnprintf(char *str, size_t size, const char *format, va_list ap)
 {
-	int retval;
+	int			retval;
 
 	retval = vsnprintf(str, size, format, ap);
 
-	if (retval >= (int)size)
+	if (retval >= (int) size)
 	{
 		log_err(_("Buffer of size not large enough to format entire string '%s'\n"),
-		        str);
+				str);
 		exit(ERR_STR_OVERFLOW);
 	}
 
@@ -56,10 +54,10 @@ xvsnprintf(char *str, size_t size, const char *format, va_list ap)
 
 
 int
-xsnprintf(char *str, size_t size, const char *format, ...)
+xsnprintf(char *str, size_t size, const char *format,...)
 {
-	va_list arglist;
+	va_list		arglist;
-	int retval;
+	int			retval;
 
 	va_start(arglist, format);
 	retval = xvsnprintf(str, size, format, arglist);
@@ -70,7 +68,7 @@ xsnprintf(char *str, size_t size, const char *format, ...)
 
 
 int
-sqlquery_snprintf(char *str, const char *format, ...)
+sqlquery_snprintf(char *str, const char *format,...)
 {
 	va_list		arglist;
 	int			retval;
@@ -83,7 +81,8 @@ sqlquery_snprintf(char *str, const char *format, ...)
 }
 
 
-int maxlen_snprintf(char *str, const char *format, ...)
+int
+maxlen_snprintf(char *str, const char *format,...)
 {
 	va_list		arglist;
 	int			retval;

strutil.h

@@ -22,7 +22,7 @@
 #define _STRUTIL_H_
 
 #include <stdlib.h>
-#include <errcode.h>
+#include "errcode.h"
 
 #define QUERY_STR_LEN	8192
 #define MAXLEN			1024
@@ -31,13 +31,30 @@
 #define MAXCONNINFO		1024
 
 
-extern int xsnprintf(char *str, size_t size, const char *format, ...) __attribute__ ((format (PG_PRINTF_ATTRIBUTE, 3, 4)));
+#if (PG_VERSION_NUM >= 90100)
-extern int sqlquery_snprintf(char *str, const char *format, ...) __attribute__ ((format (PG_PRINTF_ATTRIBUTE, 2, 3)));
+extern int
-extern int maxlen_snprintf(char *str, const char *format, ...) __attribute__ ((format (PG_PRINTF_ATTRIBUTE, 2, 3)));
+xsnprintf(char *str, size_t size, const char *format,...)
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 4)));
 
-/* Add strnlen on platforms that don't have it, like OS X */
+extern int
-#ifndef strnlen
+sqlquery_snprintf(char *str, const char *format,...)
-extern size_t strnlen(const char *s, size_t n);
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+
+extern int
+maxlen_snprintf(char *str, const char *format,...)
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+#else
+extern int
+xsnprintf(char *str, size_t size, const char *format,...)
+__attribute__((format(printf, 3, 4)));
+
+extern int
+sqlquery_snprintf(char *str, const char *format,...)
+__attribute__((format(printf, 2, 3)));
+
+extern int
+maxlen_snprintf(char *str, const char *format,...)
+__attribute__((format(printf, 2, 3)));
 #endif
 
-#endif	/* _STRUTIL_H_ */
+#endif   /* _STRUTIL_H_ */

version.h

@@ -1,5 +1,6 @@
 #ifndef _VERSION_H_
 #define _VERSION_H_
 
-#define REPMGR_VERSION "2.1dev"
+#define REPMGR_VERSION "2.0.3"
+
 #endif