Release 1.6.0 (#1131 )

* Implement missing tests and do a few minor fixes * Bump version to 1.6.0 * Update release notes
Compatibility with postgresql 12 (#1068 )
2026-08-26 07:30:14 +00:00 · 2019-08-05 15:08:04 +02:00 · 2019-08-02 16:00:55 +02:00 · 2019-08-02 11:34:29 +02:00 · 2019-08-02 11:21:26 +02:00 · 2019-07-26 09:34:42 +02:00
88 changed files with 6313 additions and 3522 deletions
@@ -51,3 +51,9 @@ scm-source.json
 docs/build/
 docs/source/_static/
 docs/source/_templates/
+
+# Pycharm IDE
+.idea/
+
+#VSCode IDE
+.vscode/
@@ -1,6 +1,10 @@
 sudo: true
 dist: trusty
 language: python
+addons:
+  apt:
+    packages:
+      - expect-dev # for unbuffer
 env:
  global:
  - ETCDVERSION=3.0.17 ZKVERSION=3.4.11 CONSULVERSION=0.7.4
@@ -115,7 +119,7 @@ install:
            fi
            source ~/virtualenv/python${pv}/bin/activate
            # explicitly install all needed python modules to cache them
-            for p in '-r requirements.txt' 'behave codacy-coverage coverage coveralls flake8 mock pytest-cov pytest setuptools'; do
+            for p in '-r requirements.txt' 'psycopg2-binary behave codacy-coverage coverage coveralls flake8 mock pytest-cov pytest setuptools'; do
                pip install $p --upgrade
            done
        fi
@@ -131,13 +135,13 @@ script:

        if [[ $TEST_SUITE != "behave" ]]; then
            echo Running unit tests using python${pv}
-            $TEST_SUITE test
+            unbuffer $TEST_SUITE test
            $TEST_SUITE flake8
        elif [[ $pv != $EXCLUDE_BEHAVE ]]; then
            echo Running acceptance tests using python${pv}
-            if ! PATH=.:/usr/lib/postgresql/9.6/bin:$PATH $TEST_SUITE; then
+            if ! PATH=.:/usr/lib/postgresql/9.6/bin:$PATH unbuffer $TEST_SUITE; then
                # output all log files when tests are failing
-                grep . features/output/*/*postgres?.*
+                grep . features/output/*_failed/*postgres?.*
                exit 1
            fi
        fi
@@ -1,45 +1,156 @@
 ## This Dockerfile is meant to aid in the building and debugging patroni whilst developing on your local machine
 ## It has all the necessary components to play/debug with a single node appliance, running etcd
-FROM postgres:10
-MAINTAINER Alexander Kukushkin <[email protected]>
+ARG PG_MAJOR=10
+ARG COMPRESS=false
+ARG PGHOME=/home/postgres
+ARG PGDATA=$PGHOME/data
+ARG LC_ALL=C.UTF-8
+ARG LANG=C.UTF-8

-RUN export DEBIAN_FRONTEND=noninteractive \
+FROM postgres:$PG_MAJOR as builder
+
+ARG PGHOME
+ARG PGDATA
+ARG LC_ALL
+ARG LANG
+
+ENV ETCDVERSION=2.3.8 CONFDVERSION=0.16.0
+
+RUN set -ex \
+    && export DEBIAN_FRONTEND=noninteractive \
    && echo 'APT::Install-Recommends "0";\nAPT::Install-Suggests "0";' > /etc/apt/apt.conf.d/01norecommend \
    && apt-get update -y \
-    && apt-get upgrade -y \
-    # postgres:10 is based on debian, which has patroni package. We will install all required dependencies
-    && apt-get install -s patroni | sed -n -e '/^Inst patroni /d' -e 's/^Inst \([^ ]\+\) .*$/\1/p' \
-            | xargs apt-get install -y curl jq haproxy locales python3-etcd python3-kazoo \
-
-    ## Make sure we have a en_US.UTF-8 locale available
+    # postgres:10 is based on debian, which has the patroni package. We will install all required dependencies
+    && apt-cache depends patroni | sed -n -e 's/.*Depends: \(python3-.\+\)$/\1/p' \
+            | grep -Ev '^python3-(sphinx|etcd|consul|kazoo|kubernetes)' \
+            | xargs apt-get install -y vim curl less jq locales haproxy sudo \
+                            python3-etcd python3-kazoo python3-pip busybox \
+    && pip3 install dumb-init \
+\
+    # Cleanup all locales but en_US.UTF-8
+    && find /usr/share/i18n/charmaps/ -type f ! -name UTF-8.gz -delete \
+    && find /usr/share/i18n/locales/ -type f ! -name en_US ! -name en_GB ! -name i18n ! -name iso14651_t1 ! -name iso14651_t1_common ! -name 'translit_*' -delete \
+    && echo 'en_US.UTF-8 UTF-8' > /usr/share/i18n/SUPPORTED \
+\
+    # Make sure we have a en_US.UTF-8 locale available
    && localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8 \
-
-    && mkdir -p /home/postgres \
-    && chown postgres:postgres /home/postgres \
-
-    # Clean up
-    && apt-get purge -y libpython2.7-stdlib libpython2.7-minimal \
+\
+    # haproxy dummy config
+    && echo 'global\n        stats socket /run/haproxy/admin.sock mode 660 level admin' > /etc/haproxy/haproxy.cfg \
+\
+    # vim config
+    && echo 'syntax on\nfiletype plugin indent on\nset mouse-=a\nautocmd FileType yaml setlocal ts=2 sts=2 sw=2 expandtab' > /etc/vim/vimrc.local \
+\
+    # Prepare postgres/patroni/haproxy environment
+    && mkdir -p $PGHOME/.config/patroni /patroni /run/haproxy \
+    && ln -s ../../postgres0.yml $PGHOME/.config/patroni/patronictl.yaml \
+    && ln -s /patronictl.py /usr/local/bin/patronictl \
+    && sed -i "s|/var/lib/postgresql.*|$PGHOME:/bin/bash|" /etc/passwd \
+    && chown -R postgres:postgres /var/log \
+\
+    # Download etcd
+    && curl -sL https://github.com/coreos/etcd/releases/download/v${ETCDVERSION}/etcd-v${ETCDVERSION}-linux-amd64.tar.gz \
+            | tar xz -C /usr/local/bin --strip=1 --wildcards --no-anchored etcd etcdctl \
+\
+    # Download confd
+    && curl -sL https://github.com/kelseyhightower/confd/releases/download/v${CONFDVERSION}/confd-${CONFDVERSION}-linux-amd64 \
+            > /usr/local/bin/confd && chmod +x /usr/local/bin/confd \
+\
+    # Clean up all useless packages and some files
+    && apt-get purge -y --allow-remove-essential python3-pip gzip bzip2 util-linux e2fsprogs \
+                libmagic1 bsdmainutils login ncurses-bin libmagic-mgc e2fslibs bsdutils \
+                exim4-config gnupg-agent dirmngr libpython2.7-stdlib libpython2.7-minimal \
    && apt-get autoremove -y \
    && apt-get clean -y \
-    && rm -rf /var/lib/apt/lists/* /root/.cache
+    && rm -rf /var/lib/apt/lists/* \
+        /root/.cache \
+        /var/cache/debconf/* \
+        /etc/rc?.d \
+        /etc/systemd \
+        /docker-entrypoint* \
+        /sbin/pam* \
+        /sbin/swap* \
+        /sbin/unix* \
+        /usr/local/bin/gosu \
+        /usr/sbin/[acgipr]* \
+        /usr/sbin/*user* \
+        /usr/share/doc* \
+        /usr/share/man \
+        /usr/share/info \
+        /usr/share/i18n/locales/translit_hangul \
+        /usr/share/locale/?? \
+        /usr/share/locale/??_?? \
+        /usr/share/postgresql/*/man \
+        /usr/share/postgresql-common/pg_wrapper \
+        /usr/share/vim/vim80/doc \
+        /usr/share/vim/vim80/lang \
+        /usr/share/vim/vim80/tutor \
+#        /var/lib/dpkg/info/* \
+    && find /usr/bin -xtype l -delete \
+    && find /var/log -type f -exec truncate --size 0 {} \; \
+    && find /usr/lib/python3/dist-packages -name '*test*' | xargs rm -fr \
+    && find /lib/x86_64-linux-gnu/security -type f ! -name pam_env.so ! -name pam_permit.so ! -name pam_unix.so -delete

-ENV ETCDVERSION 3.2.23
-RUN curl -L https://github.com/coreos/etcd/releases/download/v${ETCDVERSION}/etcd-v${ETCDVERSION}-linux-amd64.tar.gz \
-    | tar xz -C /usr/local/bin --strip=1 --wildcards --no-anchored etcd etcdctl
+# perform compression if it is necessary
+ARG COMPRESS
+RUN if [ "$COMPRESS" = "true" ]; then \
+        set -ex \
+        # Allow certain sudo commands from postgres
+        && echo 'postgres ALL=(ALL) NOPASSWD: /bin/tar xpJf /a.tar.xz -C /, /bin/rm /a.tar.xz, /bin/ln -snf dash /bin/sh' >> /etc/sudoers \
+        && ln -snf busybox /bin/sh \
+        && files="/bin/sh /usr/bin/sudo /usr/lib/sudo/sudoers.so /lib/x86_64-linux-gnu/security/pam_*.so" \
+        && libs="$(ldd $files | awk '{print $3;}' | grep '^/' | sort -u) /lib/x86_64-linux-gnu/ld-linux-x86-64.so.* /lib/x86_64-linux-gnu/libnsl.so.* /lib/x86_64-linux-gnu/libnss_compat.so.*" \
+        && (echo /var/run $files $libs | tr ' ' '\n' && realpath $files $libs) | sort -u | sed 's/^\///' > /exclude \
+        && find /etc/alternatives -xtype l -delete \
+        && save_dirs="usr lib var bin sbin etc/ssl etc/init.d etc/alternatives etc/apt" \
+        && XZ_OPT=-e9v tar -X /exclude -cpJf a.tar.xz $save_dirs \
+        # we call "cat /exclude" to avoid including files from the $save_dirs that are also among
+        # the exceptions listed in the /exclude, as "uniq -u" eliminates all non-unique lines.
+        # By calling "cat /exclude" a second time we guarantee that there will be at least two lines
+        # for each exception and therefore they will be excluded from the output passed to 'rm'.
+        && /bin/busybox sh -c "(find $save_dirs -not -type d && cat /exclude /exclude && echo exclude) | sort | uniq -u | xargs /bin/busybox rm" \
+        && /bin/busybox --install -s \
+        && /bin/busybox sh -c "find $save_dirs -type d -depth -exec rmdir -p {} \; 2> /dev/null"; \
+    fi

-ENV CONFDVERSION 0.16.0
-RUN curl -L https://github.com/kelseyhightower/confd/releases/download/v${CONFDVERSION}/confd-${CONFDVERSION}-linux-amd64 > /usr/local/bin/confd \
-    && chmod +x /usr/local/bin/confd
+FROM scratch
+COPY --from=builder / /

-ADD patronictl.py patroni.py docker/entrypoint.sh /
-ADD patroni /patroni/
-ADD extras/confd /etc/confd
+LABEL maintainer="Alexander Kukushkin <[email protected]>"

-RUN sed -i 's/env python/&3/' patroni*.py && ln -s /patronictl.py /usr/local/bin/patronictl && mkdir /data/ /run/haproxy \
-    && touch /pgpass /patroni.yml && chown postgres:postgres -R /patroni/ /data/ /pgpass /patroni.yml /etc/haproxy /var/run/ /var/lib/ /var/log/
+ARG PG_MAJOR
+ARG COMPRESS
+ARG PGHOME
+ARG PGDATA
+ARG LC_ALL
+ARG LANG

-EXPOSE 2379 5432 8008
+ARG PGBIN=/usr/lib/postgresql/$PG_MAJOR/bin
+
+ENV LC_ALL=$LC_ALL LANG=$LANG EDITOR=/usr/bin/editor
+ENV PGDATA=$PGDATA PATH=$PATH:$PGBIN
+
+COPY patroni /patroni/
+COPY extras/confd/conf.d/haproxy.toml /etc/confd/conf.d/
+COPY extras/confd/templates/haproxy.tmpl /etc/confd/templates/
+COPY patroni*.py docker/entrypoint.sh /
+COPY postgres?.yml $PGHOME/
+
+WORKDIR $PGHOME
+
+RUN sed -i 's/env python/&3/' /patroni*.py \
+    # "fix" patroni configs
+    && sed -i 's/^\(  connect_address:\|  - host\)/#&/' postgres?.yml \
+    && sed -i 's/^  listen: 127.0.0.1/  listen: 0.0.0.0/' postgres?.yml \
+    && sed -i "s|^\(  data_dir: \).*|\1$PGDATA|" postgres?.yml \
+    && sed -i "s|^#\(  bin_dir: \).*|\1$PGBIN|" postgres?.yml \
+    && sed -i 's/^  - encoding: UTF8/  - locale: en_US.UTF-8\n&/' postgres?.yml \
+    && sed -i 's/^\(scope\|name\|etcd\|  host\|  authentication\|  pg_hba\|  parameters\):/#&/' postgres?.yml \
+    && sed -i 's/^    \(replication\|superuser\|rewind\|unix_socket_directories\|\(\(  \)\{0,1\}\(username\|password\)\)\):/#&/' postgres?.yml \
+    && sed -i 's/^      parameters:/      pg_hba:\n      - local all all trust\n      - host replication all all md5\n      - host all all all md5\n&\n        max_connections: 100/'  postgres?.yml \
+    && if [ "$COMPRESS" = "true" ]; then chmod u+s /usr/bin/sudo; fi \
+    && chown -R postgres:postgres $PGHOME /run /etc/haproxy

-ENV LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
-ENTRYPOINT ["/bin/bash", "/entrypoint.sh"]
 USER postgres
+
+ENTRYPOINT ["/bin/sh", "/entrypoint.sh"]
@@ -59,6 +59,33 @@ To install requirements on a Mac, run the following:

    brew install postgresql etcd haproxy libyaml python

+**Psycopg2**
+
+Starting from `psycopg2-2.8 <http://initd.org/psycopg/articles/2019/04/04/psycopg-28-released/>`__ the binary version of psycopg2 will no longer be installed by default. Installing it from the source code requires C compiler and postgres+python dev packages.
+Since in the python world it is not possible to specify dependency as ``psycopg2 OR psycopg2-binary`` you will have to decide how to install it.
+
+There are a few options available:
+
+1. Use the package manager from your distro
+
+::
+
+    sudo apt-get install python-psycopg2   # install python2 psycopg2 module on Debian/Ubuntu
+    sudo apt-get install python3-psycopg2  # install python3 psycopg2 module on Debian/Ubuntu
+    sudo yum install python-psycopg2       # install python2 psycopg2 on RedHat/Fedora/CentOS
+
+2. Install psycopg2 from the binary package
+
+::
+
+    pip install psycopg2-binary
+
+3. Install psycopg2 from source
+
+::
+
+    pip install psycopg2>=2.5.4
+
 **General installation for pip**

 Patroni can be installed with pip:
@@ -1,58 +1,69 @@
 # docker compose file for running a 3-node PostgreSQL cluster
-# with etcd as the SIS
+# with 3-node etcd cluster as the DCS and one haproxy node
+version: "2"

-patroni_etcd:
-    container_name: patroni_etcd
-    image: patroni
-    command: --etcd
+networks:
+    demo:

-dbnode1:
-    image: patroni
-    hostname: dbnode1
-    links:
-        - patroni_etcd:patroni_etcd
-    volumes:
-        - ./patroni:/patroni
-    env_file: docker/patroni-secrets.env
-    environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
-        PATRONI_NAME: dbnode1
-        PATRONI_SCOPE: testcluster
+services:
+    etcd1:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/etcd.env
+        container_name: demo-etcd1
+        hostname: etcd1
+        command: etcd -name etcd1 -initial-advertise-peer-urls http://etcd1:2380

-dbnode2:
-    image: patroni
-    hostname: dbnode2
-    links:
-        - patroni_etcd:patroni_etcd
-    volumes:
-        - ./patroni:/patroni
-    env_file: docker/patroni-secrets.env
-    environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
-        PATRONI_NAME: dbnode2
-        PATRONI_SCOPE: testcluster
+    etcd2:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/etcd.env
+        container_name: demo-etcd2
+        hostname: etcd2
+        command: etcd -name etcd2 -initial-advertise-peer-urls http://etcd2:2380

-dbnode3:
-    image: patroni
-    hostname: dbnode3
-    links:
-        - patroni_etcd:patroni_etcd
-    volumes:
-        - ./patroni:/patroni
-    env_file: docker/patroni-secrets.env
-    environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
-        PATRONI_NAME: dbnode3
-        PATRONI_SCOPE: testcluster
+    etcd3:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/etcd.env
+        container_name: demo-etcd3
+        hostname: etcd3
+        command: etcd -name etcd3 -initial-advertise-peer-urls http://etcd3:2380

-haproxy:
-    image: patroni
-    links:
-        - patroni_etcd:patroni_etcd
-    ports:
-        - "5000:5000"
-        - "5001:5001"
-    environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
-        PATRONI_SCOPE: testcluster
-    command: --confd
+    patroni1:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/patroni.env
+        hostname: patroni1
+        container_name: demo-patroni1
+        environment:
+            PATRONI_NAME: patroni1
+
+    patroni2:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/patroni.env
+        hostname: patroni2
+        container_name: demo-patroni2
+        environment:
+            PATRONI_NAME: patroni2
+
+    patroni3:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/patroni.env
+        hostname: patroni3
+        container_name: demo-patroni3
+        environment:
+            PATRONI_NAME: patroni3
+
+    haproxy:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/patroni.env
+        hostname: haproxy
+        container_name: demo-haproxy
+        ports:
+            - "5000:5000"
+            - "5001:5001"
+        command: haproxy
@@ -1,47 +1,117 @@
 # Patroni Dockerfile
-You can run Patroni in a docker container using this Dockerfile, or by using one of the Docker image at
-
-    https://registry.opensource.zalan.do/v1/repositories/acid/patroni/tags
+You can run Patroni in a docker container using this Dockerfile

 This Dockerfile is meant in aiding development of Patroni and quick testing of features. It is not a production-worthy
 Dockerfile

+    docker build -t patroni .
+
 # Examples

 ## Standalone Patroni

-    docker run -d registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT
+    docker run -d patroni

-## Multiple Patroni's communicating with a standalone etcd inside Docker
-
-Basically what you would do would be: 
-
-* Run 1 container which provides etcd
-
-        docker run -d <IMAGE> --etcd-only
-
-* Run n containers running Patroni, passing the `--etcd` option to the `docker run` command
-
-        docker run -d <IMAGE> --etcd=<IP FROM etcd CONTAINER:PORT>
-
-To automate this you can run the following script:
-
-    dev_patroni_cluster.sh [OPTIONS]
-
-    Options:
-
-        --image     IMAGE    The Docker image to use for the cluster
-        --members   INT      The number of members for the cluster
-        --name      NAME     The name of the new cluster
+## Three-node Patroni cluster with three-node etcd cluster and one haproxy container using docker-compose

 Example session:

-    $ ./dev_patroni_cluster.sh --image registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT --members=2 --name=bravo
-    The etcd container is 6be871a11cb373406ca5ea1c6b39e1.0-SNAPSHOTfdde9fb1d6177212d6ad0c0d1bd9b563, ip=172.17.1.24
-    Started Patroni container 67e611f2eca7c40f9e6e0e24a4a8f2cba7e3e56d22a420e15ab9240a37a9d7a4, ip=172.17.1.25
-    Started Patroni container 47dd12ae635ab83b039f5889e250048b606ed5e48e3650b69e365e7e1d4acbcf, ip=172.17.1.26
+    $ docker-compose up -d
+    Creating demo-haproxy ...
+    Creating demo-patroni2 ...
+    Creating demo-patroni1 ...
+    Creating demo-patroni3 ...
+    Creating demo-etcd2 ...
+    Creating demo-etcd1 ...
+    Creating demo-etcd3 ...
+    Creating demo-haproxy
+    Creating demo-patroni2
+    Creating demo-patroni1
+    Creating demo-patroni3
+    Creating demo-etcd1
+    Creating demo-etcd2
+    Creating demo-etcd2 ... done
+
    $ docker ps
-    CONTAINER ID        IMAGE                                         COMMAND                CREATED             STATUS              PORTS                          NAMES
-    47dd12ae635a        registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT   "/bin/bash /entrypoi   10 seconds ago      Up 8 seconds        4001/tcp, 5432/tcp, 2380/tcp   bravo_OR64g8bx
-    67e611f2eca7        registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT   "/bin/bash /entrypoi   11 seconds ago      Up 10 seconds       2380/tcp, 4001/tcp, 5432/tcp   bravo_si9no8iz
-    6be871a11cb3        registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT   "/bin/bash /entrypoi   12 seconds ago      Up 10 seconds       4001/tcp, 5432/tcp, 2380/tcp   bravo_etcd
+    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                              NAMES
+    5b7a90b4cfbf        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 27 seconds                                          demo-etcd2
+    e30eea5222f2        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 27 seconds                                          demo-etcd1
+    83bcf3cb208f        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 27 seconds                                          demo-etcd3
+    922532c56e7d        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 28 seconds                                          demo-patroni3
+    14f875e445f3        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 28 seconds                                          demo-patroni2
+    110d1073b383        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 28 seconds                                          demo-patroni1
+    5af5e6e36028        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 28 seconds       0.0.0.0:5000-5001->5000-5001/tcp   demo-haproxy
+
+    $ docker logs demo-patroni1
+    2019-02-20 08:19:32,714 INFO: Failed to import patroni.dcs.consul
+    2019-02-20 08:19:32,737 INFO: Selected new etcd server http://etcd3:2379
+    2019-02-20 08:19:35,140 INFO: Lock owner: None; I am patroni1
+    2019-02-20 08:19:35,174 INFO: trying to bootstrap a new cluster
+    ...
+    2019-02-20 08:19:39,310 INFO: postmaster pid=37
+    2019-02-20 08:19:39.314 UTC [37] LOG:  listening on IPv4 address "0.0.0.0", port 5432
+    2019-02-20 08:19:39.321 UTC [37] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
+    2019-02-20 08:19:39.353 UTC [39] LOG:  database system was shut down at 2019-02-20 08:19:36 UTC
+    2019-02-20 08:19:39.354 UTC [40] FATAL:  the database system is starting up
+    localhost:5432 - rejecting connections
+    2019-02-20 08:19:39.369 UTC [37] LOG:  database system is ready to accept connections
+    localhost:5432 - accepting connections
+    2019-02-20 08:19:39,383 INFO: establishing a new patroni connection to the postgres cluster
+    2019-02-20 08:19:39,408 INFO: running post_bootstrap
+    2019-02-20 08:19:39,432 WARNING: Could not activate Linux watchdog device: "Can't open watchdog device: [Errno 2] No such file or directory: '/dev/watchdog'"
+    2019-02-20 08:19:39,515 INFO: initialized a new cluster
+    2019-02-20 08:19:49,424 INFO: Lock owner: patroni1; I am patroni1
+    2019-02-20 08:19:49,447 INFO: Lock owner: patroni1; I am patroni1
+    2019-02-20 08:19:49,480 INFO: no action.  i am the leader with the lock
+    2019-02-20 08:19:59,422 INFO: Lock owner: patroni1; I am patroni1
+
+    $ docker exec -ti demo-patroni1 bash
+    postgres@patroni1:~$ patronictl list
+    +-------------+----------+------------+--------+---------+----+-----------+
+    |   Cluster   |  Member  |    Host    |  Role  |  State  | TL | Lag in MB |
+    +-------------+----------+------------+--------+---------+----+-----------+
+    | testcluster | patroni1 | 172.21.0.3 | Leader | running |  1 |         0 |
+    | testcluster | patroni2 | 172.21.0.4 |        | running |  1 |         0 |
+    | testcluster | patroni3 | 172.21.0.5 |        | running |  1 |         0 |
+    +-------------+----------+------------+--------+---------+----+-----------+
+
+    postgres@patroni1:~$ etcdctl ls --recursive --sort -p /service/testcluster
+    /service/testcluster/config
+    /service/testcluster/initialize
+    /service/testcluster/leader
+    /service/testcluster/members/
+    /service/testcluster/members/patroni1
+    /service/testcluster/members/patroni2
+    /service/testcluster/members/patroni3
+    /service/testcluster/optime/
+    /service/testcluster/optime/leader
+
+    postgres@patroni1:~$ etcdctl member list
+    1bab629f01fa9065: name=etcd3 peerURLs=http://etcd3:2380 clientURLs=http://etcd3:2379 isLeader=false
+    8ecb6af518d241cc: name=etcd2 peerURLs=http://etcd2:2380 clientURLs=http://etcd2:2379 isLeader=true
+    b2e169fcb8a34028: name=etcd1 peerURLs=http://etcd1:2380 clientURLs=http://etcd1:2379 isLeader=false
+    postgres@patroni1:~$ exit
+
+    $ psql -h localhost -p 5000 -U postgres -W
+    Password: postgres
+    psql (11.2 (Ubuntu 11.2-1.pgdg18.04+1), server 10.7 (Debian 10.7-1.pgdg90+1))
+    Type "help" for help.
+
+    localhost/postgres=# select pg_is_in_recovery();
+     pg_is_in_recovery
+    ───────────────────
+     f
+    (1 row)
+
+    localhost/postgres=# \q
+
+    $ psql -h localhost -p 5001 -U postgres -W
+    Password: postgres
+    psql (11.2 (Ubuntu 11.2-1.pgdg18.04+1), server 10.7 (Debian 10.7-1.pgdg90+1))
+    Type "help" for help.
+
+    localhost/postgres=# select pg_is_in_recovery();
+     pg_is_in_recovery
+    ───────────────────
+     t
+    (1 row)
@@ -1,104 +0,0 @@
-#!/bin/bash
-
-DOCKER_IMAGE="registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT"
-MEMBERS=3
-
-
-function usage()
-{
-    cat <<__EOF__
-Usage: $0 
-
-Options:
-
-    --image     IMAGE    The Docker image to use for the cluster
-    --members   INT      The number of members for the cluster
-    --name      NAME     The name of the new cluster
-
-Examples:
-
-    $0 --image ${DOCKER_IMAGE}
-    $0
-    $0 --image ${DOCKER_IMAGE} --members=2
-__EOF__
-}
-
-
-optspec=":-:"
-while getopts "$optspec" optchar; do
-    case "${optchar}" in
-        -)
-            case "${OPTARG}" in
-                help)
-                    usage
-                    exit 0
-                    ;;
-                name)
-                    PATRONI_SCOPE="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
-                    ;;
-                name=*)
-                    PATRONI_SCOPE="${OPTARG#*=}"
-                    ;;
-                image)
-                    DOCKER_IMAGE="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
-                    ;;
-                image=*)
-                    DOCKER_IMAGE="${OPTARG#*=}"
-                    ;;
-                members)
-                    MEMBERS="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
-                    ;;
-                members=*)
-                    MEMBERS="${OPTARG#*=}"
-                    ;;
-                *)
-                    if [ "$OPTERR" = 1 ] && [ "${optspec:0:1}" != ":" ]; then
-                        echo "Unknown option --${OPTARG}" >&2
-                    fi
-                    ;;
-            esac;;
-        *)
-            if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then
-                echo "Non-option argument: '-${OPTARG}'" >&2
-                usage
-                exit 1
-            fi
-            ;;
-    esac
-done
-
-if [ -z ${PATRONI_SCOPE} ]; then
-    PATRONI_SCOPE=$(cat /dev/urandom | LC_ALL=C tr -dc 'a-z0-9' | head -c 8)
-fi
-
-function docker_run()
-{
-    local name=$1
-    shift
-    container=$(docker run -d --name=$name $*)
-    container_ip=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' ${container})
-    echo "Started container ${name}, ip=${container_ip}"
-}
-
-
-ETCD_CONTAINER="${PATRONI_SCOPE}_etcd"
-docker_run ${ETCD_CONTAINER} ${DOCKER_IMAGE} --etcd
-
-DOCKER_ARGS="--link=${ETCD_CONTAINER}:${ETCD_CONTAINER} -e PATRONI_SCOPE=${PATRONI_SCOPE} -e PATRONI_ETCD_URL=http://${ETCD_CONTAINER}:2379"
-PATRONI_ENV=$(sed 's/#.*//g' docker/patroni-secrets.env | sed -n 's/^PATRONI_.*$/-e &/p' | tr '\n' ' ')
-PATRONI_VOLUME="-v $(dirname $(dirname $(realpath $0)))/patroni:/patroni"
-
-for i in $(seq 1 "${MEMBERS}"); do
-    container_name=postgres${i}
-    docker_run "${PATRONI_SCOPE}_${container_name}" \
-        $PATRONI_VOLUME \
-        $DOCKER_ARGS \
-        $PATRONI_ENV \
-        -e PATRONI_NAME=${container_name} \
-        ${DOCKER_IMAGE}
-done
-
-docker_run "${PATRONI_SCOPE}_haproxy" \
-    -p=5000 -p=5001 \
-    $DOCKER_ARGS \
-    ${DOCKER_IMAGE} --confd
@@ -1,115 +1,60 @@
-#!/bin/bash
+#!/bin/sh

-function usage()
-{
-    cat <<__EOF__
-Usage: $0
+if [ -f /a.tar.xz ]; then
+    echo "decompressing image..."
+    sudo tar xpJf /a.tar.xz -C / > /dev/null 2>&1
+    sudo rm /a.tar.xz
+    sudo ln -snf dash /bin/sh
+fi

-Options:
+readonly PATRONI_SCOPE=${PATRONI_SCOPE:-batman}
+PATRONI_NAMESPACE=${PATRONI_NAMESPACE:-/service}
+readonly PATRONI_NAMESPACE=${PATRONI_NAMESPACE%/}
+readonly DOCKER_IP=$(hostname --ip-address)

-    --etcd      Do not run Patroni, run a standalone etcd
-    --confd     Do not run Patroni, run a standalone confd
-    --zookeeper Do not run Patroni, run a standalone zookeeper
-
-Examples:
-
-    $0 --etcd
-    $0 --confd
-    $0 --zookeeper
-    $0
-__EOF__
-}
-
-DOCKER_IP=$(hostname --ip-address)
-PATRONI_SCOPE=${PATRONI_SCOPE:-batman}
-ETCD_ARGS="--data-dir /tmp/etcd.data -advertise-client-urls=http://${DOCKER_IP}:2379 -listen-client-urls=http://0.0.0.0:2379"
-
-optspec=":vh-:"
-while getopts "$optspec" optchar; do
-    case "${optchar}" in
-        -)
-            case "${OPTARG}" in
-                confd)
-                    haproxy -f /etc/haproxy/haproxy.cfg -p /var/run/haproxy.pid -D
-                    CONFD="confd -prefix=${PATRONI_NAMESPACE:-/service}/$PATRONI_SCOPE -interval=10 -backend"
-                    if [ ! -z ${PATRONI_ZOOKEEPER_HOSTS} ]; then
-                        while ! /usr/share/zookeeper/bin/zkCli.sh -server ${PATRONI_ZOOKEEPER_HOSTS} ls /; do
-                            sleep 1
-                        done
-                        exec $CONFD zookeeper -node ${PATRONI_ZOOKEEPER_HOSTS}
-                    else
-                        while ! curl -s ${PATRONI_ETCD_URL}/v2/members | jq -r '.members[0].clientURLs[0]' | grep -q http; do
-                            sleep 1
-                        done
-                        exec $CONFD etcd -node $PATRONI_ETCD_URL
-                    fi
-                    ;;
-                etcd)
-                    exec etcd $ETCD_ARGS
-                    ;;
-                zookeeper)
-                    exec /usr/share/zookeeper/bin/zkServer.sh start-foreground
-                    ;;
-                cheat)
-                    CHEAT=1
-                    ;;
-                help)
-                    usage
-                    exit 0
-                    ;;
-                *)
-                    if [ "$OPTERR" = 1 ] && [ "${optspec:0:1}" != ":" ]; then
-                        echo "Unknown option --${OPTARG}" >&2
-                    fi
-                    ;;
-            esac;;
-        *)
-            if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then
-                echo "Non-option argument: '-${OPTARG}'" >&2
-                usage
-                exit 1
-            fi
-            ;;
-    esac
-done
+case "$1" in
+    haproxy)
+        haproxy -f /etc/haproxy/haproxy.cfg -p /var/run/haproxy.pid -D
+        CONFD="confd -prefix=$PATRONI_NAMESPACE/$PATRONI_SCOPE -interval=10 -backend"
+        if [ ! -z "$PATRONI_ZOOKEEPER_HOSTS" ]; then
+            while ! /usr/share/zookeeper/bin/zkCli.sh -server $PATRONI_ZOOKEEPER_HOSTS ls /; do
+                sleep 1
+            done
+            exec dumb-init $CONFD zookeeper -node $PATRONI_ZOOKEEPER_HOSTS
+        else
+            while ! etcdctl cluster-health 2> /dev/null; do
+                sleep 1
+            done
+            exec dumb-init $CONFD etcd -node $(echo $ETCDCTL_ENDPOINTS | sed 's/,/ -node /g')
+        fi
+        ;;
+    etcd)
+        exec "$@" -advertise-client-urls http://$DOCKER_IP:2379
+        ;;
+    zookeeper)
+        exec /usr/share/zookeeper/bin/zkServer.sh start-foreground
+        ;;
+esac

 ## We start an etcd
-if [[ -z ${PATRONI_ETCD_URL} && -z ${PATRONI_ZOOKEEPER_HOSTS} ]]; then
-    etcd $ETCD_ARGS > /var/log/etcd.log 2> /var/log/etcd.err &
+if [ -z "$PATRONI_ETCD_HOSTS" ] && [ -z "$PATRONI_ZOOKEEPER_HOSTS" ]; then
    export PATRONI_ETCD_URL="http://127.0.0.1:2379"
+    etcd --data-dir /tmp/etcd.data -advertise-client-urls=$PATRONI_ETCD_URL -listen-client-urls=http://0.0.0.0:2379 > /var/log/etcd.log 2> /var/log/etcd.err &
 fi

 export PATRONI_SCOPE
-export PATRONI_NAME="${PATRONI_NAME:-${HOSTNAME}}"
-export PATRONI_RESTAPI_CONNECT_ADDRESS="${DOCKER_IP}:8008"
+export PATRONI_NAMESPACE
+export PATRONI_NAME="${PATRONI_NAME:-$(hostname)}"
+export PATRONI_RESTAPI_CONNECT_ADDRESS="$DOCKER_IP:8008"
 export PATRONI_RESTAPI_LISTEN="0.0.0.0:8008"
-export PATRONI_admin_PASSWORD="${PATRONI_admin_PASSWORD:=admin}"
+export PATRONI_admin_PASSWORD="${PATRONI_admin_PASSWORD:-admin}"
 export PATRONI_admin_OPTIONS="${PATRONI_admin_OPTIONS:-createdb, createrole}"
-export PATRONI_POSTGRESQL_CONNECT_ADDRESS="${DOCKER_IP}:5432"
+export PATRONI_POSTGRESQL_CONNECT_ADDRESS="$DOCKER_IP:5432"
 export PATRONI_POSTGRESQL_LISTEN="0.0.0.0:5432"
-export PATRONI_POSTGRESQL_DATA_DIR="data/${PATRONI_SCOPE}"
+export PATRONI_POSTGRESQL_DATA_DIR="${PATRONI_POSTGRESQL_DATA_DIR:-$PGDATA}"
 export PATRONI_REPLICATION_USERNAME="${PATRONI_REPLICATION_USERNAME:-replicator}"
-export PATRONI_REPLICATION_PASSWORD="${PATRONI_REPLICATION_PASSWORD:-abcd}"
+export PATRONI_REPLICATION_PASSWORD="${PATRONI_REPLICATION_PASSWORD:-replicate}"
 export PATRONI_SUPERUSER_USERNAME="${PATRONI_SUPERUSER_USERNAME:-postgres}"
 export PATRONI_SUPERUSER_PASSWORD="${PATRONI_SUPERUSER_PASSWORD:-postgres}"
-export PATRONI_POSTGRESQL_PGPASS="$HOME/.pgpass"

-cat > /patroni.yml <<__EOF__
-bootstrap:
-  dcs:
-    postgresql:
-      use_pg_rewind: true
-
-  pg_hba:
-  - host all all 0.0.0.0/0 md5
-  - host replication replicator ${DOCKER_IP}/16    md5
-__EOF__
-
-mkdir -p "$HOME/.config/patroni"
-[ -h "$HOME/.config/patroni/patronictl.yaml" ] || ln -s /patroni.yml "$HOME/.config/patroni/patronictl.yaml"
-
-[ -z $CHEAT ] && exec python3 /patroni.py /patroni.yml
-
-while true; do
-    sleep 60
-done
+exec python3 /patroni.py postgres0.yml
@@ -0,0 +1,5 @@
+ETCD_LISTEN_PEER_URLS=http://0.0.0.0:2380
+ETCD_LISTEN_CLIENT_URLS=http://0.0.0.0:2379
+ETCD_INITIAL_CLUSTER=etcd1=http://etcd1:2380,etcd2=http://etcd2:2380,etcd3=http://etcd3:2380
+ETCD_INITIAL_CLUSTER_STATE=new
+ETCD_INITIAL_CLUSTER_TOKEN=tutorial
@@ -1,3 +1,6 @@
+PATRONI_SCOPE=demo
+PATRONI_ETCD_HOSTS='etcd1:2379','etcd2:2379','etcd3:2379'
+
 PATRONI_RESTAPI_USERNAME=admin
 PATRONI_RESTAPI_PASSWORD=admin
 PATRONI_SUPERUSER_USERNAME=postgres
@@ -6,3 +9,6 @@ PATRONI_REPLICATION_USERNAME=replicator
 PATRONI_REPLICATION_PASSWORD=replicate
 PATRONI_admin_PASSWORD=admin
 PATRONI_admin_OPTIONS=createdb,createrole
+
+# for etcdctl
+ETCDCTL_ENDPOINTS=http://etcd1:2379,http://etcd2:2379,http://etcd3:2379
@@ -11,8 +11,14 @@ Global/Universal
 -  **PATRONI\_NAME**: name of the node where the current instance of Patroni is running. Must be unique for the cluster.
 -  **PATRONI\_NAMESPACE**: path within the configuration store where Patroni will keep information about the cluster. Default value: "/service"
 -  **PATRONI\_SCOPE**: cluster name
-  **PATRONI\_LOGLEVEL**: sets the general logging level (see `the docs for Python logging <https://docs.python.org/3.6/library/logging.html#levels>`_)
-  **PATRONI\_REQUESTS_LOGLEVEL**: sets the logging level for all HTTP requests e.g. Kubernetes API calls (see `the docs for Python logging <https://docs.python.org/3.6/library/logging.html#levels>`_)
+-  **PATRONI\_LOG\_LEVEL**: sets the general logging level. Default value is **INFO** (see `the docs for Python logging <https://docs.python.org/3.6/library/logging.html#levels>`_)
+-  **PATRONI\_LOG\_FORMAT**: sets the log formatting string. Default value is **%(asctime)s %(levelname)s: %(message)s** (see `the LogRecord attributes <https://docs.python.org/3.6/library/logging.html#logrecord-attributes>`_)
+-  **PATRONI\_LOG\_DATEFORMAT**: sets the datetime formatting string. (see the `formatTime() documentation <https://docs.python.org/3.6/library/logging.html#logging.Formatter.formatTime>`_)
+-  **PATRONI\_LOG\_MAX\_QUEUE\_SIZE**: Patroni is using two-step logging. Log records are written into the in-memory queue and there is a separate thread which pulls them from the queue and writes to stderr or file. The maximum size of the internal queue is limited by default by **1000** records, which is enough to keep logs for the past 1h20m.
+-  **PATRONI\_LOG\_DIR**: Directory to write application logs to. The directory must exist and be writable by the user executing Patroni. If you set this env variable, the application will retain 4 25MB logs by default. You can tune those retention values with `PATRONI_LOG_FILE_NUM` and `PATRONI_LOG_FILE_SIZE` (see below).
+-  **PATRONI\_LOG\_FILE\_NUM**: The number of application logs to retain.
+-  **PATRONI\_LOG\_FILE\_SIZE**: Size of patroni.log file (in bytes) that triggers a log rolling.
+-  **PATRONI\_LOG\_LOGGERS**: Redefine logging level per python module. Example ``PATRONI_LOG_LOGGERS="{patroni.postmaster: WARNING, urllib3: DEBUG}"``

 Bootstrap configuration
 -----------------------
@@ -35,17 +41,25 @@ Consul
 -  **PATRONI\_CONSUL\_CERT**: (optional) File with the client certificate
 -  **PATRONI\_CONSUL\_KEY**: (optional) File with the client key. Can be empty if the key is part of certificate.
 -  **PATRONI\_CONSUL\_DC**: (optional) Datacenter to communicate with. By default the datacenter of the host is used.
+-  **PATRONI\_CONSUL\_CONSISTENCY**: (optional) Select consul consistency mode. Possible values are ``default``, ``consistent``, or ``stale`` (more details in `consul API reference <https://www.consul.io/api/features/consistency.html/>`__)
 -  **PATRONI\_CONSUL\_CHECKS**: (optional) list of Consul health checks used for the session. If not specified Consul will use "serfHealth" in additional to the TTL based check created by Patroni. Additional checks, in particular the "serfHealth", may cause the leader lock to expire faster than in `ttl` seconds when the leader instance becomes unavailable.
+-  **PATRONI\_CONSUL\_REGISTER\_SERVICE**: (optional) whether or not to register a service with the name defined by the scope parameter and the tag master, replica or standby-leader depending on the node's role. Defaults to **false**
+-  **PATRONI\_CONSUL\_SERVICE\_CHECK\_INTERVAL**: (optional) how often to perform health check against registered url

 Etcd
 ----
-  **PATRONI\_ETCD\_HOST**: the host:port for the etcd endpoint.
-  **PATRONI\_ETCD\_HOSTS**: list of etcd endpoints in format host1:port1,host2:port2,etc...
-  **PATRONI\_ETCD\_URL**: url for the etcd, in format: http(s)://(username:password@)host:port
+
 -  **PATRONI\_ETCD\_PROXY**: proxy url for the etcd. If you are connecting to the etcd using proxy, use this parameter instead of **PATRONI\_ETCD\_URL**
+-  **PATRONI\_ETCD\_URL**: url for the etcd, in format: http(s)://(username:password@)host:port
+-  **PATRONI\_ETCD\_HOSTS**: list of etcd endpoints in format 'host1:port1','host2:port2',etc...
+-  **PATRONI\_ETCD\_USE\_PROXIES**: If this parameter is set to true, Patroni will consider **hosts** as a list of proxies and will not perform a topology discovery of etcd cluster but stick to a fixed list of **hosts**.
+-  **PATRONI\_ETCD\_PROTOCOL**: http or https, if not specified http is used. If the **url** or **proxy** is specified - will take protocol from them.
+-  **PATRONI\_ETCD\_HOST**: the host:port for the etcd endpoint.
 -  **PATRONI\_ETCD\_SRV**: Domain to search the SRV record(s) for cluster autodiscovery.
+-  **PATRONI\_ETCD\_USERNAME**: username for etcd authentication.
+-  **PATRONI\_ETCD\_PASSWORD**: password for etcd authentication.
 -  **PATRONI\_ETCD\_CACERT**: The ca certificate. If present it will enable validation.
-  **PATRONI\_ETCD\_CERT**: File with the client certificate
+-  **PATRONI\_ETCD\_CERT**: File with the client certificate.
 -  **PATRONI\_ETCD\_KEY**: File with the client key. Can be empty if the key is part of certificate.

 Exhibitor
@@ -77,9 +91,11 @@ PostgreSQL
 -  **PATRONI\_REPLICATION\_PASSWORD**: replication password; the user will be created during initialization.
 -  **PATRONI\_SUPERUSER\_USERNAME**: name for the superuser, set during initialization (initdb) and later used by Patroni to connect to the postgres. Also this user is used by pg_rewind.
 -  **PATRONI\_SUPERUSER\_PASSWORD**: password for the superuser, set during initialization (initdb).
+-  **PATRONI\_REWIND\_USERNAME**: name for the user for ``pg_rewind``; the user will be created during initialization of postgres 11+ and all necessary `permissions <https://www.postgresql.org/docs/11/app-pgrewind.html#id-1.9.5.8.8>`__ will be granted.
+-  **PATRONI\_REWIND\_PASSWORD**: password for the user for ``pg_rewind``; the user will be created during initialization.

 REST API
-------- 
+--------
 -  **PATRONI\_RESTAPI\_CONNECT\_ADDRESS**: IP address and port to access the REST API.
 -  **PATRONI\_RESTAPI\_LISTEN**: IP address and port that Patroni will listen to, to provide health-check information for HAProxy.
 -  **PATRONI\_RESTAPI\_USERNAME**: Basic-auth username to protect unsafe REST API endpoints.
@@ -33,6 +33,35 @@ To install requirements on a Mac, run the following:

    brew install postgresql etcd haproxy libyaml python

+.. _psycopg2_install_options:
+
+**Psycopg2**
+
+Starting from `psycopg2-2.8 <http://initd.org/psycopg/articles/2019/04/04/psycopg-28-released/>`__ the binary version of psycopg2 will no longer be installed by default. Installing it from the source code requires C compiler and postgres+python dev packages.
+Since in the python world it is not possible to specify dependency as ``psycopg2 OR psycopg2-binary`` you will have to decide how to install it.
+
+There are a few options available:
+
+1. Use the package manager from your distro
+
+::
+
+    sudo apt-get install python-psycopg2   # install python2 psycopg2 module on Debian/Ubuntu
+    sudo apt-get install python3-psycopg2  # install python3 psycopg2 module on Debian/Ubuntu
+    sudo yum install python-psycopg2       # install python2 psycopg2 on RedHat/Fedora/CentOS
+
+2. Install psycopg2 from the binary package
+
+::
+
+    pip install psycopg2-binary
+
+3. Install psycopg2 from source
+
+::
+
+    pip install psycopg2>=2.5.4
+
 **General installation for pip**

 Patroni can be installed with pip:
@@ -66,6 +95,8 @@ Note that external tools to call in the replica creation or custom bootstrap scr
 independently of Patroni.


+.. _running_configuring:
+
 Running and Configuring
 -----------------------

@@ -10,6 +10,21 @@ Global/Universal
 -  **namespace**: path within the configuration store where Patroni will keep information about the cluster. Default value: "/service"
 -  **scope**: cluster name

+Log
+---
+-  **level**: sets the general logging level. Default value is **INFO** (see `the docs for Python logging <https://docs.python.org/3.6/library/logging.html#levels>`_)
+-  **format**: sets the log formatting string. Default value is **%(asctime)s %(levelname)s: %(message)s** (see `the LogRecord attributes <https://docs.python.org/3.6/library/logging.html#logrecord-attributes>`_)
+-  **dateformat**: sets the datetime formatting string. (see the `formatTime() documentation <https://docs.python.org/3.6/library/logging.html#logging.Formatter.formatTime>`_)
+-  **max\_queue\_size**: Patroni is using two-step logging. Log records are written into the in-memory queue and there is a separate thread which pulls them from the queue and writes to stderr or file. The maximum size of the internal queue is limited by default by **1000** records, which is enough to keep logs for the past 1h20m.
+-  **dir**: Directory to write application logs to. The directory must exist and be writable by the user executing Patroni. If you set this value, the application will retain 4 25MB logs by default. You can tune those retention values with `file_num` and `file_size` (see below).
+-  **file\_num**: The number of application logs to retain.
+-  **file\_size**: Size of patroni.log file (in bytes) that triggers a log rolling.
+-  **loggers**: This section allows redefining logging level per python module
+    -  **patroni.postmaster: WARNING**
+    -  **urllib3: DEBUG**
+
+.. _bootstrap_settings:
+
 Bootstrap configuration
 -----------------------
 -  **dcs**: This section will be written into `/<namespace>/<scope>/config` of a given configuration store after initializing of new cluster. This is the global configuration for the cluster. If you want to change some parameters for all cluster nodes - just do it in DCS (or via Patroni API) and all nodes will apply this configuration.
@@ -23,7 +38,7 @@ Bootstrap configuration
    -  **postgresql**:
        -  **use\_pg\_rewind**: whether or not to use pg_rewind
        -  **use\_slots**: whether or not to use replication_slots. Must be False for PostgreSQL 9.3. You should comment out max_replication_slots before it becomes ineligible for leader status.
-        -  **recovery\_conf**: additional configuration settings written to recovery.conf when configuring follower. 
+        -  **recovery\_conf**: additional configuration settings written to recovery.conf when configuring follower.
        -  **parameters**: list of configuration settings for Postgres. Many of these are required for replication to work.
    -  **standby\_cluster**: if this section is defined, we want to bootstrap a standby cluster.
        -  **host**: an address of remote master
@@ -36,8 +51,8 @@ Bootstrap configuration
    -  **slots**: define permanent replication slots. These slots will be preserved during switchover/failover. Patroni will try to create slots before opening connections to the cluster.
        -  **my_slot_name**: the name of replication slot. It is the responsibility of the operator to make sure that there are no clashes in names between replication slots automatically created by Patroni for members and permanent replication slots.
            -  **type**: slot type. Could be ``physical`` or ``logical``. If the slot is logical, you have to additionally define ``database`` and ``plugin``.
-               **database**: the database name where logical slots should be created.
-               **plugin**: the plugin name for the logical slot.
+            -  **database**: the database name where logical slots should be created.
+            -  **plugin**: the plugin name for the logical slot.
 -  **method**: custom script to use for bootstrapping this cluster.
   See :ref:`custom bootstrap methods documentation <custom_bootstrap>` for details.
   When ``initdb`` is specified revert to the default ``initdb`` command. ``initdb`` is also triggered when no ``method``
@@ -73,7 +88,10 @@ Most of the parameters are optional, but you have to specify one of the **host**
 -  **cert**: (optional) file with the client certificate
 -  **key**: (optional) file with the client key. Can be empty if the key is part of **cert**.
 -  **dc**: (optional) Datacenter to communicate with. By default the datacenter of the host is used.
+-  **consistency**: (optional) Select consul consistency mode. Possible values are ``default``, ``consistent``, or ``stale`` (more details in `consul API reference <https://www.consul.io/api/features/consistency.html/>`__)
 -  **checks**: (optional) list of Consul health checks used for the session. If not specified Consul will use "serfHealth" in additional to the TTL based check created by Patroni. Additional checks, in particular the "serfHealth", may cause the leader lock to expire faster than in `ttl` seconds when the leader instance becomes unavailable
+-  **register\_service**: (optional) whether or not to register a service with the name defined by the scope parameter and the tag master, replica or standby-leader depending on the node's role. Defaults to **false**
+-  **service\_check\_interval**: (optional) how often to perform health check against registered url

 Etcd
 ----
@@ -81,14 +99,15 @@ Most of the parameters are optional, but you have to specify one of the **host**

 -  **host**: the host:port for the etcd endpoint.
 -  **hosts**: list of etcd endpoint in format host1:port1,host2:port2,etc... Could be a comma separated string or an actual yaml list.
+-  **use\_proxies**: If this parameter is set to true, Patroni will consider **hosts** as a list of proxies and will not perform a topology discovery of etcd cluster.
 -  **url**: url for the etcd
 -  **proxy**: proxy url for the etcd. If you are connecting to the etcd using proxy, use this parameter instead of **url**
 -  **srv**: Domain to search the SRV record(s) for cluster autodiscovery.
 -  **protocol**: (optional) http or https, if not specified http is used. If the **url** or **proxy** is specified - will take protocol from them.
-  **username**: (optional) username for etcd authentication
+-  **username**: (optional) username for etcd authentication.
 -  **password**: (optional) password for etcd authentication.
 -  **cacert**: (optional) The ca certificate. If present it will enable validation.
-  **cert**: (optional) file with the client certificate
+-  **cert**: (optional) file with the client certificate.
 -  **key**: (optional) file with the client key. Can be empty if the key is part of **cert**.

 Exhibitor
@@ -120,21 +139,24 @@ PostgreSQL
    -  **replication**:
        -  **username**: replication username; the user will be created during initialization. Replicas will use this user to access master via streaming replication
        -  **password**: replication password; the user will be created during initialization.
+    -  **rewind**:
+        -  **username**: name for the user for ``pg_rewind``; the user will be created during initialization of postgres 11+ and all necessary `permissions <https://www.postgresql.org/docs/11/app-pgrewind.html#id-1.9.5.8.8>`__ will be granted.
+        -  **password**: password for the user for ``pg_rewind``; the user will be created during initialization.
 -  **callbacks**: callback scripts to run on certain actions. Patroni will pass the action, role and cluster name. (See scripts/aws.py as an example of how to write them.)
        -  **on\_reload**: run this script when configuration reload is triggered.
-        -  **on\_restart**: run this script when the cluster restarts.
-        -  **on\_role\_change**: run this script when the cluster is being promoted or demoted.
-        -  **on\_start**: run this script when the cluster starts.
-        -  **on\_stop**: run this script when the cluster stops.
+        -  **on\_restart**: run this script when the postgres restarts (without changing role).
+        -  **on\_role\_change**: run this script when the postgres is being promoted or demoted.
+        -  **on\_start**: run this script when the postgres starts.
+        -  **on\_stop**: run this script when the postgres stops.
 -  **connect\_address**: IP address + port through which Postgres is accessible from other nodes and applications.
 -  **create\_replica\_methods**: an ordered list of the create methods for turning a Patroni node into a new replica.
   "basebackup" is the default method; other methods are assumed to refer to scripts, each of which is configured as its
   own config item. See :ref:`custom replica creation methods documentation <custom_replica_creation>` for further explanation.
-  **data\_dir**: The location of the Postgres data directory, either existing or to be initialized by Patroni.
+-  **data\_dir**: The location of the Postgres data directory, either :ref:`existing <existing_data>` or to be initialized by Patroni.
 -  **config\_dir**: The location of the Postgres configuration directory, defaults to the data directory. Must be writable by Patroni.
 -  **bin\_dir**: Path to PostgreSQL binaries (pg_ctl, pg_rewind, pg_basebackup, postgres). The default value is an empty string meaning that PATH environment variable will be used to find the executables.
 -  **listen**: IP address + port that Postgres listens to; must be accessible from other nodes in the cluster, if you're using streaming replication. Multiple comma-separated addresses are permitted, as long as the port component is appended after to the last one with a colon, i.e. ``listen: 127.0.0.1,127.0.0.2:5432``. Patroni will use the first address from this list to establish local connections to the PostgreSQL node.
-  **use\_unix\_socket**: specifies that Patroni should prefer to use unix sockets to connect to the cluster. Default value is ``false``. If ``unix_socket_directories`` is definded, Patroni will use first suitable value from it to connect to the cluster and fallback to tcp if nothing is suitable. If ``unix_socket_directories`` is not specified in ``postgresql.parameters``, Patroni will assume that default value should be used and omit ``host`` from connection parameters.
+-  **use\_unix\_socket**: specifies that Patroni should prefer to use unix sockets to connect to the cluster. Default value is ``false``. If ``unix_socket_directories`` is defined, Patroni will use the first suitable value from it to connect to the cluster and fallback to tcp if nothing is suitable. If ``unix_socket_directories`` is not specified in ``postgresql.parameters``, Patroni will assume that the default value should be used and omit ``host`` from the connection parameters.
 -  **pgpass**: path to the `.pgpass <https://www.postgresql.org/docs/current/static/libpq-pgpass.html>`__ password file. Patroni creates this file before executing pg\_basebackup, the post_init script and under some other circumstances. The location must be writable by Patroni.
 -  **recovery\_conf**: additional configuration settings written to recovery.conf when configuring follower.
 -  **custom\_conf** : path to an optional custom ``postgresql.conf`` file, that will be used in place of ``postgresql.base.conf``. The file must exist on all cluster nodes, be readable by PostgreSQL and will be included from its location on the real ``postgresql.conf``. Note that Patroni will not monitor this file for changes, nor backup it. However, its settings can still be overridden by Patroni's own configuration facilities - see :ref:`dynamic configuration <dynamic_configuration>` for details.
@@ -142,15 +164,21 @@ PostgreSQL
 -  **pg\_hba**: list of lines that Patroni will use to generate ``pg_hba.conf``. This parameter has higher priority than ``bootstrap.pg_hba``. Together with :ref:`dynamic configuration <dynamic_configuration>` it simplifies management of ``pg_hba.conf``.
        -  **- host all all 0.0.0.0/0 md5**.
        -  **- host replication replicator 127.0.0.1/32 md5**: A line like this is required for replication.
+-  **pg\_ident**: list of lines that Patroni will use to generate ``pg_ident.conf``. Together with :ref:`dynamic configuration <dynamic_configuration>` it simplifies management of ``pg_ident.conf``.
+        -  **- mapname1 systemname1 pguser1**.
+        -  **- mapname1 systemname2 pguser2**.
 -  **pg\_ctl\_timeout**: How long should pg_ctl wait when doing ``start``, ``stop`` or ``restart``. Default value is 60 seconds.
 -  **use\_pg\_rewind**: try to use pg\_rewind on the former leader when it joins cluster as a replica.
-  **remove\_data\_directory\_on\_rewind\_failure**: If this option is enabled, Patroni will remove postgres data directory and recreate replica. Otherwise it will try to follow the new leader. Default value is **false**.
+-  **remove\_data\_directory\_on\_rewind\_failure**: If this option is enabled, Patroni will remove the PostgreSQL data directory and recreate the replica. Otherwise it will try to follow the new leader. Default value is **false**.
+-  **remove\_data\_directory\_on\_diverged\_timelines**: Patroni will remove the PostgreSQL data directory and recreate the replica if it notices that timelines are diverging and the former master can not start streaming from the new master. This option is useful when ``pg_rewind`` can not be used. Default value is **false**.
 -  **replica\_method**: for each create_replica_methods other than basebackup, you would add a configuration section of the same name. At a minimum, this should include "command" with a full path to the actual script to be executed. Other configuration parameters will be passed along to the script in the form "parameter=value".

 REST API
-------- 
-  **connect\_address**: IP address (or hostname) and port, to access the Patroni's REST API. It can serve as a endpoint for HTTP health checks (read below about the "listen" REST API parameter), and also for user queries (either directly or via the REST API), as well as for the health checks done by the cluster members during leader elections (for example, to determine whether the master is still running, or if there is a node which has a WAL position that is ahead of the one doing the query; etc.) The connect_address is put in the member key in DCS, making it possible to translate the member name into the address to connect to its REST API.
-  **listen**: IP address (or hostname) and port that Patroni will listen to for the REST API - to provide also the same health checks and cluster messaging between the participating nodes, as described above. to provide health-check information for HAProxy (or any other load balancer capable of doing a HTTP "OPTION" or "GET" checks)  
+--------
+-  **connect\_address**: IP address (or hostname) and port, to access the Patroni's REST API. All the members of the cluster must be able to connect to this address, so unless the Patroni setup is intended for a demo inside the localhost, this address must be a non "localhost" or loopback addres (ie: "localhost" or "127.0.0.1"). It can serve as a endpoint for HTTP health checks (read below about the "listen" REST API parameter), and also for user queries (either directly or via the REST API), as well as for the health checks done by the cluster members during leader elections (for example, to determine whether the master is still running, or if there is a node which has a WAL position that is ahead of the one doing the query; etc.) The connect_address is put in the member key in DCS, making it possible to translate the member name into the address to connect to its REST API.
+
+-  **listen**: IP address (or hostname) and port that Patroni will listen to for the REST API - to provide also the same health checks and cluster messaging between the participating nodes, as described above. to provide health-check information for HAProxy (or any other load balancer capable of doing a HTTP "OPTION" or "GET" checks).
+
 -  **Optional**:
        -  **authentication**:
            -  **username**: Basic-auth username to protect unsafe REST API endpoints.
@@ -164,7 +192,7 @@ REST API
 CTL
 ---
 -  **Optional**:
-    -  **insecure**: Allow connections to REST API without verifying SSL certs. 
+    -  **insecure**: Allow connections to REST API without verifying SSL certs.
    -  **cacert**: Specifices the file with the CA_BUNDLE file or directory with certificates of trusted CAs to use while verifying REST API SSL certs.
    -  **certfile**: Specifies the file with the certificate in the PEM format to use while verifying REST API SSL certs. If not provided patronictl will use the value provided for REST API "certfile" parameter.

@@ -76,6 +76,7 @@ Also, the following Patroni configuration options can be changed only dynamicall
 - loop_wait: 10
 - retry_timeouts: 10
 - maximum_lag_on_failover: 1048576
+- check_timeline: false
 - postgresql.use_slots: true

 Upon changing these options, Patroni will read the relevant section of the configuration stored in DCS and change its
@@ -0,0 +1,36 @@
+.. _existing_data:
+
+Convert a Standalone to a Patroni Cluster
+=========================================
+
+This section describes the process for converting a standalone PostgreSQL instance into a Patroni cluster.
+
+To deploy a Patroni cluster without using a pre-existing PostgreSQL instance, see :ref:`Running and Configuring <running_configuring>` instead.
+
+Procedure
+---------
+
+A Patroni cluster can be started with a data directory from a single-node PostgreSQL database. This is achieved by following closely these steps:
+
+1. Manually start PostgreSQL daemon
+2. Create Patroni superuser and replication users as defined in the :ref:`authentication <postgresql_settings>` section of the Patroni configuration. If this user is created in SQL, the following queries achieve this:
+
+.. code-block:: sql
+
+   CREATE USER $PATRONI_SUPERUSER_USERNAME WITH SUPERUSER ENCRYPTED PASSWORD '$PATRONI_SUPERUSER_PASSWORD';
+   CREATE USER $PATRONI_REPLICATION_USERNAME WITH REPLICATION ENCRYPTED PASSWORD '$PATRONI_REPLICATION_PASSWORD';
+
+3. Start Patroni (e.g. ``patroni /etc/patroni/patroni.yml``). It automatically detects that PostgreSQL daemon is already running but its configuration might be out-of-date.
+4. Ask Patroni to restart the node with ``patronictl restart cluster-name node-name``. This step is only required if PostgreSQL configuration is out-of-date.
+
+
+FAQ
+---
+
+- During Patroni startup, Patroni complains that it cannot bind to the PostgreSQL port.
+
+  You need to verify ``listen_addresses`` and ``port`` in ``postgresql.conf`` and ``postgresql.listen`` in ``patroni.yml``. Don't forget that ``pg_hba.conf`` should allow such access.
+
+- After asking Patroni to restart the node, PostgreSQL displays the error message ``could not open configuration file "/etc/postgresql/10/main/pg_hba.conf": No such file or directory``
+
+  It can mean various things depending on how you manage PostgreSQL configuration. If you specified `postgresql.config_dir`, Patroni generates the ``pg_hba.conf`` based on the settings in the :ref:`bootstrap <bootstrap_settings>` section only when it bootstraps a new cluster. In this scenario the ``PGDATA`` was not empty, therefore no bootstrap happened. This file must exist beforehand.
@@ -3,6 +3,288 @@
 Release notes
 =============

+Version 1.6.0
+-------------
+
+This version adds compatibility with PostgreSQL 12, makes is possible to run pg_rewind without superuser on PostgreSQL 11 and newer, and enables IPv6 support.
+
+
+**New features**
+
+- Psycopg2 was removed from requirements and must be installed independently (Alexander Kukushkin)
+
+  Starting from 2.8.0 ``psycopg2`` was split into two different packages, ``psycopg2``, and ``psycopg2-binary``, which could be installed at the same time into the same place on the filesystem. In order to decrease dependency hell problem, we let a user choose how to install it. There are a few options available, please consult the :ref:`documentation <psycopg2_install_options>`.
+
+- Compatibility with PostgreSQL 12 (Alexander Kukushkin)
+
+  Starting from PostgreSQL 12 there is no ``recovery.conf`` anymore and all former recovery parameters are converted into `GUC <https://www.enterprisedb.com/blog/what-is-a-guc-variable>`_. In order to protect from ``ALTER SYSTEM SET primary_conninfo`` or similar, Patroni will parse ``postgresql.auto.conf`` and remove all standby and recovery parameters from there. Patroni config remains backward compatible. For example despite ``restore_command`` being a GUC, one can still specify it in the ``postgresql.recovery_conf.restore_command`` section and Patroni will write it into ``postgresql.conf`` for PostgreSQL 12.
+
+- Make it possible to use ``pg_rewind`` without superuser on PostgreSQL 11 and newer (Alexander Kukushkin)
+
+  If you want to use this feature please define ``username`` and ``password`` in the ``postgresql.authentication.rewind`` section of Patroni configuration file. For an already existing cluster you will have to create the user manually and ``GRANT EXECUTE`` permission on a few functions. You can find more details in the PostgreSQL `documentation <https://www.postgresql.org/docs/11/app-pgrewind.html#id-1.9.5.8.8>`__.
+
+- Do a smart comparison of actual and desired ``primary_conninfo`` values on replicas (Alexander Kukushkin)
+
+  It might help to avoid replica restart when you are converting an already existing primary-standby cluster to one managed by Patroni
+
+- IPv6 support (Alexander Kukushkin)
+
+  There were two major issues. Patroni REST API service was listening only on ``0.0.0.0`` and IPv6 IP addresses used in the ``api_url`` and ``conn_url`` were not properly quoted.
+
+- Kerberos support (Ajith Vilas, Alexander Kukushkin)
+
+  It makes possible using Kerberos authentication between Postgres nodes instead of defining passwords in Patroni configuration file
+
+- Manage ``pg_ident.conf`` (Alexander Kukushkin)
+
+  This functionality works similarly to ``pg_hba.conf``: if the ``postgresql.pg_ident`` is defined in the config file or DCS, Patroni will write its value to ``pg_ident.conf``, however, if ``postgresql.parameters.ident_file`` is defined, Patroni will assume that ``pg_ident`` is managed from outside and not update the file.
+
+
+  **Improvements in REST API**
+
+- Added ``/health`` endpoint (Wilfried Roset)
+
+  It will return an HTTP status code only if PostgreSQL is running
+
+- Added ``/read-only`` and ``/read-write`` endpoints (Julien Riou)
+
+  The ``/read-only`` endpoint enables reads balanced across replicas and the primary. The ``/read-write`` endpoint is an alias for ``/primary``, ``/leader`` and ``/master``.
+
+- Use ``SSLContext`` to wrap the REST API socket (Julien Riou)
+
+  Usage of ``ssl.wrap_socket()`` is deprecated and was still allowing soon-to-be-deprecated protocols like TLS 1.1.
+
+
+**Logging improvements**
+
+- Two-step logging (Alexander Kukushkin)
+
+  All log messages are first written into the in-memory queue and later they are asynchronously flushed into the stderr or file from a separate thread. The maximum queue size is limited (configurable). If the limit is reached, Patroni will start losing logs, which is still better than blocking the HA loop.
+
+- Enable debug logging for GET/OPTIONS API calls together with latency (Jan Tomsa)
+
+  It will help with debugging of health-checks performed by HAProxy, Consul or other tooling that decides which node is the primary/replica.
+
+- Log exceptions caught in Retry (Daniel Kucera)
+
+  Log the final exception when either the number of attempts or the timeout were reached. It will hopefully help to debug some issues when communication to DCS fails.
+
+
+**Improvements in patronictl**
+
+- Enhance dialogues for scheduled switchover and restart (Rafia Sabih)
+
+  Previously dialogues did not take into account scheduled actions and therefore were misleading.
+
+- Check if config file exists (Wilfried Roset)
+
+  Be verbose about configuration file when the given filename does not exists, instead of ignoring silently (which can lead to misunderstanding).
+
+- Add fallback value for ``EDITOR`` (Wilfried Roset)
+
+  When the ``EDITOR`` environment variable was not defined, ``patronictl edit-config`` was failing with `PatroniCtlException`. The new strategy is to try ``editor`` and than ``vi``, which should be available on most systems.
+
+
+**Improvements in Consul support**
+
+- Allow to specify Consul consistency mode (Jan Tomsa)
+
+  You can read more about consistency mode `here <https://www.consul.io/api/features/consistency.html>`__.
+
+- Reload Consul config on SIGHUP (Cameron Daniel, Alexander Kukushkin)
+
+  It is especially useful when somebody is changing the value of ``token``.
+
+
+**Bugfixes**
+
+- Fix corner case in switchover/failover (Sharoon Thomas)
+
+  The variable ``scheduled_at`` may be undefined if REST API is not accessible and we are using DCS as a fallback.
+
+- Open trust to localhost in ``pg_hba.conf`` during custom bootstrap (Alexander Kukushkin)
+
+  Previously it was open only to unix_socket, which was causing a lot of errors: ``FATAL:  no pg_hba.conf entry for replication connection from host "127.0.0.1", user "replicator"``
+
+- Consider synchronous node as healthy even when the former leader is ahead (Alexander Kukushkin)
+
+  If the primary loses access to the DCS, it restarts Postgres in read-only, but it might happen that other nodes can still access the old primary via the REST API. Such a situation was causing the synchronous standby not to promote because the old primary was reporting WAL position ahead of the synchronous standby.
+
+- Standby cluster bugfixes (Alexander Kukushkin)
+
+  Make it possible to bootstrap a replica in a standby cluster when the standby_leader is not accessible and a few other minor fixes.
+
+
+Version 1.5.6
+-------------
+
+**New features**
+
+- Support work with etcd cluster via set of proxies (Alexander Kukushkin)
+
+  It might happen that etcd cluster is not accessible directly but via set of proxies. In this case Patroni will not perform etcd topology discovery but just round-robin via proxy hosts. Behavior is controlled by `etcd.use_proxies`.
+
+- Changed callbacks behavior when role on the node is changed (Alexander)
+
+  If the role was changed from `master` or `standby_leader` to `replica` or from `replica` to `standby_leader`, `on_restart` callback will not be called anymore in favor of `on_role_change` callback.
+
+- Change the way how we start postgres (Alexander)
+
+  Use `multiprocessing.Process` instead of executing itself and `multiprocessing.Pipe` to transmit the postmaster pid to the Patroni process. Before that we were using pipes, what was leaving postmaster process with stdin closed.
+
+**Bug fixes**
+
+- Fix role returned by REST API for the standby leader (Alexander)
+
+  It was incorrectly returning `replica` instead of `standby_leader`
+
+- Wait for callback end if it could not be killed (Julien Tachoires)
+
+  Patroni doesn't have enough privileges to terminate the callback script running under `sudo` what was cancelling the new callback. If the running script could not be killed, Patroni will wait until it finishes and then run the next callback.
+
+- Reduce lock time taken by dcs.get_cluster method (Alexander)
+
+  Due to the lock being held DCS slowness was affecting the REST API health checks causing false positives.
+
+- Improve cleaning of PGDATA when `pg_wal`/`pg_xlog` is a symlink (Julien)
+
+  In this case Patroni will explicitly remove files from the target directory.
+
+- Remove unnecessary usage of os.path.relpath (Ants Aasma)
+
+  It depends on being able to resolve the working directory, what will fail if Patroni is started in a directory that is later unlinked from the filesystem.
+
+- Do not enforce ssl version when communicating with Etcd (Alexander)
+
+  For some unknown reason python3-etcd on debian and ubuntu are not based on the latest version of the package and therefore it enforces TLSv1 which is not supported by Etcd v3. We solved this problem on Patroni side.
+
+Version 1.5.5
+-------------
+
+This version introduces the possibility of automatic reinit of the former master, improves patronictl list output and fixes a number of bugs.
+
+**New features**
+
+- Add support of `PATRONI_ETCD_PROTOCOL`, `PATRONI_ETCD_USERNAME` and `PATRONI_ETCD_PASSWORD` environment variables (Étienne M)
+
+  Before it was possible to configure them only in the config file or as a part of `PATRONI_ETCD_URL`, which is not always convenient.
+
+- Make it possible to automatically reinit the former master (Alexander Kukushkin)
+
+  If the pg_rewind is disabled or can't be used, the former master could fail to start as a new replica due to diverged timelines. In this case, the only way to fix it is wiping the data directory and reinitializing. This behavior could be changed by setting `postgresql.remove_data_directory_on_diverged_timelines`. When it is set, Patroni will wipe the data directory and reinitialize the former master automatically.
+
+- Show information about timelines in patronictl list (Alexander)
+
+  It helps to detect stale replicas. In addition to that, `Host` will include ':{port}' if the port value isn't default or there is more than one member running on the same host.
+
+- Create a headless service associated with the $SCOPE-config endpoint (Alexander)
+
+  The "config" endpoint keeps information about the cluster-wide Patroni and Postgres configuration, history file, and last but the most important, it holds the `initialize` key. When the Kubernetes master node is restarted or upgraded, it removes endpoints without services. The headless service will prevent it from being removed.
+
+**Bug fixes**
+
+- Adjust the read timeout for the leader watch blocking query (Alexander)
+
+  According to the Consul documentation, the actual response timeout is increased by a small random amount of additional wait time added to the supplied maximum wait time to spread out the wake up time of any concurrent requests. It adds up to `wait / 16` additional time to the maximum duration. In our case we are adding `wait / 15` or 1 second depending on what is bigger.
+
+- Always use replication=1 when connecting via replication protocol to the postgres (Alexander)
+
+  Starting from Postgres 10 the line in the pg_hba.conf with database=replication doesn't accept connections with the parameter replication=database.
+
+- Don't write primary_conninfo into recovery.conf for wal-only standby cluster (Alexander)
+
+  Despite not having neither `host` nor `port` defined in the `standby_cluster` config, Patroni was putting the `primary_conninfo` into the `recovery.conf`, which is useless and generating a lot of errors.
+
+
+Version 1.5.4
+-------------
+
+This version implements flexible logging and fixes a number of bugs.
+
+**New features**
+
+- Improvements in logging infrastructure (Alexander Kukushkin, Lucas Capistrant, Alexander Anikin)
+
+  Logging configuration could be configured not only from environment variables but also from Patroni config file. It makes it possible to change logging configuration in runtime by updating config and doing reload or sending SIGHUP to the Patroni process. By default Patroni writes logs to stderr, but now it becomes possible to write logs directly into the file and rotate when it reaches a certain size. In addition to that added support of custom dateformat and the possibility to fine-tune log level for each python module.
+
+- Make it possible to take into account the current timeline during leader elections (Alexander Kukushkin)
+
+  It could happen that the node is considering itself as a healthiest one although it is currently not on the latest known timeline. In some cases we want to avoid promoting of such node, which could be achieved by setting `check_timeline` parameter to `true` (default behavior remains unchanged).
+
+- Relaxed requirements on superuser credentials
+
+  Libpq allows opening connections without explicitly specifying neither username nor password. Depending on situation it relies either on pgpass file or trust authentication method in pg_hba.conf. Since pg_rewind is also using libpq, it will work the same way.
+
+- Implemented possibility to configure Consul Service registration and check interval via environment variables (Alexander Kukushkin)
+
+  Registration of service in Consul was added in the 1.5.0, but so far it was only possible to turn it on via patroni.yaml.
+
+**Stability Improvements**
+
+- Set archive_mode to off during the custom bootstrap (Alexander Kukushkin)
+
+  We want to avoid archiving wals and history files until the cluster is fully functional.  It really helps if the custom bootstrap involves pg_upgrade.
+
+- Apply five seconds backoff when loading global config on start (Alexander Kukushkin)
+
+  It helps to avoid hammering DCS when Patroni just starting up.
+
+- Reduce amount of error messages generated on shutdown (Alexander Kukushkin)
+
+  They were harmless but rather annoying and sometimes scary.
+
+- Explicitly secure rw perms for recovery.conf at creation time (Lucas)
+
+  We don't want anybody except patroni/postgres user reading this file, because it contains replication user and password.
+
+- Redirect HTTPServer exceptions to logger (Julien Riou)
+
+  By default, such exceptions were logged on standard output messing with regular logs.
+
+**Bug fixes**
+
+- Removed stderr pipe to stdout on pg_ctl process (Cody Coons)
+
+  Inheriting stderr from the main Patroni process allows all Postgres logs to be seen along with all patroni logs. This is very useful in a container environment as Patroni and Postgres logs may be consumed using standard tools (docker logs, kubectl, etc). In addition to that, this change fixes a bug with Patroni not being able to catch postmaster pid when postgres writing some warnings into stderr.
+
+- Set Consul service check deregister timeout in Go time format (Pavel Kirillov)
+
+  Without explicitly mentioned time unit registration was failing.
+
+- Relax checks of standby_cluster cluster configuration (Dmitry Dolgov, Alexander Kukushkin)
+
+  It was accepting only strings as valid values and therefore it was not possible to specify the port as integer and create_replica_methods as a list.
+
+Version 1.5.3
+-------------
+
+Compatibility and bugfix release.
+
+- Improve stability when running with python3 against zookeeper (Alexander Kukushkin)
+
+  Change of `loop_wait` was causing Patroni to disconnect from zookeeper and never reconnect back.
+
+- Fix broken compatibility with postgres 9.3 (Alexander)
+
+  When opening a replication connection we should specify replication=1, beacuse 9.3 does not understand replication='database'
+
+- Make sure we refresh Consul session at least once per HA loop and improve handling of consul sessions exceptions (Alexander)
+
+  Restart of local consul agent invalidates all sessions related to the node. Not calling session refresh on time and not doing proper handling of session errors was causing demote of the primary.
+
+Version 1.5.2
+-------------
+
+Compatibility and bugfix release.
+
+- Compatibility with kazoo-2.6.0 (Alexander Kukushkin)
+
+  In order to make sure that requests are performed with an appropriate timeout, Patroni redefines create_connection method from python-kazoo module. The last release of kazoo slightly changed the way how create_connection method is called.
+
+- Fix Patroni crash when Consul cluster loses the leader (Alexander)
+
+  The crash was happening due to incorrect implementation of touch_member method, it should return boolean and not raise any exceptions.
+
 Version 1.5.1
 -------------

@@ -101,7 +101,7 @@ example: pgbackrest
            - pgbackrest
            - basebackup
        pgbackrest:
-            command: /usr/bin/pgbackrest --stanza=mydb --deltarestore
+            command: /usr/bin/pgbackrest --stanza=<scope> --delta restore
            keep_data: True
            no_params: True
        basebackup:
@@ -177,9 +177,15 @@ standby nodes replicating from some remote master. This type of clusters has:

 Standby leader holds and updates a leader lock in DCS. If the leader lock
 expires, cascade replicas will perform an election to choose another leader
-from the standbys. For the sake of flexibility, you can specify different
-methods of creating a replica and recovery WAL records when a cluster is in the
-"standby mode", and after it was detached to function as a normal cluster.
+from the standbys.
+
+For the sake of flexibility, you can specify methods of creating a replica and
+recovery WAL records when a cluster is in the "standby mode" by providing
+`create_replica_methods` key in `standby_cluster` section. It is distinct from
+creating replicas, when cluster is detached and functions as a normal cluster,
+which is controlled by `create_replica_methods` in `postgresql` section. Both
+"standby" and "normal" `create_replica_methods` reference  keys in `postgresql`
+section.

 To configure such cluster you need to specify the section ``standby_cluster``
 in a patroni configuration:
@@ -192,6 +198,10 @@ in a patroni configuration:
                host: 1.2.3.4
                port: 5432
                primary_slot_name: patroni
+                create_replica_methods:
+                - basebackup

 Note, that these options will be applied only once during cluster bootstrap,
 and the only way to change them afterwards is through DCS.
+
+If you use replication slots on the standby cluster, you must also create the corresponding replication slot on the primary cluster.  It will not be done automatically by the standby cluster implementation.  You can use Patroni's permenant replication slots feature on the primary cluster to maintain a replication slot with the same name as ``primary_slot_name``, or its default value if ``primary_slot_name`` is not provided.
@@ -13,6 +13,8 @@ In asynchronous mode the cluster is allowed to lose some committed transactions

 The amount of transactions that can be lost is controlled via ``maximum_lag_on_failover`` parameter. Because the primary transaction log position is not sampled in real time, in reality the amount of lost data on failover is worst case bounded by  ``maximum_lag_on_failover`` bytes of transaction log plus the amount that is written in the last ``ttl`` seconds (``loop_wait``/2 seconds in the average case). However typical steady state replication delay is well under a second.

+By default, when running leader elections, Patroni does not take into account the current timeline of replicas, what in some cases could be undesirable behavior. You can prevent the node not having the same timeline as a former master become the new leader by changing the value of ``check_timeline`` parameter to ``true``.
+
 PostgreSQL synchronous replication
 ----------------------------------

@@ -1,11 +1,11 @@
 ### confd

-`confd` directory contains haproxy template files for the [confd](https://github.com/kelseyhightower/confd) -- lightweight configuration management tool
+`confd` directory contains haproxy and pgbouncer template files for the [confd](https://github.com/kelseyhightower/confd) -- lightweight configuration management tool
 You need to copy content of `confd` directory into /etcd/confd and run confd service:
 ```bash
 $ confd -prefix=/service/$PATRONI_SCOPE -backend etcd -node $PATRONI_ETCD_URL -interval=10
 ```
-It will periodically update haproxy.cfg with the actual list of Patroni nodes from `etcd` and "reload" haproxy when it is necessary.
+It will periodically update haproxy.cfg and pgbouncer.ini with the actual list of Patroni nodes from `etcd` and "reload" haproxy and pgbouncer.ini when it is necessary.


 ### startup-scripts
@@ -0,0 +1,12 @@
+[template]
+prefix = "/service/batman"
+owner = "postgres"
+mode = "0644"
+src = "pgbouncer.tmpl"
+dest = "/etc/pgbouncer/pgbouncer.ini"
+
+reload_cmd = "systemctl reload pgbouncer"
+
+keys = [
+    "/members/","/leader"
+]
@@ -0,0 +1,17 @@
+[databases]
+{{with get "/leader"}}{{$leader := .Value}}{{$leadkey := printf "/members/%s" $leader}}{{with get $leadkey}}{{$data := json .Value}}{{$hostport := base (replace (index (split $data.conn_url "/") 2) "@" "/" -1)}}{{ $host := base (index (split $hostport ":") 0)}}{{ $port := base (index (split $hostport ":") 1)}}* = host={{ $host }} port={{ $port }} pool_size=10{{end}}{{end}}
+
+[pgbouncer]
+logfile = /var/log/postgresql/pgbouncer.log
+pidfile = /var/run/postgresql/pgbouncer.pid
+listen_addr = *
+listen_port = 6432
+unix_socket_dir = /var/run/postgresql
+auth_type = trust
+auth_file = /etc/pgbouncer/userlist.txt
+auth_hba_file = /etc/pgbouncer/pg_hba.txt
+admin_users = pgbouncer
+stats_users = pgbouncer
+pool_mode = session
+max_client_conn = 100
+default_pool_size = 20
@@ -12,6 +12,7 @@ import shutil
 import signal
 import six
 import subprocess
+import sys
 import tempfile
 import threading
 import time
@@ -84,7 +85,7 @@ class AbstractController(object):


 class PatroniController(AbstractController):
-    __PORT = 5440
+    __PORT = 5360
    PATRONI_CONFIG = '{}.yml'
    """ starts and stops individual patronis"""

@@ -110,19 +111,31 @@ class PatroniController(AbstractController):
        with open(os.path.join(self._data_dir, 'label'), 'w') as f:
            f.write(content)

-    def read_label(self):
+    def read_label(self, label):
        try:
-            with open(os.path.join(self._data_dir, 'label'), 'r') as f:
+            with open(os.path.join(self._data_dir, label), 'r') as f:
                return f.read().strip()
        except IOError:
            return None

-    def add_tag_to_config(self, tag, value):
+    @staticmethod
+    def recursive_update(dst, src):
+        for k, v in src.items():
+            if k in dst and isinstance(dst[k], dict):
+                PatroniController.recursive_update(dst[k], v)
+            else:
+                dst[k] = v
+
+    def update_config(self, custom_config):
        with open(self._config) as r:
            config = yaml.safe_load(r)
-            config['tags']['tag'] = value
+            self.recursive_update(config, custom_config)
            with open(self._config, 'w') as w:
                yaml.safe_dump(config, w, default_flow_style=False)
+        self._scope = config.get('scope', 'batman')
+
+    def add_tag_to_config(self, tag, value):
+        self.update_config({'tags': {tag: value}})

    def _start(self):
        if self.watchdog:
@@ -130,7 +143,8 @@ class PatroniController(AbstractController):
        if isinstance(self._context.dcs_ctl, KubernetesController):
            self._context.dcs_ctl.create_pod(self._name[8:], self._scope)
            os.environ['PATRONI_KUBERNETES_POD_IP'] = '10.0.0.' + self._name[-1]
-        return subprocess.Popen(['coverage', 'run', '--source=patroni', '-p', 'patroni.py', self._config],
+        return subprocess.Popen([sys.executable, '-m', 'coverage', 'run',
+                                '--source=patroni', '-p', 'patroni.py', self._config],
                                stdout=self._log, stderr=subprocess.STDOUT, cwd=self._work_directory)

    def stop(self, kill=False, timeout=15, postgres=False):
@@ -174,13 +188,7 @@ class PatroniController(AbstractController):
                config['bootstrap']['initdb'].extend([{'auth': 'md5'}, {'auth-host': 'md5'}])

        if custom_config is not None:
-            def recursive_update(dst, src):
-                for k, v in src.items():
-                    if k in dst and isinstance(dst[k], dict):
-                        recursive_update(dst[k], v)
-                    else:
-                        dst[k] = v
-            recursive_update(config, custom_config)
+            self.recursive_update(config, custom_config)

        if config['postgresql'].get('callbacks', {}).get('on_role_change'):
            config['postgresql']['callbacks']['on_role_change'] += ' ' + str(self.__PORT)
@@ -290,9 +298,9 @@ class PatroniController(AbstractController):
    def backup_source(self):
        return 'postgres://{username}:{password}@{host}:{port}/{database}'.format(**self._replication)

-    def backup(self, dest='basebackup'):
+    def backup(self, dest='data/basebackup'):
        subprocess.call([PatroniPoolController.BACKUP_SCRIPT, '--walmethod=none',
-                         '--datadir=' + os.path.join(self._output_dir, dest),
+                         '--datadir=' + os.path.join(self._work_directory, dest),
                         '--dbname=' + self.backup_source])


@@ -366,6 +374,7 @@ class ConsulController(AbstractDcsController):
    def __init__(self, context):
        super(ConsulController, self).__init__(context)
        os.environ['PATRONI_CONSUL_HOST'] = 'localhost:8500'
+        os.environ['PATRONI_CONSUL_REGISTER_SERVICE'] = 'on'
        self._client = consul.Consul()
        self._config_file = None

@@ -628,7 +637,7 @@ class PatroniPoolController(object):
                'parameters': {
                    'archive_mode': 'on',
                    'archive_command': 'mkdir -p {0} && test ! -f {0}/%f && cp %p {0}/%f'.format(
-                            os.path.join(self._output_dir, 'wal_archive'))
+                            os.path.join(self.patroni_path, 'data/wal_archive'))
                },
                'authentication': {
                    'superuser': {'password': 'zalando1'},
@@ -644,11 +653,12 @@ class PatroniPoolController(object):
            'bootstrap': {
                'method': 'backup_restore',
                'backup_restore': {
-                    'command': 'features/backup_restore.sh --sourcedir=' + os.path.join(self._output_dir, 'basebackup'),
+                    'command': 'features/backup_restore.sh --sourcedir=' + os.path.join(self.patroni_path,
+                                                                                        'data/basebackup'),
                    'recovery_conf': {
                        'recovery_target_action': 'promote',
                        'recovery_target_timeline': 'latest',
-                        'restore_command': 'cp {0}/wal_archive/%f %p'.format(self._output_dir)
+                        'restore_command': 'cp {0}/data/wal_archive/%f %p'.format(self.patroni_path)
                    }
                }
            },
@@ -802,8 +812,8 @@ def before_all(context):

 def after_all(context):
    context.dcs_ctl.stop()
-    subprocess.call(['coverage', 'combine'])
-    subprocess.call(['coverage', 'report'])
+    subprocess.call([sys.executable, '-m', 'coverage', 'combine'])
+    subprocess.call([sys.executable, '-m', 'coverage', 'report'])


 def before_feature(context, feature):
@@ -816,3 +826,5 @@ def after_feature(context, feature):
    context.pctl.stop_all()
    shutil.rmtree(os.path.join(context.pctl.patroni_path, 'data'))
    context.dcs_ctl.cleanup_service_tree()
+    if feature.status == 'failed':
+        shutil.copytree(context.pctl.output_dir, context.pctl.output_dir + '_failed')
@@ -8,6 +8,8 @@ Scenario: check API requests on a stand-alone server
 	Then I receive a response code 200
 	And I receive a response state running
 	And I receive a response role master
+	When I issue a GET request to http://127.0.0.1:8008/health
+	Then I receive a response code 200
 	When I issue a GET request to http://127.0.0.1:8008/replica
 	Then I receive a response code 503
 	When I run patronictl.py reinit batman postgres0 --force
@@ -43,7 +45,7 @@ Scenario: check dynamic configuration change via DCS
 	And I receive a response loop_wait 2
 	When I issue a GET request to http://127.0.0.1:8008/patroni
 	Then I receive a response code 200
-	And I receive a response tags {'tag': 'new_value'}
+	And I receive a response tags {'new_tag': 'new_value'}

 Scenario: check API requests for the primary-replica pair in the pause mode
 	Given I run patronictl.py pause batman
@@ -2,15 +2,20 @@ Feature: standby cluster
  Scenario: check permanent logical slots are preserved on failover/switchover
    Given I start postgres1
    Then postgres1 is a leader after 10 seconds
+    And I sleep for 3 seconds
+    When I issue a PATCH request to http://127.0.0.1:8009/config with {"loop_wait": 2, "slots": {"pm_1": {"type": "physical"}}, "postgresql": {"parameters": {"wal_level": "logical"}}}
+    Then I receive a response code 200
+    And Response on GET http://127.0.0.1:8009/config contains slots after 10 seconds
+    And I sleep for 3 seconds
    When I issue a PATCH request to http://127.0.0.1:8009/config with {"slots": {"test_logical": {"type": "logical", "database": "postgres", "plugin": "test_decoding"}}}
    Then I receive a response code 200
-    When I issue a PATCH request to http://127.0.0.1:8009/config with {"slots": {"pm_1": {"type": "physical"}}, "postgresql": {"parameters": {"wal_level": "logical"}}}
-    Then I receive a response code 200
+    And I do a backup of postgres1
    When I start postgres0 with callback configured
    Then "members/postgres0" key in DCS has state=running after 10 seconds
+    And replication works from postgres1 to postgres0 after 15 seconds
    When I shut down postgres1
    Then postgres0 is a leader after 10 seconds
-    And I sleep for 2 seconds
+    And "members/postgres0" key in DCS has role=master after 3 seconds
    When I issue a GET request to http://127.0.0.1:8008/
    Then I receive a response code 200
    And there is a label with "test_logical" in postgres0 data directory
@@ -18,9 +23,14 @@ Feature: standby cluster
  Scenario: check replication of a single table in a standby cluster
    Given I start postgres1 in a standby cluster batman1 as a clone of postgres0
    Then postgres1 is a leader of batman1 after 10 seconds
-    When I issue a PATCH request to http://127.0.0.1:8009/config with {"ttl": 20, "loop_wait": 2}
-    And I add the table foo to postgres0
+    When I add the table foo to postgres0
    Then table foo is present on postgres1 after 20 seconds
+    When I issue a GET request to http://127.0.0.1:8009/master
+    Then I receive a response code 200
+    When I issue a GET request to http://127.0.0.1:8009/standby_leader
+    Then I receive a response code 200
+    And I receive a response role standby_leader
+    And there is a postgres1_cb.log with "on_start replica batman1\non_role_change standby_leader batman1" in postgres1 data directory
    When I start postgres2 in a cluster batman1
    Then postgres2 role is the replica after 24 seconds
    And table foo is present on postgres2 after 20 seconds
@@ -28,4 +38,11 @@ Feature: standby cluster
  Scenario: check failover
    When I kill postgres1
    And I kill postmaster on postgres1
-    Then postgres2 is replicating from postgres0 after 20 seconds
+    Then postgres2 is replicating from postgres0 after 32 seconds
+    When I issue a GET request to http://127.0.0.1:8010/master
+    Then I receive a response code 200
+    When I issue a GET request to http://127.0.0.1:8010/standby_leader
+    Then I receive a response code 200
+    And I receive a response role standby_leader
+    And replication works from postgres0 to postgres2 after 15 seconds
+    And there is a postgres2_cb.log with "on_start replica batman1\non_role_change standby_leader batman1" in postgres2 data directory
@@ -9,9 +9,10 @@ def start_patroni_with_a_name_value_tag(context, name, tag_name, tag_value):
    return context.pctl.start(name, custom_config={'tags': {tag_name: tag_value}})


-@then('There is a label with "{content:w}" in {name:w} data directory')
-def check_label(context, content, name):
-    label = context.pctl.read_label(name)
+@then('There is a {label} with "{content}" in {name:w} data directory')
+def check_label(context, label, content, name):
+    label = context.pctl.read_label(name, label)
+    label = label.replace('\n', '\\n')
    assert label == content, "{0} is not equal to {1}".format(label, content)


@@ -5,6 +5,7 @@ import parse
 import requests
 import shlex
 import subprocess
+import sys
 import time
 import yaml

@@ -95,7 +96,7 @@ def do_request(context, request_method, url, data):

@step('I run {cmd}')
 def do_run(context, cmd):
-    cmd = ['coverage', 'run', '--source=patroni', '-p'] + shlex.split(cmd)
+    cmd = [sys.executable, '-m', 'coverage', 'run', '--source=patroni', '-p'] + shlex.split(cmd)
    try:
        # XXX: Dirty hack! We need to take name/passwd from the config!
        env = os.environ.copy()
@@ -9,6 +9,8 @@ SELECT * FROM pg_catalog.pg_stat_replication
 WHERE application_name = '{0}'
 """

+callback = "bash -c 'echo \"${*: -3:1} ${*: -2:1} ${*: -1:1}\" >> data/$1/$1_cb.log' -- "
+

@step('I start {name:w} with callback configured')
 def start_patroni_with_callbacks(context, name):
@@ -24,29 +26,41 @@ def start_patroni_with_callbacks(context, name):
@step('I start {name:w} in a cluster {cluster_name:w}')
 def start_patroni(context, name, cluster_name):
    return context.pctl.start(name, custom_config={
-        "scope": cluster_name
+        "scope": cluster_name,
+        "postgresql": {
+            "callbacks": {c: callback + name for c in ('on_start', 'on_stop', 'on_restart', 'on_role_change')},
+            "backup_restore": {
+                "command": "features/backup_restore.sh --sourcedir=" + os.path.join(context.pctl.patroni_path,
+                                                                                    "data/basebackup")}
+        }
    })


@step('I start {name:w} in a standby cluster {cluster_name:w} as a clone of {name2:w}')
-def start_patroni_stanby_cluster(context, name, cluster_name, name2):
-    ctl = context.pctl._processes.pop(name, None)
+def start_patroni_standby_cluster(context, name, cluster_name, name2):
    # we need to remove patroni.dynamic.json in order to "bootstrap" standby cluster with existing PGDATA
-    if ctl:
-        os.unlink(os.path.join(ctl._data_dir, 'patroni.dynamic.json'))
+    os.unlink(os.path.join(context.pctl._processes[name]._data_dir, 'patroni.dynamic.json'))
    port = context.pctl._processes[name2]._connkwargs.get('port')
-    return context.pctl.start(name, custom_config={
+    context.pctl._processes[name].update_config({
        "scope": cluster_name,
        "bootstrap": {
            "dcs": {
+                "ttl": 20,
+                "loop_wait": 2,
+                "retry_timeout": 5,
                "standby_cluster": {
                    "host": "localhost",
                    "port": port,
                    "primary_slot_name": "pm_1",
+                    "create_replica_methods": ["backup_restore", "basebackup"]
                }
            }
+        },
+        "postgresql": {
+            "callbacks": {c: callback + name for c in ('on_start', 'on_stop', 'on_restart', 'on_role_change')}
        }
    })
+    return context.pctl.start(name)


@step('{pg_name1:w} is replicating from {pg_name2:w} after {timeout:d} seconds')
@@ -61,8 +75,8 @@ def check_replication_status(context, pg_name1, pg_name2, timeout):
        )

        if cur and len(cur.fetchall()) != 0:
-            return True
+            break

        time.sleep(1)
-
-    return False
+    else:
+        assert False, "{0} is not replicating from {1} after {2} seconds".format(pg_name1, pg_name2, timeout)
@@ -1,32 +1,34 @@
-FROM postgres:9.6
+FROM postgres:11
 MAINTAINER Alexander Kukushkin <[email protected]>

 RUN export DEBIAN_FRONTEND=noninteractive \
    && echo 'APT::Install-Recommends "0";\nAPT::Install-Suggests "0";' > /etc/apt/apt.conf.d/01norecommend \
    && apt-get update -y \
    && apt-get upgrade -y \
-    && apt-get install -y git curl jq python-psycopg2 python-yaml python-requests python-six python-pysocks \
-        python-dateutil python-pip python-prettytable python-wheel python-psutil python locales \
-
+    && apt-cache depends patroni | sed -n -e 's/.* Depends: \(python3-.\+\)$/\1/p' \
+            | grep -Ev '^python3-(sphinx|etcd|consul|kazoo|kubernetes)' \
+            | xargs apt-get install -y vim-tiny curl jq locales git python3-pip python3-wheel \
    ## Make sure we have a en_US.UTF-8 locale available
    && localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8 \
-
-    && pip install setuptools pip --upgrade \
-    && pip install 'git+https://github.com/zalando/patroni.git#egg=patroni[kubernetes]' \
-
-    && mkdir -p /home/postgres \
-    && chown postgres:postgres /home/postgres \
-
+    && pip3 install setuptools \
+    && pip3 install 'git+https://github.com/zalando/patroni.git#egg=patroni[kubernetes]' \
+    && PGHOME=/home/postgres \
+    && mkdir -p $PGHOME \
+    && chown postgres $PGHOME \
+    && sed -i "s|/var/lib/postgresql.*|$PGHOME:/bin/bash|" /etc/passwd \
+    # Set permissions for OpenShift
+    && chmod 775 $PGHOME \
+    && chmod 664 /etc/passwd \
    # Clean up
-    && apt-get remove -y git python-pip python-setuptools \
+    && apt-get remove -y git python3-pip python3-wheel \
    && apt-get autoremove -y \
    && apt-get clean -y \
    && rm -rf /var/lib/apt/lists/* /root/.cache

-ADD entrypoint.sh callback.py /
+ADD entrypoint.sh /

 EXPOSE 5432 8008
-ENV LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
+ENV LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8 EDITOR=/usr/bin/editor
 USER postgres
 WORKDIR /home/postgres
 CMD ["/bin/bash", "/entrypoint.sh"]
@@ -1,62 +0,0 @@
-#!/usr/bin/env python
-
-import logging
-import os
-import socket
-import sys
-import time
-
-from kubernetes import client as k8s_client, config as k8s_config
-from urllib3.exceptions import HTTPError
-from six.moves.http_client import HTTPException
-
-logger = logging.getLogger(__name__)
-
-
-class CoreV1Api(k8s_client.CoreV1Api):
-
-    def retry(func):
-        def wrapped(*args, **kwargs):
-            count = 0
-            while True:
-                try:
-                    return func(*args, **kwargs)
-                except (HTTPException, HTTPError, socket.error, socket.timeout):
-                    if count >= 10:
-                        raise
-                    logger.info('Throttling API requests...')
-                    time.sleep(2 ** count * 0.5)
-                    count += 1
-        return wrapped
-
-    @retry
-    def patch_namespaced_endpoints(self, *args, **kwargs):
-        return super(CoreV1Api, self).patch_namespaced_endpoints(*args, **kwargs)
-
-
-def patch_master_endpoint(api, namespace, cluster):
-    addresses = [k8s_client.V1EndpointAddress(ip=os.environ['POD_IP'])]
-    ports = [k8s_client.V1EndpointPort(port=5432)]
-    subsets = [k8s_client.V1EndpointSubset(addresses=addresses, ports=ports)]
-    body = k8s_client.V1Endpoints(subsets=subsets)
-    return api.patch_namespaced_endpoints(cluster, namespace, body)
-
-
-def main():
-    logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', level=logging.INFO)
-    if len(sys.argv) != 4 or sys.argv[1] not in ('on_start', 'on_stop', 'on_role_change'):
-        sys.exit('Usage: %s <action> <role> <cluster_name>', sys.argv[0])
-
-    action, role, cluster = sys.argv[1:4]
-
-    k8s_config.load_incluster_config()
-    k8s_api = CoreV1Api()
-
-    namespace = os.environ['KUBERNETES_NAMESPACE']
-
-    if role == 'master' and action in ('on_start', 'on_role_change'):
-        patch_master_endpoint(k8s_api, namespace, cluster)
-
-
-if __name__ == '__main__':
-    main()
@@ -1,5 +1,12 @@
 #!/bin/bash

+if [[ $UID -ge 10000 ]]; then
+    GID=$(id -g)
+    sed -e "s/^postgres:x:[^:]*:[^:]*:/postgres:x:$UID:$GID:/" /etc/passwd > /tmp/passwd
+    cat /tmp/passwd > /etc/passwd
+    rm /tmp/passwd
+fi
+
 cat > /home/postgres/patroni.yml <<__EOF__
 bootstrap:
  dcs:
@@ -13,24 +20,20 @@ bootstrap:
  - data-checksums
  pg_hba:
  - host all all 0.0.0.0/0 md5
-  - host replication ${PATRONI_REPLICATION_USERNAME} ${POD_IP}/16    md5
+  - host replication ${PATRONI_REPLICATION_USERNAME} ${PATRONI_KUBERNETES_POD_IP}/16 md5
 restapi:
-  connect_address: '${POD_IP}:8008'
+  connect_address: '${PATRONI_KUBERNETES_POD_IP}:8008'
 postgresql:
-  connect_address: '${POD_IP}:5432'
+  connect_address: '${PATRONI_KUBERNETES_POD_IP}:5432'
  authentication:
    superuser:
      password: '${PATRONI_SUPERUSER_PASSWORD}'
    replication:
      password: '${PATRONI_REPLICATION_PASSWORD}'
-  callbacks:
-    on_start: /callback.py
-    on_stop: /callback.py
-    on_role_change: /callback.py
 __EOF__

 unset PATRONI_SUPERUSER_PASSWORD PATRONI_REPLICATION_PASSWORD
 export KUBERNETES_NAMESPACE=$PATRONI_KUBERNETES_NAMESPACE
 export POD_NAME=$PATRONI_NAME

-exec /usr/bin/python /usr/local/bin/patroni /home/postgres/patroni.yml
+exec /usr/bin/python3 /usr/local/bin/patroni /home/postgres/patroni.yml
@@ -0,0 +1,49 @@
+# Patroni OpenShift Configuration
+Patroni can be run in OpenShift. Based on the kubernetes configuration, the Dockerfile and Entrypoint has been modified to support the dynamic UID/GID configuration that is applied in OpenShift. This can be run under the standard `restricted` SCC. 
+
+# Examples
+
+## Create test project
+
+```
+oc new-project patroni-test
+```
+
+## Build the image
+
+Note: Update the references when merged upstream. 
+Note: If deploying as a template for multiple users, the following commands should be performed in a shared namespace like `openshift`. 
+
+```
+oc import-image postgres:10 --confirm -n openshift
+oc new-build https://github.com/zalando/patroni --context-dir=kubernetes -n openshift
+```
+
+## Deploy the Image 
+Two configuration templates exist in [templates](templates) directory: 
+- Patroni Ephemeral
+- Patroni Persistent
+
+The only difference is whether or not the statefulset requests persistent storage. 
+
+## Create the Template
+Install the template into the `openshift` namespace if this should be shared across projects: 
+
+```
+oc create -f templates/template_patroni_ephemeral.yml -n openshift
+```
+
+Then, from your own project: 
+
+```
+oc new-app patroni-pgsql-ephemeral
+```
+
+Once the pods are running, two configmaps should be available: 
+
+```
+$ oc get configmap
+NAME                DATA      AGE
+patroniocp-config   0         1m
+patroniocp-leader   0         1m
+```
@@ -0,0 +1,287 @@
+apiVersion: v1
+kind: Template
+metadata:
+  name: patroni-pgsql-ephemeral
+  annotations:
+    description: |-
+      Patroni Postgresql database cluster, without persistent storage.
+
+      WARNING: Any data stored will be lost upon pod destruction. Only use this template for testing.
+    iconClass: icon-postgresql
+    openshift.io/display-name: Patroni Postgresql (Ephemeral)
+    openshift.io/long-description: This template deploys a a patroni postgresql HA cluster without persistent storage.
+    tags: postgresql
+objects:
+- apiVersion: v1
+  kind: Service
+  metadata:
+    creationTimestamp: null
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${PATRONI_CLUSTER_NAME}
+  spec:
+    ports:
+    - port: 5432
+      protocol: TCP
+      targetPort: 5432
+    sessionAffinity: None
+    type: ClusterIP
+  status:
+    loadBalancer: {}
+- apiVersion: v1
+  kind: Service
+  metadata:
+    creationTimestamp: null
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${PATRONI_MASTER_SERVICE_NAME}
+  spec:
+    ports:
+    - port: 5432
+      protocol: TCP
+      targetPort: 5432
+    selector:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+      role: master
+    sessionAffinity: None
+    type: ClusterIP
+  status:
+    loadBalancer: {}
+- apiVersion: v1
+  kind: Secret
+  metadata:
+    name: ${PATRONI_CLUSTER_NAME}
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+  stringData:
+    superuser-password: ${PATRONI_SUPERUSER_PASSWORD}
+    replication-password: ${PATRONI_REPLICATION_PASSWORD}
+- apiVersion: v1
+  kind: Service
+  metadata:
+    creationTimestamp: null
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${PATRONI_REPLICA_SERVICE_NAME}
+  spec:
+    ports:
+    - port: 5432
+      protocol: TCP
+      targetPort: 5432
+    selector:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+      role: replica
+    sessionAffinity: None
+    type: ClusterIP
+  status:
+    loadBalancer: {}
+- apiVersion: apps/v1
+  kind: StatefulSet
+  metadata:
+    creationTimestamp: null
+    generation: 3
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${APPLICATION_NAME}
+  spec:
+    podManagementPolicy: OrderedReady
+    replicas: 3
+    revisionHistoryLimit: 10
+    selector:
+      matchLabels:
+        application: ${APPLICATION_NAME}
+        cluster-name: ${PATRONI_CLUSTER_NAME}
+    serviceName: ${APPLICATION_NAME}
+    template:
+      metadata:
+        creationTimestamp: null
+        labels:
+          application: ${APPLICATION_NAME}
+          cluster-name: ${PATRONI_CLUSTER_NAME}
+      spec:
+        containers:
+        - env:
+          - name: PATRONI_KUBERNETES_POD_IP
+            valueFrom:
+              fieldRef:
+                apiVersion: v1
+                fieldPath: status.podIP
+          - name: PATRONI_KUBERNETES_NAMESPACE
+            valueFrom:
+              fieldRef:
+                apiVersion: v1
+                fieldPath: metadata.namespace
+          - name: PATRONI_KUBERNETES_LABELS
+            value: '{application: ${APPLICATION_NAME}, cluster-name: ${PATRONI_CLUSTER_NAME}}'
+          - name: PATRONI_SUPERUSER_USERNAME
+            value: ${PATRONI_SUPERUSER_USERNAME}
+          - name: PATRONI_SUPERUSER_PASSWORD
+            valueFrom:
+              secretKeyRef:
+                key: superuser-password
+                name: ${PATRONI_CLUSTER_NAME}
+          - name: PATRONI_REPLICATION_USERNAME
+            value: ${PATRONI_REPLICATION_USERNAME}
+          - name: PATRONI_REPLICATION_PASSWORD
+            valueFrom:
+              secretKeyRef:
+                key: replication-password
+                name: ${PATRONI_CLUSTER_NAME}
+          - name: PATRONI_SCOPE
+            value: ${PATRONI_CLUSTER_NAME}
+          - name: PATRONI_NAME
+            valueFrom:
+              fieldRef:
+                apiVersion: v1
+                fieldPath: metadata.name
+          - name: PATRONI_POSTGRESQL_DATA_DIR
+            value: /home/postgres/pgdata/pgroot/data
+          - name: PATRONI_POSTGRESQL_PGPASS
+            value: /tmp/pgpass
+          - name: PATRONI_POSTGRESQL_LISTEN
+            value: 0.0.0.0:5432
+          - name: PATRONI_RESTAPI_LISTEN
+            value: 0.0.0.0:8008
+          image: docker-registry.default.svc:5000/${NAMESPACE}/patroni:latest
+          imagePullPolicy: IfNotPresent
+          name: ${APPLICATION_NAME}
+          ports:
+          - containerPort: 8008
+            protocol: TCP
+          - containerPort: 5432
+            protocol: TCP
+          resources: {}
+          terminationMessagePath: /dev/termination-log
+          terminationMessagePolicy: File
+          volumeMounts:
+          - mountPath: /home/postgres/pgdata
+            name: pgdata
+        dnsPolicy: ClusterFirst
+        restartPolicy: Always
+        schedulerName: default-scheduler
+        securityContext: {}
+        serviceAccount: ${SERVICE_ACCOUNT}
+        serviceAccountName: ${SERVICE_ACCOUNT}
+        terminationGracePeriodSeconds: 0
+        volumes:
+        - name: pgdata
+          emptyDir: {}
+    updateStrategy:
+      type: OnDelete
+- apiVersion: v1
+  kind: Endpoints
+  metadata:
+    name: ${APPLICATION_NAME}
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+  subsets: []
+- apiVersion: v1
+  kind: ServiceAccount
+  metadata:
+    name: ${SERVICE_ACCOUNT}
+- apiVersion: rbac.authorization.k8s.io/v1
+  kind: Role
+  metadata:
+    name: ${SERVICE_ACCOUNT}
+  rules:
+  - apiGroups:
+    - ""
+    resources:
+    - configmaps
+    verbs:
+    - create
+    - get
+    - list
+    - patch
+    - update
+    - watch
+    # delete is required only for 'patronictl remove'
+    - delete
+  - apiGroups:
+    - ""
+    resources:
+    - endpoints
+    verbs:
+    - get
+    - patch
+    - update
+    # the following three privileges are necessary only when using endpoints
+    - create
+    - list
+    - watch
+    # delete is required only for for 'patronictl remove'
+    - delete
+  - apiGroups:
+    - ""
+    resources:
+    - pods
+    verbs:
+    - get
+    - list
+    - patch
+    - update
+    - watch
+- apiVersion: rbac.authorization.k8s.io/v1
+  kind: RoleBinding
+  metadata:
+    name: ${SERVICE_ACCOUNT}
+  roleRef:
+    apiGroup: rbac.authorization.k8s.io
+    kind: Role
+    name: ${SERVICE_ACCOUNT}
+  subjects:
+  - kind: ServiceAccount
+    name: ${SERVICE_ACCOUNT}
+parameters:
+- description: The name of the application for labelling all artifacts.
+  displayName: Application Name
+  name: APPLICATION_NAME
+  value: patroni-ephemeral
+- description: The name of the patroni-pgsql cluster.
+  displayName: Cluster Name
+  name: PATRONI_CLUSTER_NAME
+  value: patroni-ephemeral
+- description: The name of the OpenShift Service exposed for the patroni-ephemeral-master container.
+  displayName: Master service name.  
+  name: PATRONI_MASTER_SERVICE_NAME
+  value: patroni-ephemeral-master
+- description: The name of the OpenShift Service exposed for the patroni-ephemeral-replica containers.
+  displayName: Replica service name. 
+  name: PATRONI_REPLICA_SERVICE_NAME
+  value: patroni-ephemeral-replica
+- description: Maximum amount of memory the container can use.
+  displayName: Memory Limit
+  name: MEMORY_LIMIT
+  value: 512Mi
+- description: The OpenShift Namespace where the patroni and postgresql ImageStream resides.
+  displayName: ImageStream Namespace
+  name: NAMESPACE
+  value: openshift
+- description: Username of the superuser account for initialization.
+  displayName: Superuser Username
+  name: PATRONI_SUPERUSER_USERNAME
+  value: postgres
+- description: Password of the superuser account for initialization.
+  displayName: Superuser Passsword
+  name: PATRONI_SUPERUSER_PASSWORD
+  value: postgres
+- description: Username of the replication account for initialization.
+  displayName: Replication Username
+  name: PATRONI_REPLICATION_USERNAME
+  value: postgres
+- description: Password of the replication account for initialization.
+  displayName: Repication Passsword
+  name: PATRONI_REPLICATION_PASSWORD
+  value: postgres
+- description: Service account name used for pods and rolebindings to form a cluster in the project. 
+  displayName: Service Account
+  name: SERVICE_ACCOUNT
+  value: patroniocp
@@ -0,0 +1,303 @@
+apiVersion: v1
+kind: Template
+metadata:
+  name: patroni-pgsql-persistent
+  annotations:
+    description: |-
+      Patroni Postgresql database cluster, with persistent storage.
+
+      WARNING: Any data stored will be lost upon pod destruction. Only use this template for testing.
+    iconClass: icon-postgresql
+    openshift.io/display-name: Patroni Postgresql (Persistent)
+    openshift.io/long-description: This template deploys a a patroni postgresql HA cluster without persistent storage.
+    tags: postgresql
+objects:
+- apiVersion: v1
+  kind: Service
+  metadata:
+    creationTimestamp: null
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${PATRONI_CLUSTER_NAME}
+  spec:
+    ports:
+    - port: 5432
+      protocol: TCP
+      targetPort: 5432
+    sessionAffinity: None
+    type: ClusterIP
+  status:
+    loadBalancer: {}
+- apiVersion: v1
+  kind: Service
+  metadata:
+    creationTimestamp: null
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${PATRONI_MASTER_SERVICE_NAME}
+  spec:
+    ports:
+    - port: 5432
+      protocol: TCP
+      targetPort: 5432
+    selector:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+      role: master
+    sessionAffinity: None
+    type: ClusterIP
+  status:
+    loadBalancer: {}
+- apiVersion: v1
+  kind: Secret
+  metadata:
+    name: ${PATRONI_CLUSTER_NAME}
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+  stringData:
+    superuser-password: ${PATRONI_SUPERUSER_PASSWORD}
+    replication-password: ${PATRONI_REPLICATION_PASSWORD}
+- apiVersion: v1
+  kind: Service
+  metadata:
+    creationTimestamp: null
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${PATRONI_REPLICA_SERVICE_NAME}
+  spec:
+    ports:
+    - port: 5432
+      protocol: TCP
+      targetPort: 5432
+    selector:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+      role: replica
+    sessionAffinity: None
+    type: ClusterIP
+  status:
+    loadBalancer: {}
+- apiVersion: apps/v1
+  kind: StatefulSet
+  metadata:
+    creationTimestamp: null
+    generation: 3
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+    name: ${APPLICATION_NAME}
+  spec:
+    podManagementPolicy: OrderedReady
+    replicas: 3
+    revisionHistoryLimit: 10
+    selector:
+      matchLabels:
+        application: ${APPLICATION_NAME}
+        cluster-name: ${PATRONI_CLUSTER_NAME}
+    serviceName: ${APPLICATION_NAME}
+    template:
+      metadata:
+        creationTimestamp: null
+        labels:
+          application: ${APPLICATION_NAME}
+          cluster-name: ${PATRONI_CLUSTER_NAME}
+      spec:
+        containers:
+        - env:
+          - name: PATRONI_KUBERNETES_POD_IP
+            valueFrom:
+              fieldRef:
+                apiVersion: v1
+                fieldPath: status.podIP
+          - name: PATRONI_KUBERNETES_NAMESPACE
+            valueFrom:
+              fieldRef:
+                apiVersion: v1
+                fieldPath: metadata.namespace
+          - name: PATRONI_KUBERNETES_LABELS
+            value: '{application: ${APPLICATION_NAME}, cluster-name: ${PATRONI_CLUSTER_NAME}}'
+          - name: PATRONI_SUPERUSER_USERNAME
+            value: ${PATRONI_SUPERUSER_USERNAME}
+          - name: PATRONI_SUPERUSER_PASSWORD
+            valueFrom:
+              secretKeyRef:
+                key: superuser-password
+                name: ${PATRONI_CLUSTER_NAME}
+          - name: PATRONI_REPLICATION_USERNAME
+            value: ${PATRONI_REPLICATION_USERNAME}
+          - name: PATRONI_REPLICATION_PASSWORD
+            valueFrom:
+              secretKeyRef:
+                key: replication-password
+                name: ${PATRONI_CLUSTER_NAME}
+          - name: PATRONI_SCOPE
+            value: ${PATRONI_CLUSTER_NAME}
+          - name: PATRONI_NAME
+            valueFrom:
+              fieldRef:
+                apiVersion: v1
+                fieldPath: metadata.name
+          - name: PATRONI_POSTGRESQL_DATA_DIR
+            value: /home/postgres/pgdata/pgroot/data
+          - name: PATRONI_POSTGRESQL_PGPASS
+            value: /tmp/pgpass
+          - name: PATRONI_POSTGRESQL_LISTEN
+            value: 0.0.0.0:5432
+          - name: PATRONI_RESTAPI_LISTEN
+            value: 0.0.0.0:8008
+          image: docker-registry.default.svc:5000/${NAMESPACE}/patroni:latest
+          imagePullPolicy: IfNotPresent
+          name: ${APPLICATION_NAME}
+          ports:
+          - containerPort: 8008
+            protocol: TCP
+          - containerPort: 5432
+            protocol: TCP
+          resources: {}
+          terminationMessagePath: /dev/termination-log
+          terminationMessagePolicy: File
+          volumeMounts:
+          - mountPath: /home/postgres/pgdata
+            name: ${APPLICATION_NAME}
+        dnsPolicy: ClusterFirst
+        restartPolicy: Always
+        schedulerName: default-scheduler
+        securityContext: {}
+        serviceAccount: ${SERVICE_ACCOUNT}
+        serviceAccountName: ${SERVICE_ACCOUNT}
+        terminationGracePeriodSeconds: 0
+        volumes:
+        - name: ${APPLICATION_NAME}
+          persistentVolumeClaim: 
+            claimName: ${APPLICATION_NAME}
+    volumeClaimTemplates:
+    - metadata:
+        labels:
+          application: ${APPLICATION_NAME}
+        name: ${APPLICATION_NAME}
+      spec:
+        accessModes:
+        - ReadWriteOnce
+        resources:
+          requests:
+            storage: ${PVC_SIZE}
+    updateStrategy:
+      type: OnDelete
+- apiVersion: v1
+  kind: Endpoints
+  metadata:
+    name: ${APPLICATION_NAME}
+    labels:
+      application: ${APPLICATION_NAME}
+      cluster-name: ${PATRONI_CLUSTER_NAME}
+  subsets: []
+- apiVersion: v1
+  kind: ServiceAccount
+  metadata:
+    name: ${SERVICE_ACCOUNT}
+- apiVersion: rbac.authorization.k8s.io/v1
+  kind: Role
+  metadata:
+    name: ${SERVICE_ACCOUNT}
+  rules:
+  - apiGroups:
+    - ""
+    resources:
+    - configmaps
+    verbs:
+    - create
+    - get
+    - list
+    - patch
+    - update
+    - watch
+    # delete is required only for 'patronictl remove'
+    - delete
+  - apiGroups:
+    - ""
+    resources:
+    - endpoints
+    verbs:
+    - get
+    - patch
+    - update
+    # the following three privileges are necessary only when using endpoints
+    - create
+    - list
+    - watch
+    # delete is required only for for 'patronictl remove'
+    - delete
+  - apiGroups:
+    - ""
+    resources:
+    - pods
+    verbs:
+    - get
+    - list
+    - patch
+    - update
+    - watch
+- apiVersion: rbac.authorization.k8s.io/v1
+  kind: RoleBinding
+  metadata:
+    name: ${SERVICE_ACCOUNT}
+  roleRef:
+    apiGroup: rbac.authorization.k8s.io
+    kind: Role
+    name: ${SERVICE_ACCOUNT}
+  subjects:
+  - kind: ServiceAccount
+    name: ${SERVICE_ACCOUNT}
+parameters:
+- description: The name of the application for labelling all artifacts.
+  displayName: Application Name
+  name: APPLICATION_NAME
+  value: patroni-persistent
+- description: The name of the patroni-pgsql cluster.
+  displayName: Cluster Name
+  name: PATRONI_CLUSTER_NAME
+  value: patroni-persistent
+- description: The name of the OpenShift Service exposed for the patroni-persistent-master container.
+  displayName: Master service name.  
+  name: PATRONI_MASTER_SERVICE_NAME
+  value: patroni-persistent-master
+- description: The name of the OpenShift Service exposed for the patroni-persistent-replica containers.
+  displayName: Replica service name. 
+  name: PATRONI_REPLICA_SERVICE_NAME
+  value: patroni-persistent-replica
+- description: Maximum amount of memory the container can use.
+  displayName: Memory Limit
+  name: MEMORY_LIMIT
+  value: 512Mi
+- description: The OpenShift Namespace where the patroni and postgresql ImageStream resides.
+  displayName: ImageStream Namespace
+  name: NAMESPACE
+  value: openshift
+- description: Username of the superuser account for initialization.
+  displayName: Superuser Username
+  name: PATRONI_SUPERUSER_USERNAME
+  value: postgres
+- description: Password of the superuser account for initialization.
+  displayName: Superuser Passsword
+  name: PATRONI_SUPERUSER_PASSWORD
+  value: postgres
+- description: Username of the replication account for initialization.
+  displayName: Replication Username
+  name: PATRONI_REPLICATION_USERNAME
+  value: postgres
+- description: Password of the replication account for initialization.
+  displayName: Repication Passsword
+  name: PATRONI_REPLICATION_PASSWORD
+  value: postgres
+- description: Service account name used for pods and rolebindings to form a cluster in the project. 
+  displayName: Service Account
+  name: SERVICE_ACCOUNT
+  value: patroni-persistent
+- description: The size of the persistent volume to create. 
+  displayName: Persistent Volume Size
+  name: PVC_SIZE
+  value: 5Gi
@@ -0,0 +1,43 @@
+pipeline {
+  agent any
+  stages {
+    stage ('Deploy test pod'){
+      when {
+          expression {
+            openshift.withCluster() {
+              openshift.withProject() {
+                return !openshift.selector( "dc", "pgbench" ).exists()
+              }
+            }
+          }
+        }
+      steps {
+        script {
+            openshift.withCluster() {
+                openshift.withProject() {
+                  def pgbench = openshift.newApp( "https://github.com/stewartshea/docker-pgbench/", "--name=pgbench", "-e PGPASSWORD=postgres", "-e PGUSER=postgres", "-e PGHOST=patroni-persistent-master", "-e PGDATABASE=postgres", "-e TEST_CLIENT_COUNT=20", "-e TEST_DURATION=120" )
+                  def pgbenchdc = openshift.selector( "dc", "pgbench" )
+                  timeout(5) { 
+                    pgbenchdc.rollout().status()
+                    }
+                  }
+                }
+            }
+        }
+    }
+    stage ('Run benchmark Test'){
+      steps {
+          sh '''
+          oc exec $(oc get pods -l app=pgbench | grep Running | awk '{print $1}')  ./test.sh
+          '''
+      }
+    }
+    stage ('Clean up pgtest pod'){
+      steps {
+          sh '''
+          oc delete all -l app=pgbench
+          '''
+      }
+    }
+  }
+}
@@ -0,0 +1,2 @@
+# Jenkins Test
+This pipeline test will create a separate deployment config for a pgbench pod and execute a test against the patroni cluster. This is a sample and should be customized. 
@@ -1,3 +1,15 @@
+# headless service to avoid deletion of patronidemo-config endpoint
+apiVersion: v1
+kind: Service
+metadata:
+  name: patronidemo-config
+  labels:
+    application: patroni
+    cluster-name: patronidemo
+spec:
+  clusterIP: None
+
+---
 apiVersion: apps/v1beta1
 kind: StatefulSet
 metadata:
@@ -28,7 +40,7 @@ spec:
        - mountPath: /home/postgres/pgdata
          name: pgdata
        env:
-        - name: POD_IP
+        - name: PATRONI_KUBERNETES_POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
@@ -36,6 +48,8 @@ spec:
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
+        - name: PATRONI_KUBERNETES_USE_ENDPOINTS
+          value: 'true'
        - name: PATRONI_KUBERNETES_LABELS
          value: '{application: patroni, cluster-name: patronidemo}'
        - name: PATRONI_SUPERUSER_USERNAME
@@ -145,8 +159,9 @@ rules:
  - patch
  - update
  - watch
-  # delete is required only for 'patronictl remove'
+  # delete and deletecollection are required only for 'patronictl remove'
  - delete
+  - deletecollection
 - apiGroups:
  - ""
  resources:
@@ -159,8 +174,9 @@ rules:
  - create
  - list
  - watch
-  # delete is required only for for 'patronictl remove'
+  # delete and deletecollection are required only for for 'patronictl remove'
  - delete
+  - deletecollection
 - apiGroups:
  - ""
  resources:
@@ -171,6 +187,16 @@ rules:
  - patch
  - update
  - watch
+# The following privilege is only necessary for creation of headless service
+# for patronidemo-config endpoint, in order to prevent cleaning it up by the
+# k8s master. You can avoid giving this privilege by explicitly creating the
+# service like it is done in this manifest (lines 2..10)
+- apiGroups:
+  - ""
+  resources:
+  - services
+  verbs:
+  - create

 ---
 apiVersion: rbac.authorization.k8s.io/v1
@@ -14,6 +14,7 @@ class Patroni(object):
        from patroni.config import Config
        from patroni.dcs import get_dcs
        from patroni.ha import Ha
+        from patroni.log import PatroniLogger
        from patroni.postgresql import Postgresql
        from patroni.version import __version__
        from patroni.watchdog import Watchdog
@@ -21,7 +22,9 @@ class Patroni(object):
        self.setup_signal_handlers()

        self.version = __version__
+        self.logger = PatroniLogger()
        self.config = Config()
+        self.logger.reload_config(self.config.get('log', {}))
        self.dcs = get_dcs(self.config)
        self.watchdog = Watchdog(self.config)
        self.load_dynamic_configuration()
@@ -49,6 +52,7 @@ class Patroni(object):
                break
            except DCSError:
                logger.warning('Can not get cluster from dcs')
+                time.sleep(5)

    def get_tags(self):
        return {tag: value for tag, value in self.config.get('tags', {}).items()
@@ -65,6 +69,7 @@ class Patroni(object):
    def reload_config(self):
        try:
            self.tags = self.get_tags()
+            self.logger.reload_config(self.config.get('log', {}))
            self.dcs.reload_config(self.config)
            self.watchdog.reload_config(self.config)
            self.api.reload_config(self.config['restapi'])
@@ -80,9 +85,10 @@ class Patroni(object):
        self._received_sighup = True

    def sigterm_handler(self, *args):
-        if not self._received_sigterm:
-            self._received_sigterm = True
-            sys.exit()
+        with self._sigterm_lock:
+            if not self._received_sigterm:
+                self._received_sigterm = True
+                sys.exit()

    @property
    def noloadbalance(self):
@@ -101,11 +107,16 @@ class Patroni(object):
        elif self.ha.watch(nap_time):
            self.next_run = time.time()

+    @property
+    def received_sigterm(self):
+        with self._sigterm_lock:
+            return self._received_sigterm
+
    def run(self):
        self.api.start()
        self.next_run = time.time()

-        while not self._received_sigterm:
+        while not self.received_sigterm:
            if self._received_sighup:
                self._received_sighup = False
                if self.config.reload_local_configuration():
@@ -123,27 +134,27 @@ class Patroni(object):
            self.schedule_next_run()

    def setup_signal_handlers(self):
+        from threading import Lock
+
        self._received_sighup = False
+        self._sigterm_lock = Lock()
        self._received_sigterm = False
        if os.name != 'nt':
            signal.signal(signal.SIGHUP, self.sighup_handler)
        signal.signal(signal.SIGTERM, self.sigterm_handler)

    def shutdown(self):
+        with self._sigterm_lock:
+            self._received_sigterm = True
        try:
            self.api.shutdown()
        except Exception:
            logger.exception('Exception during RestApi.shutdown')
        self.ha.shutdown()
+        self.logger.shutdown()


 def patroni_main():
-    logformat = os.environ.get('PATRONI_LOGFORMAT', '%(asctime)s %(levelname)s: %(message)s')
-    loglevel = os.environ.get('PATRONI_LOGLEVEL', 'INFO')
-    requests_loglevel = os.environ.get('PATRONI_REQUESTS_LOGLEVEL', 'WARNING')
-    logging.basicConfig(format=logformat, level=loglevel)
-    logging.getLogger('requests').setLevel(requests_loglevel)
-
    patroni = Patroni()
    try:
        patroni.run()
@@ -153,34 +164,38 @@ def patroni_main():
        patroni.shutdown()


-def pg_ctl_start(args):
-    import subprocess
-    if os.name != 'nt':
-        os.setsid()
-    postmaster = subprocess.Popen(args)
-    print(postmaster.pid)
+def fatal(string, *args):
+    sys.stderr.write('FATAL: ' + string.format(*args) + '\n')
+    sys.exit(1)


-def call_self(args, **kwargs):
-    """This function executes Patroni once again with provided arguments.
+def check_psycopg2():
+    min_psycopg2 = (2, 5, 4)
+    min_psycopg2_str = '.'.join(map(str, min_psycopg2))

-    :args: list of arguments to call Patroni with.
-    :returns: `Popen` object"""
+    def parse_version(version):
+        for e in version.split('.'):
+            try:
+                yield int(e)
+            except ValueError:
+                break

-    exe = [sys.executable]
-    if not getattr(sys, 'frozen', False):  # Binary distribution?
-        exe.append(sys.argv[0])
-
-    import subprocess
-    return subprocess.Popen(exe + args, **kwargs)
+    try:
+        import psycopg2
+        version_str = psycopg2.__version__.split(' ')[0]
+        version = tuple(parse_version(version_str))
+        if version < min_psycopg2:
+            fatal('Patroni requires psycopg2>={0}, but only {1} is available', min_psycopg2_str, version_str)
+    except ImportError:
+        fatal('Patroni requires psycopg2>={0} or psycopg2-binary', min_psycopg2_str)


 def main():
+    check_psycopg2()
    if os.getpid() != 1:
-        if len(sys.argv) > 5 and sys.argv[1] == 'pg_ctl_start':
-            return pg_ctl_start(sys.argv[2:])
        return patroni_main()

+    # Patroni started with PID=1, it looks like we are in the container
    pid = 0

    # Looks like we are in a docker, so we will act like init
@@ -199,16 +214,18 @@ def main():
        if pid:
            os.kill(pid, signo)

-    signal.signal(signal.SIGCHLD, sigchld_handler)
    if os.name != 'nt':
+        signal.signal(signal.SIGCHLD, sigchld_handler)
        signal.signal(signal.SIGHUP, passtochild)
        signal.signal(signal.SIGQUIT, passtochild)
+        signal.signal(signal.SIGUSR1, passtochild)
+        signal.signal(signal.SIGUSR2, passtochild)
    signal.signal(signal.SIGINT, passtochild)
-    signal.signal(signal.SIGUSR1, passtochild)
-    signal.signal(signal.SIGUSR2, passtochild)
    signal.signal(signal.SIGABRT, passtochild)
    signal.signal(signal.SIGTERM, passtochild)

-    patroni = call_self(sys.argv[1:])
+    import multiprocessing
+    patroni = multiprocessing.Process(target=patroni_main)
+    patroni.start()
    pid = patroni.pid
-    patroni.wait()
+    patroni.join()
@@ -3,13 +3,16 @@ import json
 import logging
 import psycopg2
 import time
+import traceback
 import dateutil.parser
 import datetime
 import os
+import socket

-from patroni.postgresql import PostgresConnectionException, PostgresException, Postgresql
+from patroni.postgresql import PostgresConnectionException
+from patroni.postgresql.misc import postgres_version_to_int, PostgresException
 from patroni.utils import deep_compare, parse_bool, patch_config, Retry, \
-    RetryFailedError, parse_int, split_host_port, tzutc
+    RetryFailedError, parse_int, split_host_port, tzutc, uri
 from six.moves.BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
 from six.moves.socketserver import ThreadingMixIn
 from threading import Thread
@@ -73,30 +76,44 @@ class RestApiHandler(BaseHTTPRequestHandler):
            response['watchdog_failed'] = True
        if patroni.ha.is_paused():
            response['pause'] = True
+        qsize = patroni.logger.queue_size
+        if qsize > patroni.logger.NORMAL_LOG_QUEUE_SIZE:
+            response['logger_queue_size'] = qsize
+            lost = patroni.logger.records_lost
+            if lost:
+                response['logger_records_lost'] = lost
        self._write_json_response(status_code, response)

    def do_GET(self, write_status_code_only=False):
        """Default method for processing all GET requests which can not be routed to other methods"""

+        time_start = time.time()
+        request_type = 'OPTIONS' if write_status_code_only else 'GET'
+
        path = '/master' if self.path == '/' else self.path
        response = self.get_postgresql_status()

        patroni = self.server.patroni
        cluster = patroni.dcs.cluster

+        if not cluster and patroni.ha.is_paused():
+            primary_status_code = 200 if response['role'] == 'master' else 503
+        else:
+            primary_status_code = 200 if patroni.ha.is_leader() else 503
+
        replica_status_code = 200 if not patroni.noloadbalance and response.get('role') == 'replica' else 503
        status_code = 503

        if patroni.ha.is_standby_cluster() and ('standby_leader' in path or 'standby-leader' in path):
            status_code = 200 if patroni.ha.is_leader() else 503
-        elif 'master' in path or 'leader' in path or 'primary' in path:
-            # Round-robing across all masters in pause mode if DCS is not accessible
-            if not cluster and patroni.ha.is_paused():
-                status_code = 200 if response['role'] == 'master' else 503
-            else:
-                status_code = 200 if patroni.ha.is_leader() else 503
+        elif 'master' in path or 'leader' in path or 'primary' in path or 'read-write' in path:
+            status_code = primary_status_code
        elif 'replica' in path:
            status_code = replica_status_code
+        elif 'read-only' in path:
+            status_code = 200 if primary_status_code == 200 else replica_status_code
+        elif 'health' in path:
+            status_code = 200 if response.get('state') == 'running' else 503
        elif cluster:  # dcs is available
            is_synchronous = cluster.is_synchronous_mode() and cluster.sync \
                    and cluster.sync.sync_standby == patroni.postgresql.name
@@ -111,6 +128,10 @@ class RestApiHandler(BaseHTTPRequestHandler):
        else:
            self._write_status_response(status_code, response)

+        time_end = time.time()
+        self.log_message('%s %s %s latency: %s ms', request_type, path,
+                         status_code, (time_end - time_start) * 1000)
+
    def do_OPTIONS(self):
        self.do_GET(write_status_code_only=True)

@@ -228,7 +249,7 @@ class RestApiHandler(BaseHTTPRequestHandler):
                    break
            elif k == 'postgres_version':
                try:
-                    Postgresql.postgres_version_to_int(request[k])
+                    postgres_version_to_int(request[k])
                except PostgresException as e:
                    status_code = 400
                    data = e.value
@@ -445,6 +466,9 @@ class RestApiHandler(BaseHTTPRequestHandler):
                })
            }

+            if result['role'] == 'replica' and self.server.patroni.ha.is_standby_cluster():
+                result['role'] = self.server.patroni.postgresql.role
+
            if row[1] > 0:
                result['timeline'] = row[1]
            else:
@@ -509,8 +533,34 @@ class RestApiServer(ThreadingMixIn, HTTPServer, Thread):

    def __set_config_parameters(self, config):
        self.__auth_key = base64.b64encode(config['auth'].encode('utf-8')).decode('utf-8') if 'auth' in config else None
-        self.connection_string = '{0}://{1}/patroni'.format(self.__protocol,
-                                                            config.get('connect_address') or self.__listen)
+        self.connection_string = uri(self.__protocol, config.get('connect_address') or self.__listen, 'patroni')
+
+    @staticmethod
+    def __has_dual_stack():
+        if hasattr(socket, 'AF_INET6') and hasattr(socket, 'IPPROTO_IPV6') and hasattr(socket, 'IPV6_V6ONLY'):
+            sock = None
+            try:
+                sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+                sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, False)
+                return True
+            except socket.error as e:
+                logger.debug('Error when working with ipv6 socket: %s', e)
+            finally:
+                if sock:
+                    sock.close()
+        return False
+
+    def __httpserver_init(self, host, port):
+        dual_stack = self.__has_dual_stack()
+        if host == '':
+            host = None
+
+        info = socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
+        # in case dual stack is not supported we want IPv4 to be preferred over IPv6
+        info.sort(key=lambda x: x[0] == socket.AF_INET, reverse=not dual_stack)
+
+        self.address_family = info[0][0]
+        HTTPServer.__init__(self, info[0][-1][:2], RestApiHandler)

    def __initialize(self, config):
        try:
@@ -525,7 +575,7 @@ class RestApiServer(ThreadingMixIn, HTTPServer, Thread):
        self.__listen = config['listen']
        self.__ssl_options = self.__get_ssl_options(config)

-        HTTPServer.__init__(self, (host, port), RestApiHandler)
+        self.__httpserver_init(host, port)
        Thread.__init__(self, target=self.serve_forever)
        self._set_fd_cloexec(self.socket)

@@ -535,7 +585,9 @@ class RestApiServer(ThreadingMixIn, HTTPServer, Thread):
        # Sometime it's also needed to pass reference to a 'keyfile'.
        if self.__ssl_options.get('certfile'):
            import ssl
-            self.socket = ssl.wrap_socket(self.socket, server_side=True, **self.__ssl_options)
+            ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            ctx.load_cert_chain(**self.__ssl_options)
+            self.socket = ctx.wrap_socket(self.socket, server_side=True)
            self.__protocol = 'https'
        return True

@@ -547,3 +599,9 @@ class RestApiServer(ThreadingMixIn, HTTPServer, Thread):
                and self.__initialize(config):
            self.start()
        self.__set_config_parameters(config)
+
+    @staticmethod
+    def handle_error(request, client_address):
+        address, port = client_address
+        logger.warning('Exception happened during processing of request from {}:{}'.format(address, port))
+        logger.warning(traceback.format_exc())
@@ -52,8 +52,8 @@ class CriticalTask(object):

 class AsyncExecutor(object):

-    def __init__(self, state_handler, ha_wakeup):
-        self.state_handler = state_handler
+    def __init__(self, cancellable, ha_wakeup):
+        self._cancellable = cancellable
        self._ha_wakeup = ha_wakeup
        self._thread_lock = RLock()
        self._scheduled_action = None
@@ -92,7 +92,7 @@ class AsyncExecutor(object):
                    return
                self._finish_event.clear()

-            self.state_handler.reset_is_cancelled()
+            self._cancellable.reset_is_cancelled()
            # if the func returned something (not None) - wake up main HA loop
            wakeup = func(*args) if args else func()
            return wakeup
@@ -118,7 +118,7 @@ class AsyncExecutor(object):
                logger.warning('Cancelling long running task %s', self._scheduled_action)
            self._is_cancelled = True

-        self.state_handler.cancel()
+        self._cancellable.cancel()
        self._finish_event.wait()

        with self:
@@ -2,7 +2,6 @@ import json
 import logging
 import os
 import shutil
-import six
 import sys
 import tempfile
 import yaml
@@ -10,7 +9,7 @@ import yaml
 from collections import defaultdict
 from copy import deepcopy
 from patroni.dcs import ClusterConfig
-from patroni.postgresql import Postgresql
+from patroni.postgresql.config import ConfigHandler
 from patroni.utils import deep_compare, parse_bool, parse_int, patch_config
 from requests.structures import CaseInsensitiveDict

@@ -44,6 +43,7 @@ class Config(object):
    __DEFAULT_CONFIG = {
        'ttl': 30, 'loop_wait': 10, 'retry_timeout': 10,
        'maximum_lag_on_failover': 1048576,
+        'check_timeline': False,
        'master_start_timeout': 300,
        'synchronous_mode': False,
        'synchronous_mode_strict': False,
@@ -59,7 +59,7 @@ class Config(object):
        'postgresql': {
            'bin_dir': '',
            'use_slots': True,
-            'parameters': CaseInsensitiveDict({p: v[0] for p, v in Postgresql.CMDLINE_OPTIONS.items()})
+            'parameters': CaseInsensitiveDict({p: v[0] for p, v in ConfigHandler.CMDLINE_OPTIONS.items()})
        },
        'watchdog': {
            'mode': 'automatic',
@@ -178,11 +178,9 @@ class Config(object):

    @staticmethod
    def _process_postgresql_parameters(parameters, is_local=False):
-        ret = {}
-        for name, value in (parameters or {}).items():
-            if name not in Postgresql.CMDLINE_OPTIONS or not is_local and Postgresql.CMDLINE_OPTIONS[name][1](value):
-                ret[name] = value
-        return ret
+        return {name: value for name, value in (parameters or {}).items()
+                if name not in ConfigHandler.CMDLINE_OPTIONS or
+                not is_local and ConfigHandler.CMDLINE_OPTIONS[name][1](value)}

    def _safe_copy_dynamic_configuration(self, dynamic_configuration):
        config = deepcopy(self.__DEFAULT_CONFIG)
@@ -195,12 +193,9 @@ class Config(object):
                    elif name not in ('connect_address', 'listen', 'data_dir', 'pgpass', 'authentication'):
                        config['postgresql'][name] = deepcopy(value)
            elif name == 'standby_cluster':
-                allowed_keys = self.__DEFAULT_CONFIG['standby_cluster'].keys()
-                expected = {
-                    k: v for k, v in (value or {}).items()
-                    if (k in allowed_keys and isinstance(v, six.string_types))
-                }
-                config['standby_cluster'].update(expected)
+                for name, value in (value or {}).items():
+                    if name in self.__DEFAULT_CONFIG['standby_cluster']:
+                        config['standby_cluster'][name] = deepcopy(value)
            elif name in config:  # only variables present in __DEFAULT_CONFIG allowed to be overriden from DCS
                if name in ('synchronous_mode', 'synchronous_mode_strict'):
                    config[name] = value
@@ -220,6 +215,15 @@ class Config(object):
            if value:
                ret[param] = value

+        def _fix_log_env(name, oldname):
+            value = _popenv(oldname)
+            name = Config.PATRONI_ENV_PREFIX + 'LOG_' + name.upper()
+            if value and name not in os.environ:
+                os.environ[name] = value
+
+        for name, oldname in (('level', 'loglevel'), ('format', 'logformat'), ('dateformat', 'log_datefmt')):
+            _fix_log_env(name, oldname)
+
        def _set_section_values(section, params):
            for param in params:
                value = _popenv(section + '_' + param)
@@ -227,7 +231,24 @@ class Config(object):
                    ret[section][param] = value

        _set_section_values('restapi', ['listen', 'connect_address', 'certfile', 'keyfile'])
-        _set_section_values('postgresql', ['listen', 'connect_address', 'data_dir', 'pgpass', 'bin_dir'])
+        _set_section_values('postgresql', ['listen', 'connect_address', 'config_dir', 'data_dir', 'pgpass', 'bin_dir'])
+        _set_section_values('log', ['level', 'format', 'dateformat', 'max_queue_size',
+                                    'dir', 'file_size', 'file_num', 'loggers'])
+
+        def _parse_dict(value):
+            if not value.strip().startswith('{'):
+                value = '{{{0}}}'.format(value)
+            try:
+                return yaml.safe_load(value)
+            except Exception:
+                logger.exception('Exception when parsing dict %s', value)
+                return None
+
+        value = ret.get('log', {}).pop('loggers', None)
+        if value:
+            value = _parse_dict(value)
+            if value:
+                ret['log']['loggers'] = value

        def _get_auth(name):
            ret = {}
@@ -242,7 +263,7 @@ class Config(object):
            ret['restapi']['authentication'] = restapi_auth

        authentication = {}
-        for user_type in ('replication', 'superuser'):
+        for user_type in ('replication', 'superuser', 'rewind'):
            entry = _get_auth(user_type)
            if entry:
                authentication[user_type] = entry
@@ -250,8 +271,6 @@ class Config(object):
        if authentication:
            ret['postgresql']['authentication'] = authentication

-        users = {}
-
        def _parse_list(value):
            if not (value.strip().startswith('-') or '[' in value):
                value = '[{0}]'.format(value)
@@ -263,37 +282,40 @@ class Config(object):

        for param in list(os.environ.keys()):
            if param.startswith(Config.PATRONI_ENV_PREFIX):
+                # PATRONI_(ETCD|CONSUL|ZOOKEEPER|EXHIBITOR|...)_(HOSTS?|PORT|..)
                name, suffix = (param[8:].split('_', 1) + [''])[:2]
-                if name and suffix:
-                    # PATRONI_(ETCD|CONSUL|ZOOKEEPER|EXHIBITOR|...)_(HOSTS?|PORT|..)
-                    if suffix in ('HOST', 'HOSTS', 'PORT', 'SRV', 'URL', 'PROXY', 'CACERT', 'CERT',
-                                  'KEY', 'VERIFY', 'TOKEN', 'CHECKS', 'DC', 'NAMESPACE', 'CONTEXT',
-                                  'USE_ENDPOINTS', 'SCOPE_LABEL', 'ROLE_LABEL', 'POD_IP', 'PORTS', 'LABELS'):
-                        value = os.environ.pop(param)
-                        if suffix == 'PORT':
-                            value = value and parse_int(value)
-                        elif suffix in ('HOSTS', 'PORTS', 'CHECKS'):
-                            value = value and _parse_list(value)
-                        elif suffix == 'LABELS':
-                            if not value.strip().startswith('{'):
-                                value = '{{{0}}}'.format(value)
-                            try:
-                                value = yaml.safe_load(value)
-                            except Exception:
-                                logger.exception('Exception when parsing dict %s', value)
-                                value = None
-                        if value:
-                            ret[name.lower()][suffix.lower()] = value
-                    # PATRONI_<username>_PASSWORD=<password>, PATRONI_<username>_OPTIONS=<option1,option2,...>
-                    # CREATE USER "<username>" WITH <OPTIONS> PASSWORD '<password>'
-                    elif suffix == 'PASSWORD':
-                        password = os.environ.pop(param)
-                        if password:
-                            users[name] = {'password': password}
-                            options = os.environ.pop(param[:-9] + '_OPTIONS', None)
-                            options = options and _parse_list(options)
-                            if options:
-                                users[name]['options'] = options
+                if suffix in ('HOST', 'HOSTS', 'PORT', 'USE_PROXIES', 'PROTOCOL', 'SRV', 'URL', 'PROXY',
+                              'CACERT', 'CERT', 'KEY', 'VERIFY', 'TOKEN', 'CHECKS', 'DC', 'CONSISTENCY',
+                              'REGISTER_SERVICE', 'SERVICE_CHECK_INTERVAL', 'NAMESPACE', 'CONTEXT',
+                              'USE_ENDPOINTS', 'SCOPE_LABEL', 'ROLE_LABEL', 'POD_IP', 'PORTS', 'LABELS') and name:
+                    value = os.environ.pop(param)
+                    if suffix == 'PORT':
+                        value = value and parse_int(value)
+                    elif suffix in ('HOSTS', 'PORTS', 'CHECKS'):
+                        value = value and _parse_list(value)
+                    elif suffix == 'LABELS':
+                        value = _parse_dict(value)
+                    elif suffix in ('USE_PROXIES', 'REGISTER_SERVICE'):
+                        value = parse_bool(value)
+                    if value:
+                        ret[name.lower()][suffix.lower()] = value
+        if 'etcd' in ret:
+            ret['etcd'].update(_get_auth('etcd'))
+
+        users = {}
+        for param in list(os.environ.keys()):
+            if param.startswith(Config.PATRONI_ENV_PREFIX):
+                name, suffix = (param[8:].rsplit('_', 1) + [''])[:2]
+                # PATRONI_<username>_PASSWORD=<password>, PATRONI_<username>_OPTIONS=<option1,option2,...>
+                # CREATE USER "<username>" WITH <OPTIONS> PASSWORD '<password>'
+                if name and suffix == 'PASSWORD':
+                    password = os.environ.pop(param)
+                    if password:
+                        users[name] = {'password': password}
+                        options = os.environ.pop(param[:-9] + '_OPTIONS', None)
+                        options = options and _parse_list(options)
+                        if options:
+                            users[name]['options'] = options
        if users:
            ret['bootstrap']['users'] = users

@@ -340,7 +362,7 @@ class Config(object):
            'scope',
            'retry_timeout',
            'synchronous_mode',
-            'maximum_lag_on_failover'
+            'synchronous_mode_strict',
        )

        pg_config.update({p: config[p] for p in updated_fields if p in config})
@@ -14,7 +14,6 @@ import io
 import json
 import logging
 import os
-import psycopg2
 import random
 import requests
 import subprocess
@@ -26,10 +25,12 @@ import yaml

 from click import ClickException
 from contextlib import contextmanager
+from distutils.spawn import find_executable
 from patroni.config import Config
 from patroni.dcs import get_dcs as _get_dcs
 from patroni.exceptions import PatroniException
 from patroni.postgresql import Postgresql
+from patroni.postgresql.misc import postgres_version_to_int
 from patroni.utils import patch_config, polling_loop
 from patroni.version import __version__
 from prettytable import PrettyTable
@@ -63,12 +64,15 @@ def parse_dcs(dcs):
    elif scheme not in DCS_DEFAULTS:
        raise PatroniCtlException('Unknown dcs scheme: {}'.format(scheme))

-    dcs_info = DCS_DEFAULTS[scheme]
-    return yaml.load(dcs_info['template'].format(host=parsed.hostname or 'localhost', port=port or dcs_info['port']))
+    default = DCS_DEFAULTS[scheme]
+    return yaml.safe_load(default['template'].format(host=parsed.hostname or 'localhost', port=port or default['port']))


 def load_config(path, dcs):
-    logging.debug('Loading configuration from file %s', path)
+    if not (os.path.exists(path) and os.access(path, os.R_OK)):
+        logging.debug('Ignoring configuration file "%s". It does not exists or is not readable.', path)
+    else:
+        logging.debug('Loading configuration from file %s', path)
    config = {}
    old_argv = list(sys.argv)
    try:
@@ -112,7 +116,10 @@ option_insecure = click.option('-k', '--insecure', is_flag=True, help='Allow con
@option_insecure
@click.pass_context
 def ctl(ctx, config_file, dcs, insecure):
-    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=os.environ.get('LOGLEVEL', 'WARNING'))
+    level = 'WARNING'
+    for name in ('LOGLEVEL', 'PATRONI_LOGLEVEL', 'PATRONI_LOG_LEVEL'):
+        level = os.environ.get(name, level)
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=level)
    logging.captureWarnings(True)  # Capture eventual SSL warning
    ctx.obj = load_config(config_file, dcs)
    # backward compatibility for configuration file where ctl section is not define
@@ -180,7 +187,7 @@ def print_output(columns, rows=None, alignment=None, fmt='pretty', header=True,

    if fmt == 'tsv':
        if columns is not None and header:
-            click.echo(delimiter.join(columns) + '\n')
+            click.echo(delimiter.join(columns))

        for r in rows:
            c = [str(c) for c in r]
@@ -246,6 +253,7 @@ def get_cursor(cluster, connect_parameters, role='master', member=None):
    else:
        params.pop('database')

+    import psycopg2
    conn = psycopg2.connect(**params)
    conn.autocommit = True
    cursor = conn.cursor()
@@ -263,7 +271,7 @@ def get_cursor(cluster, connect_parameters, role='master', member=None):
    return None


-def get_members(cluster, cluster_name, member_names, role, force, action):
+def get_members(cluster, cluster_name, member_names, role, force, action, scheduled_at=None):
    candidates = {m.name: m for m in cluster.members}

    if not force or role:
@@ -286,10 +294,18 @@ def get_members(cluster, cluster_name, member_names, role, force, action):
        if member_name not in candidates:
            raise PatroniCtlException('{0} is not a member of cluster'.format(member_name))

-    if not force:
-        confirm = click.confirm('Are you sure you want to {0} members {1}?'.format(action, ', '.join(member_names)))
-        if not confirm:
-            raise PatroniCtlException('Aborted {0}'.format(action))
+    if scheduled_at:
+        if not force:
+            confirm = click.confirm('Are you sure you want to schedule {0} of members {1} at {2}?'
+                                    .format(action, ', '.join(member_names), scheduled_at))
+            if not confirm:
+                raise PatroniCtlException('Aborted scheduled {0}'.format(action))
+    else:
+        if not force:
+            confirm = click.confirm('Are you sure you want to {0} members {1}?'
+                                    .format(action, ', '.join(member_names)))
+            if not confirm:
+                raise PatroniCtlException('Aborted {0}'.format(action))

    return [candidates[n] for n in member_names]

@@ -380,6 +396,7 @@ def query(


 def query_member(cluster, cursor, member, role, command, connect_parameters):
+    import psycopg2
    try:
        if cursor is None:
            cursor = get_cursor(cluster, connect_parameters, role=role, member=member)
@@ -509,7 +526,14 @@ def reload(obj, cluster_name, member_names, force, role):
 def restart(obj, cluster_name, member_names, force, role, p_any, scheduled, version, pending, timeout):
    cluster = get_dcs(obj, cluster_name).get_cluster()

-    members = get_members(cluster, cluster_name, member_names, role, force, 'restart')
+    if scheduled is None and not force:
+        next_hour = (datetime.datetime.now() + datetime.timedelta(hours=1)).strftime('%Y-%m-%dT%H:%M')
+        scheduled = click.prompt('When should the restart take place (e.g. ' + next_hour + ') ',
+                                 type=str, default='now')
+
+    scheduled_at = parse_scheduled(scheduled)
+
+    members = get_members(cluster, cluster_name, member_names, role, force, 'restart', scheduled_at)
    if p_any:
        random.shuffle(members)
        members = members[:1]
@@ -524,16 +548,12 @@ def restart(obj, cluster_name, member_names, force, role, p_any, scheduled, vers

    if version:
        try:
-            Postgresql.postgres_version_to_int(version)
+            postgres_version_to_int(version)
        except PatroniException as e:
            raise PatroniCtlException(e.value)

        content['postgres_version'] = version

-    if scheduled is None and not force:
-        scheduled = click.prompt('When should the restart take place (e.g. 2015-10-01T14:30) ', type=str, default='now')
-
-    scheduled_at = parse_scheduled(scheduled)
    if scheduled_at:
        if cluster.is_paused():
            raise PatroniCtlException("Can't schedule restart in the paused state")
@@ -625,10 +645,12 @@ def _do_failover_or_switchover(obj, action, cluster_name, master, candidate, for
        raise PatroniCtlException('Member {0} does not exist in cluster {1}'.format(candidate, cluster_name))

    scheduled_at_str = None
+    scheduled_at = None

    if action == 'switchover':
        if scheduled is None and not force:
-            scheduled = click.prompt('When should the switchover take place (e.g. 2015-10-01T14:30) ',
+            next_hour = (datetime.datetime.now() + datetime.timedelta(hours=1)).strftime('%Y-%m-%dT%H:%M')
+            scheduled = click.prompt('When should the switchover take place (e.g. ' + next_hour + ' ) ',
                                     type=str, default='now')

        scheduled_at = parse_scheduled(scheduled)
@@ -647,9 +669,14 @@ def _do_failover_or_switchover(obj, action, cluster_name, master, candidate, for

    if not force:
        demote_msg = ', demoting current master ' + master if master else ''
-
-        if not click.confirm('Are you sure you want to {0} cluster {1}{2}?'.format(action, cluster_name, demote_msg)):
-            raise PatroniCtlException('Aborting ' + action)
+        if scheduled_at_str:
+            if not click.confirm('Are you sure you want to schedule {0} of cluster {1} at {2}{3}?'
+                                 .format(action, cluster_name, scheduled_at_str, demote_msg)):
+                raise PatroniCtlException('Aborting scheduled ' + action)
+        else:
+            if not click.confirm('Are you sure you want to {0} cluster {1}{2}?'
+                                 .format(action, cluster_name, demote_msg)):
+                raise PatroniCtlException('Aborting ' + action)

    r = None
    try:
@@ -716,6 +743,10 @@ def output_members(cluster, name, extended=False, fmt='pretty'):
    has_scheduled_restarts = any(m.data.get('scheduled_restart') for m in cluster.members)
    has_pending_restarts = any(m.data.get('pending_restart') for m in cluster.members)

+    # Show Host as 'host:port' if somebody is running on non-standard port or two nodes are running on the same host
+    append_port = any(str(m.conn_kwargs()['port']) != '5432' for m in cluster.members) or\
+        len(set(m.conn_kwargs()['host'] for m in cluster.members)) < len(cluster.members)
+
    for m in cluster.members:
        logging.debug(m)

@@ -732,7 +763,11 @@ def output_members(cluster, name, extended=False, fmt='pretty'):
        elif xlog_location_cluster >= xlog_location:
            lag = round((xlog_location_cluster - xlog_location)/1024/1024)

-        row = [name, m.name, m.conn_kwargs()['host'], role, m.data.get('state', ''), lag]
+        host = m.conn_kwargs()['host']
+        if append_port:
+            host += ':{0}'.format(m.conn_kwargs()['port'])
+
+        row = [name, m.name, host, role, m.data.get('state', ''), m.data.get('timeline', ''), lag]

        if extended or has_pending_restarts:
            row.append('*' if m.data.get('pending_restart') else '')
@@ -749,8 +784,8 @@ def output_members(cluster, name, extended=False, fmt='pretty'):

        rows.append(row)

-    columns = ['Cluster', 'Member', 'Host', 'Role', 'State', 'Lag in MB']
-    alignment = {'Lag in MB': 'r'}
+    columns = ['Cluster', 'Member', 'Host', 'Role', 'State', 'TL', 'Lag in MB']
+    alignment = {'Lag in MB': 'r', 'TL': 'r'}

    if extended or has_pending_restarts:
        columns.append('Pending restart')
@@ -1077,9 +1112,16 @@ def invoke_editor(before_editing, cluster_name):
    :param before_editing: human representation before editing
    :returns tuple of human readable and parsed datastructure after changes
    """
+
    editor_cmd = os.environ.get('EDITOR')
    if not editor_cmd:
-        raise PatroniCtlException('EDITOR environment variable is not set')
+        for editor in ('editor', 'vi'):
+            editor_cmd = find_executable(editor)
+            if editor_cmd:
+                logging.debug('Setting fallback editor_cmd=%s', editor)
+                break
+    if not editor_cmd:
+        raise PatroniCtlException('EDITOR environment variable is not set. editor or vi are not available')

    with temporary_file(contents=before_editing.encode('utf-8'),
                        suffix='.yaml',
@@ -9,11 +9,12 @@ import pkgutil
 import re
 import six
 import sys
+import time

 from collections import defaultdict, namedtuple
 from copy import deepcopy
 from patroni.exceptions import PatroniException
-from patroni.utils import parse_bool
+from patroni.utils import parse_bool, uri
 from random import randint
 from six.moves.urllib_parse import urlparse, urlunparse, parse_qsl
 from threading import Event, Lock
@@ -133,10 +134,7 @@ class Member(namedtuple('Member', 'index,name,session,data')):
            return conn_url

        if conn_kwargs:
-            conn_url = 'postgresql://{host}:{port}'.format(
-                host=conn_kwargs.get('host'),
-                port=conn_kwargs.get('port'),
-            )
+            conn_url = uri('postgresql', (conn_kwargs.get('host'), conn_kwargs.get('port', 5432)))
            self.data['conn_url'] = conn_url
            return conn_url

@@ -238,6 +236,20 @@ class Leader(namedtuple('Leader', 'index,session,member')):
    def timeline(self):
        return self.member.data.get('timeline')

+    @property
+    def checkpoint_after_promote(self):
+        """
+        >>> Leader(1, '', Member.from_node(1, '', '', '{"version":"z"}')).checkpoint_after_promote
+        """
+        version = self.member.data.get('version')
+        if version:
+            try:
+                # 1.5.6 is the last version which doesn't expose checkpoint_after_promote: false
+                if tuple(map(int, version.split('.'))) > (1, 5, 6):
+                    return self.member.data['role'] == 'master' and 'checkpoint_after_promote' not in self.member.data
+            except Exception:
+                logger.debug('Failed to parse Patroni version %s', version)
+

 class Failover(namedtuple('Failover', 'index,leader,candidate,scheduled_at')):

@@ -368,7 +380,7 @@ class SyncState(namedtuple('SyncState', 'index,leader,sync_standby')):
        return name is not None and name in (self.leader, self.sync_standby)


-class TimelineHistory(namedtuple('TimelineHistory', 'index,lines')):
+class TimelineHistory(namedtuple('TimelineHistory', 'index,value,lines')):
    """Object representing timeline history file"""

    @staticmethod
@@ -384,7 +396,7 @@ class TimelineHistory(namedtuple('TimelineHistory', 'index,lines')):
            lines = None
        if not isinstance(lines, list):
            lines = []
-        return TimelineHistory(index, lines)
+        return TimelineHistory(index, value, lines)


 class Cluster(namedtuple('Cluster', 'initialize,config,leader,last_leader_operation,members,failover,sync,history')):
@@ -484,6 +496,26 @@ class Cluster(namedtuple('Cluster', 'initialize,config,leader,last_leader_operat
        slots = self.get_replication_slots(name, 'master').values()
        return any(v for v in slots if v.get("type") == "logical")

+    @property
+    def timeline(self):
+        """
+        >>> Cluster(0, 0, 0, 0, 0, 0, 0, 0).timeline
+        0
+        >>> Cluster(0, 0, 0, 0, 0, 0, 0, TimelineHistory.from_node(1, '[]')).timeline
+        1
+        >>> Cluster(0, 0, 0, 0, 0, 0, 0, TimelineHistory.from_node(1, '[["a"]]')).timeline
+        0
+        """
+        if self.history:
+            if self.history.lines:
+                try:
+                    return int(self.history.lines[-1][0]) + 1
+                except Exception:
+                    logger.error('Failed to parse cluster history from DCS: %s', self.history.lines)
+            elif self.history.value == '[]':
+                return 1
+        return 0
+

@six.add_metaclass(abc.ABCMeta)
 class AbstractDCS(object):
@@ -509,6 +541,7 @@ class AbstractDCS(object):

        self._ctl = bool(config.get('patronictl', False))
        self._cluster = None
+        self._cluster_valid_till = 0
        self._cluster_thread_lock = Lock()
        self._last_leader_operation = ''
        self.event = Event()
@@ -556,6 +589,10 @@ class AbstractDCS(object):
    def set_ttl(self, ttl):
        """Set the new ttl value for leader key"""

+    @abc.abstractmethod
+    def ttl(self):
+        """Get new ttl value"""
+
    @abc.abstractmethod
    def set_retry_timeout(self, retry_timeout):
        """Set the new value for retry_timeout"""
@@ -583,22 +620,26 @@ class AbstractDCS(object):
           instance would be demoted."""

    def get_cluster(self):
+        try:
+            cluster = self._load_cluster()
+        except Exception:
+            self.reset_cluster()
+            raise
+
        with self._cluster_thread_lock:
-            try:
-                self._load_cluster()
-            except Exception:
-                self._cluster = None
-                raise
-            return self._cluster
+            self._cluster = cluster
+            self._cluster_valid_till = time.time() + self.ttl
+            return cluster

    @property
    def cluster(self):
        with self._cluster_thread_lock:
-            return self._cluster
+            return self._cluster if self._cluster_valid_till > time.time() else None

    def reset_cluster(self):
        with self._cluster_thread_lock:
            self._cluster = None
+            self._cluster_valid_till = 0

    @abc.abstractmethod
    def _write_leader_optime(self, last_operation):
@@ -664,7 +705,7 @@ class AbstractDCS(object):
        """Create or update `/config` key"""

    @abc.abstractmethod
-    def touch_member(self, data, ttl=None, permanent=False):
+    def touch_member(self, data, permanent=False):
        """Update member key in DCS.
        This method should create or update key with the name = '/members/' + `~self._name`
        and value = data in a given DCS.
@@ -11,7 +11,7 @@ import urllib3
 from consul import ConsulException, NotFound, base
 from patroni.dcs import AbstractDCS, ClusterConfig, Cluster, Failover, Leader, Member, SyncState, TimelineHistory
 from patroni.exceptions import DCSError
-from patroni.utils import deep_compare, parse_bool, Retry, RetryFailedError, split_host_port
+from patroni.utils import deep_compare, parse_bool, Retry, RetryFailedError, split_host_port, uri
 from urllib3.exceptions import HTTPError
 from six.moves.urllib.parse import urlencode, urlparse, quote
 from six.moves.http_client import HTTPException
@@ -27,16 +27,20 @@ class ConsulInternalError(ConsulException):
    """An internal Consul server error occurred"""


-class InvalidSessionTTL(ConsulInternalError):
+class InvalidSessionTTL(ConsulException):
    """Session TTL is too small or too big"""


+class InvalidSession(ConsulException):
+    """invalid session"""
+
+
 class HTTPClient(object):

    def __init__(self, host='127.0.0.1', port=8500, token=None, scheme='http', verify=True, cert=None, ca_cert=None):
        self.token = token
        self._read_timeout = 10
-        self.base_uri = '{0}://{1}:{2}'.format(scheme, host, port)
+        self.base_uri = uri(scheme, (host, port))
        kwargs = {}
        if cert:
            if isinstance(cert, tuple):
@@ -72,6 +76,8 @@ class HTTPClient(object):
            msg = '{0} {1}'.format(response.status, data)
            if data.startswith('Invalid Session TTL'):
                raise InvalidSessionTTL(msg)
+            elif data.startswith('invalid session'):
+                raise InvalidSession(msg)
            else:
                raise ConsulInternalError(msg)
        return base.Response(response.status, response.headers, data)
@@ -96,7 +102,12 @@ class HTTPClient(object):
                params = {k: v for k, v in params}
            kwargs = {'retries': 0, 'preload_content': False, 'body': data}
            if method == 'get' and isinstance(params, dict) and 'index' in params:
-                kwargs['timeout'] = (float(params['wait'][:-1]) if 'wait' in params else 300) + 1
+                timeout = float(params['wait'][:-1]) if 'wait' in params else 300
+                # According to the documentation a small random amount of additional wait time is added to the
+                # supplied maximum wait time to spread out the wake up time of any concurrent requests. This adds
+                # up to wait / 16 additional time to the maximum duration. Since our goal is actually getting a
+                # response rather read timeout we will add to the timeout a sligtly bigger value.
+                kwargs['timeout'] = timeout + max(timeout/15.0, 1)
            else:
                kwargs['timeout'] = self._read_timeout
            token = params.pop('token', self.token) if isinstance(params, dict) else self.token
@@ -111,7 +122,7 @@ class ConsulClient(base.Consul):
    def __init__(self, *args, **kwargs):
        self._cert = kwargs.pop('cert', None)
        self._ca_cert = kwargs.pop('ca_cert', None)
-        self._token = kwargs.get('token')
+        self.token = kwargs.get('token')
        super(ConsulClient, self).__init__(*args, **kwargs)

    def connect(self, *args, **kwargs):
@@ -120,10 +131,15 @@ class ConsulClient(base.Consul):
            kwargs['cert'] = self._cert
        if self._ca_cert:
            kwargs['ca_cert'] = self._ca_cert
-        if self._token:
-            kwargs['token'] = self._token
+        if self.token:
+            kwargs['token'] = self.token
        return HTTPClient(**kwargs)

+    def reload_config(self, config):
+        self.http.token = self.token = config.get('token')
+        self.consistency = config.get('consistency', 'default')
+        self.dc = config.get('dc')
+

 def catch_consul_errors(func):
    def wrapper(*args, **kwargs):
@@ -186,7 +202,7 @@ class Consul(AbstractDCS):
        if config.get('key') and config.get('cert'):
            config['cert'] = (config['cert'], config['key'])

-        config_keys = ('host', 'port', 'token', 'scheme', 'cert', 'ca_cert', 'dc')
+        config_keys = ('host', 'port', 'token', 'scheme', 'cert', 'ca_cert', 'dc', 'consistency')
        kwargs = {p: config.get(p) for p in config_keys if config.get(p)}

        verify = config.get('verify')
@@ -221,11 +237,19 @@ class Consul(AbstractDCS):
                logger.info('waiting on consul')
                time.sleep(5)

+    def reload_config(self, config):
+        super(Consul, self).reload_config(config)
+        self._client.reload_config(config.get('consul', {}))
+
    def set_ttl(self, ttl):
        if self._client.http.set_ttl(ttl/2.0):  # Consul multiplies the TTL by 2x
            self._session = None
            self.__do_not_watch = True

+    @property
+    def ttl(self):
+        return self._client.http.ttl
+
    def set_retry_timeout(self, retry_timeout):
        self._retry.deadline = retry_timeout
        self._client.http.set_read_timeout(retry_timeout)
@@ -288,7 +312,7 @@ class Consul(AbstractDCS):
            nodes = {}
            for node in results:
                node['Value'] = (node['Value'] or b'').decode('utf-8')
-                nodes[os.path.relpath(node['Key'], path).replace('\\', '/')] = node
+                nodes[node['Key'][len(path):].lstrip('/')] = node

            # get initialize flag
            initialize = nodes.get(self._INITIALIZE)
@@ -331,24 +355,22 @@ class Consul(AbstractDCS):
            sync = nodes.get(self._SYNC)
            sync = SyncState.from_node(sync and sync['ModifyIndex'], sync and sync['Value'])

-            self._cluster = Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
+            return Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
        except NotFound:
-            self._cluster = Cluster(None, None, None, None, [], None, None, None)
+            return Cluster(None, None, None, None, [], None, None, None)
        except Exception:
            logger.exception('get_cluster')
            raise ConsulError('Consul is not responding properly')

-    def touch_member(self, data, ttl=None, permanent=False):
+    @catch_consul_errors
+    def touch_member(self, data, permanent=False):
        cluster = self.cluster
        member = cluster and cluster.get_member(self._name, fallback_to_leader=False)
        create_member = not permanent and self.refresh_session()

        if member and (create_member or member.session != self._session):
-            try:
-                self._client.kv.delete(self.member_path)
-                create_member = True
-            except Exception:
-                return False
+            self._client.kv.delete(self.member_path)
+            create_member = True

        if not create_member and member and deep_compare(data, member.data):
            return True
@@ -359,6 +381,9 @@ class Consul(AbstractDCS):
            if self._register_service:
                self.update_service(not create_member and member and member.data or {}, data)
            return True
+        except InvalidSession:
+            self._session = None
+            logger.error('Our session disappeared from Consul, can not "touch_member"')
        except Exception:
            logger.exception('touch_member')
        return False
@@ -382,7 +407,8 @@ class Consul(AbstractDCS):
        api_parts = urlparse(data['api_url'])
        api_parts = api_parts._replace(path='/{0}'.format(role))
        conn_parts = urlparse(data['conn_url'])
-        check = base.Check.http(api_parts.geturl(), self._service_check_interval, deregister=self._client.http.ttl * 10)
+        check = base.Check.http(api_parts.geturl(), self._service_check_interval,
+                                deregister='{0}s'.format(self._client.http.ttl * 10))
        params = {
            'service_id': '{0}/{1}'.format(self._scope, self._name),
            'address': conn_parts.hostname,
@@ -416,14 +442,21 @@ class Consul(AbstractDCS):
            return self._update_service(new_data)

    @catch_consul_errors
-    def _do_attempt_to_acquire_leader(self, kwargs):
-        return self.retry(self._client.kv.put, self.leader_path, self._name, **kwargs)
+    def _do_attempt_to_acquire_leader(self, permanent):
+        try:
+            kwargs = {} if permanent else {'acquire': self._session}
+            return self.retry(self._client.kv.put, self.leader_path, self._name, **kwargs)
+        except InvalidSession:
+            self._session = None
+            logger.error('Our session disappeared from Consul. Will try to get a new one and retry attempt')
+            self.refresh_session()
+            return self.retry(self._client.kv.put, self.leader_path, self._name, acquire=self._session)

    def attempt_to_acquire_leader(self, permanent=False):
        if not self._session and not permanent:
            self.refresh_session()

-        ret = self._do_attempt_to_acquire_leader({} if permanent else {'acquire': self._session})
+        ret = self._do_attempt_to_acquire_leader(permanent)
        if not ret:
            logger.info('Could not take out TTL lock')

@@ -483,6 +516,7 @@ class Consul(AbstractDCS):
        return self.retry(self._client.kv.delete, self.sync_path, cas=index)

    def watch(self, leader_index, timeout):
+        self._last_session_refresh = 0
        if self.__do_not_watch:
            self.__do_not_watch = False
            return True
@@ -14,7 +14,7 @@ from dns.exception import DNSException
 from dns import resolver
 from patroni.dcs import AbstractDCS, ClusterConfig, Cluster, Failover, Leader, Member, SyncState, TimelineHistory
 from patroni.exceptions import DCSError
-from patroni.utils import Retry, RetryFailedError, split_host_port
+from patroni.utils import Retry, RetryFailedError, split_host_port, uri
 from urllib3.exceptions import HTTPError, ReadTimeoutError
 from requests.exceptions import RequestException
 from six.moves.queue import Queue
@@ -25,10 +25,6 @@ from threading import Thread
 logger = logging.getLogger(__name__)


-def uri(protocol, host, port, endpoint=''):
-    return '{0}://{1}:{2}{3}'.format(protocol, host, port, endpoint)
-
-
 class EtcdError(DCSError):
    pass

@@ -87,9 +83,12 @@ class Client(etcd.Client):
        args = {p: config.get(p) for p in ('host', 'port', 'protocol', 'use_proxies', 'username', 'password',
                                           'cert', 'ca_cert') if config.get(p)}
        super(Client, self).__init__(read_timeout=config['retry_timeout'], **args)
+        # For some reason python3-etcd on debian and ubuntu are not based on the latest version
+        # Workaround for the case when https://github.com/jplana/python-etcd/pull/196 is not applied
+        self.http.connection_pool_kw.pop('ssl_version', None)
        self._config = config
        self._load_machines_cache()
-        self._allow_reconnect = not self._use_proxies
+        self._allow_reconnect = True

    def _build_request_parameters(self):
        kwargs = {'headers': self._get_headers(), 'redirect': self.allow_redirect}
@@ -128,8 +127,11 @@ class Client(etcd.Client):
        while True:
            try:
                response = self.http.request(self._MGET, self._base_uri + self.version_prefix + '/machines', **kwargs)
-                machines = [n.strip() for n in self._handle_server_response(response).data.decode('utf-8').split(',')]
+                data = self._handle_server_response(response).data.decode('utf-8')
+                machines = [m.strip() for m in data.split(',') if m.strip()]
                logger.debug("Retrieved list of machines: %s", machines)
+                if not machines:
+                    raise etcd.EtcdException
                random.shuffle(machines)
                for url in machines:
                    r = urlparse(url)
@@ -186,10 +188,8 @@ class Client(etcd.Client):
        # Update machines_cache if previous attempt of update has failed
        if self._update_machines_cache:
            self._load_machines_cache()
-        elif time.time() - self._machines_cache_updated > self._machines_cache_ttl:
-            self._machines_cache = self.machines
-            if self._base_uri in self._machines_cache:
-                self._machines_cache.remove(self._base_uri)
+        elif not self._use_proxies and time.time() - self._machines_cache_updated > self._machines_cache_ttl:
+            self._refresh_machines_cache()
            self._machines_cache_updated = time.time()

        kwargs.update(self._build_request_parameters())
@@ -206,10 +206,8 @@ class Client(etcd.Client):

                if response is False:
                    some_request_failed = True
-            if some_request_failed and not self._use_proxies:
-                self._machines_cache = self.machines
-                if self._base_uri in self._machines_cache:
-                    self._machines_cache.remove(self._base_uri)
+            if some_request_failed:
+                self._refresh_machines_cache()
        except etcd.EtcdConnectionFailed as e:
            if isinstance(e, etcd.EtcdWatchTimedOut) and self._machines_cache:
                self._base_uri = self._next_server()
@@ -236,7 +234,7 @@ class Client(etcd.Client):
            protocol = 'https' if '-ssl' in r else 'http'
            endpoint = '/members' if '-server' in r else ''
            for host, port in self.get_srv_record('_etcd{0}._tcp.{1}'.format(r, srv)):
-                url = uri(protocol, host, port, endpoint)
+                url = uri(protocol, (host, port), endpoint)
                if endpoint:
                    try:
                        response = requests.get(url, timeout=self.read_timeout, verify=False)
@@ -258,15 +256,25 @@ class Client(etcd.Client):
    def _get_machines_cache_from_dns(self, host, port):
        """One host might be resolved into multiple ip addresses. We will make list out of it"""
        if self.protocol == 'http':
-            ret = []
-            for af, _, _, _, sa in self._dns_resolver.resolve(host, port):
-                host, port = sa[:2]
-                if af == socket.AF_INET6:
-                    host = '[{0}]'.format(host)
-                ret.append(uri(self.protocol, host, port))
+            ret = map(lambda res: uri(self.protocol, res[-1][:2]), self._dns_resolver.resolve(host, port))
            if ret:
                return list(set(ret))
-        return [uri(self.protocol, host, port)]
+        return [uri(self.protocol, (host, port))]
+
+    def _get_machines_cache_from_config(self):
+        if 'proxy' in self._config:
+            return [uri(self.protocol, (self._config['host'], self._config['port']))]
+
+        machines_cache = []
+        if 'srv' in self._config:
+            machines_cache = self._get_machines_cache_from_srv(self._config['srv'])
+
+        if not machines_cache and 'hosts' in self._config:
+            machines_cache = list(self._config['hosts'])
+
+        if not machines_cache and 'host' in self._config:
+            machines_cache = self._get_machines_cache_from_dns(self._config['host'], self._config['port'])
+        return machines_cache

    def _load_machines_cache(self):
        """This method should fill up `_machines_cache` from scratch.
@@ -279,19 +287,7 @@ class Client(etcd.Client):
        if 'srv' not in self._config and 'host' not in self._config and 'hosts' not in self._config:
            raise Exception('Neither srv, hosts, host nor url are defined in etcd section of config')

-        if self._use_proxies:
-            self._machines_cache = [uri(self.protocol, self._config['host'], self._config['port'])]
-        else:
-            self._machines_cache = []
-
-            if 'srv' in self._config:
-                self._machines_cache = self._get_machines_cache_from_srv(self._config['srv'])
-
-            if not self._machines_cache and 'hosts' in self._config:
-                self._machines_cache = list(self._config['hosts'])
-
-            if not self._machines_cache and 'host' in self._config:
-                self._machines_cache = self._get_machines_cache_from_dns(self._config['host'], self._config['port'])
+        self._machines_cache = self._get_machines_cache_from_config()

        # Can not bootstrap list of etcd-cluster members, giving up
        if not self._machines_cache:
@@ -299,14 +295,16 @@ class Client(etcd.Client):

        # After filling up initial list of machines_cache we should ask etcd-cluster about actual list
        self._base_uri = self._next_server()
-        self._machines_cache = self.machines
-
-        if self._base_uri in self._machines_cache:
-            self._machines_cache.remove(self._base_uri)
+        self._refresh_machines_cache()

        self._update_machines_cache = False
        self._machines_cache_updated = time.time()

+    def _refresh_machines_cache(self):
+        self._machines_cache = self._get_machines_cache_from_config() if self._use_proxies else self.machines
+        if self._base_uri in self._machines_cache:
+            self._machines_cache.remove(self._base_uri)
+

 class Etcd(AbstractDCS):

@@ -370,7 +368,7 @@ class Etcd(AbstractDCS):
            config['hosts'] = []
            for value in hosts:
                if isinstance(value, six.string_types):
-                    config['hosts'].append(uri(protocol, *split_host_port(value, default_port)))
+                    config['hosts'].append(uri(protocol, split_host_port(value, default_port)))
        elif 'host' in config:
            host, port = split_host_port(config['host'], 2379)
            config['host'] = host
@@ -426,6 +424,8 @@ class Etcd(AbstractDCS):
        while not client:
            try:
                client = Client(config, dns_resolver)
+                if 'use_proxies' in config and not client.machines:
+                    raise etcd.EtcdException
            except etcd.EtcdException:
                logger.info('waiting on etcd')
                time.sleep(5)
@@ -437,6 +437,10 @@ class Etcd(AbstractDCS):
        self._ttl = ttl
        self._client.set_machines_cache_ttl(ttl*10)

+    @property
+    def ttl(self):
+        return self._ttl
+
    def set_retry_timeout(self, retry_timeout):
        self._retry.deadline = retry_timeout
        self._client.set_read_timeout(retry_timeout)
@@ -446,9 +450,10 @@ class Etcd(AbstractDCS):
        return Member.from_node(node.modifiedIndex, os.path.basename(node.key), node.ttl, node.value)

    def _load_cluster(self):
+        cluster = None
        try:
            result = self.retry(self._client.read, self.client_path(''), recursive=True)
-            nodes = {os.path.relpath(node.key, result.key).replace('\\', '/'): node for node in result.leaves}
+            nodes = {node.key[len(result.key):].lstrip('/'): node for node in result.leaves}

            # get initialize flag
            initialize = nodes.get(self._INITIALIZE)
@@ -486,17 +491,18 @@ class Etcd(AbstractDCS):
            sync = nodes.get(self._SYNC)
            sync = SyncState.from_node(sync and sync.modifiedIndex, sync and sync.value)

-            self._cluster = Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
+            cluster = Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
        except etcd.EtcdKeyNotFound:
-            self._cluster = Cluster(None, None, None, None, [], None, None, None)
+            cluster = Cluster(None, None, None, None, [], None, None, None)
        except Exception as e:
            self._handle_exception(e, 'get_cluster', raise_ex=EtcdError('Etcd is not responding properly'))
        self._has_failed = False
+        return cluster

    @catch_etcd_errors
-    def touch_member(self, data, ttl=None, permanent=False):
+    def touch_member(self, data, permanent=False):
        data = json.dumps(data, separators=(',', ':'))
-        return self._client.set(self.member_path, data, None if permanent else ttl or self._ttl)
+        return self._client.set(self.member_path, data, None if permanent else self._ttl)

    @catch_etcd_errors
    def take_leader(self):
@@ -4,6 +4,7 @@ import requests
 import time

 from patroni.dcs.zookeeper import ZooKeeper
+from patroni.utils import uri
 from requests.exceptions import RequestException

 logger = logging.getLogger(__name__)
@@ -46,9 +47,8 @@ class ExhibitorEnsembleProvider(object):
    def _query_exhibitors(self, exhibitors):
        random.shuffle(exhibitors)
        for host in exhibitors:
-            uri = 'http://{0}:{1}{2}'.format(host, self._exhibitor_port, self._uri_path)
            try:
-                response = requests.get(uri, timeout=self.TIMEOUT)
+                response = requests.get(uri('http', (host, self._exhibitor_port), self._uri_path), timeout=self.TIMEOUT)
                return response.json()
            except RequestException:
                pass
@@ -92,13 +92,14 @@ class Kubernetes(AbstractDCS):
        self.__subsets = None
        use_endpoints = config.get('use_endpoints') and (config.get('patronictl') or 'pod_ip' in config)
        if use_endpoints:
-            addresses = [k8s_client.V1EndpointAddress(ip=config['pod_ip'])]
+            addresses = [k8s_client.V1EndpointAddress(ip='127.0.0.1' if config.get('patronictl') else config['pod_ip'])]
            ports = []
            for p in config.get('ports', [{}]):
                port = {'port': int(p.get('port', '5432'))}
                port.update({n: p[n] for n in ('name', 'protocol') if p.get(n)})
                ports.append(k8s_client.V1EndpointPort(**port))
            self.__subsets = [k8s_client.V1EndpointSubset(addresses=addresses, ports=ports)]
+            self._should_create_config_service = True
        self._api = CoreV1ApiProxy(use_endpoints)
        self.set_retry_timeout(config['retry_timeout'])
        self.set_ttl(config.get('ttl') or 30)
@@ -106,6 +107,7 @@ class Kubernetes(AbstractDCS):
        self._leader_observed_time = None
        self._leader_resource_version = None
        self._leader_observed_subsets = []
+        self._config_resource_version = None
        self.__do_not_watch = False

    def retry(self, *args, **kwargs):
@@ -123,6 +125,10 @@ class Kubernetes(AbstractDCS):
        self.__do_not_watch = self._ttl != ttl
        self._ttl = ttl

+    @property
+    def ttl(self):
+        return self._ttl
+
    def set_retry_timeout(self, retry_timeout):
        self._retry.deadline = retry_timeout
        self._api.set_timeout(retry_timeout)
@@ -145,6 +151,7 @@ class Kubernetes(AbstractDCS):

            config = nodes.get(self.config_path)
            metadata = config and config.metadata
+            self._config_resource_version = metadata.resource_version if metadata else None
            annotations = metadata and metadata.annotations or {}

            # get initialize flag
@@ -200,7 +207,7 @@ class Kubernetes(AbstractDCS):
            metadata = sync and sync.metadata
            sync = SyncState.from_node(metadata and metadata.resource_version,  metadata and metadata.annotations)

-            self._cluster = Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
+            return Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
        except Exception:
            logger.exception('get_cluster')
            raise KubernetesError('Kubernetes API is not responding properly')
@@ -274,6 +281,27 @@ class Kubernetes(AbstractDCS):
            body = k8s_client.V1ConfigMap(metadata=metadata)
        return self.retry(func, self._namespace, body) if retry else func(self._namespace, body)

+    def patch_or_create_config(self, annotations, resource_version=None, patch=False, retry=True):
+        # SCOPE-config endpoint requires corresponding service otherwise it might be "cleaned" by k8s master
+        if self.__subsets and not patch and not resource_version:
+            self._should_create_config_service = True
+            self._create_config_service()
+        ret = self.patch_or_create(self.config_path, annotations, resource_version, patch, retry)
+        if ret:
+            self._config_resource_version = ret.metadata.resource_version
+        return ret
+
+    def _create_config_service(self):
+        metadata = k8s_client.V1ObjectMeta(namespace=self._namespace, name=self.config_path, labels=self._labels)
+        body = k8s_client.V1Service(metadata=metadata, spec=k8s_client.V1ServiceSpec(cluster_ip='None'))
+        try:
+            if not self._api.create_namespaced_service(self._namespace, body):
+                return
+        except Exception as e:
+            if not isinstance(e, k8s_client.rest.ApiException) or e.status != 409:  # Service already exists
+                return logger.exception('create_config_service failed')
+        self._should_create_config_service = False
+
    def _write_leader_optime(self, last_operation):
        """Unused"""

@@ -288,9 +316,7 @@ class Kubernetes(AbstractDCS):
        if last_operation:
            annotations[self._OPTIME] = last_operation

-        subsets = self.__subsets
-        if subsets is not None and access_is_restricted:
-            subsets = []
+        subsets = [] if access_is_restricted else self.__subsets

        ret = self.patch_or_create(self.leader_path, annotations, self._leader_resource_version, subsets=subsets)
        if ret:
@@ -332,14 +358,13 @@ class Kubernetes(AbstractDCS):
        return self.patch_or_create(self.failover_path, annotations, index, bool(index or patch), False)

    def set_config_value(self, value, index=None):
-        patch = bool(index or self.cluster and self.cluster.config and self.cluster.config.index)
-        return self.patch_or_create(self.config_path, {self._CONFIG: value}, index, patch, False)
+        return self.patch_or_create_config({self._CONFIG: value}, index, bool(self._config_resource_version), False)

    @catch_kubernetes_errors
-    def touch_member(self, data, ttl=None, permanent=False):
+    def touch_member(self, data, permanent=False):
        cluster = self.cluster
        if cluster and cluster.leader and cluster.leader.name == self._name:
-            role = 'master'
+            role = 'promoted' if data['role'] in ('replica', 'promoted') else 'master'
        elif data['state'] == 'running' and data['role'] != 'master':
            role = data['role']
        else:
@@ -354,12 +379,14 @@ class Kubernetes(AbstractDCS):
                        'annotations': {'status': json.dumps(data, separators=(',', ':'))}}
            body = k8s_client.V1Pod(metadata=k8s_client.V1ObjectMeta(**metadata))
            ret = self._api.patch_namespaced_pod(self._name, self._namespace, body)
+        if self.__subsets and self._should_create_config_service:
+            self._create_config_service()
        return ret

    def initialize(self, create_new=True, sysid=""):
        cluster = self.cluster
        resource_version = cluster.config.index if cluster and cluster.config and cluster.config.index else None
-        return self.patch_or_create(self.config_path, {self._INITIALIZE: sysid}, resource_version)
+        return self.patch_or_create_config({self._INITIALIZE: sysid}, resource_version)

    def delete_leader(self):
        if self.cluster and isinstance(self.cluster.leader, Leader) and self.cluster.leader.name == self._name:
@@ -367,15 +394,14 @@ class Kubernetes(AbstractDCS):
            self.reset_cluster()

    def cancel_initialization(self):
-        self.patch_or_create(self.config_path, {self._INITIALIZE: None}, self.cluster.config.index, True)
+        self.patch_or_create_config({self._INITIALIZE: None}, self._config_resource_version, True)

    @catch_kubernetes_errors
    def delete_cluster(self):
        self.retry(self._api.delete_collection_namespaced_kind, self._namespace, label_selector=self._label_selector)

    def set_history_value(self, value):
-        patch = bool(self.cluster and self.cluster.config and self.cluster.config.index)
-        return self.patch_or_create(self.config_path, {self._HISTORY: value}, None, patch, False)
+        return self.patch_or_create_config({self._HISTORY: value}, None, bool(self._config_resource_version), False)

    def set_sync_state_value(self, value, index=None):
        """Unused"""
@@ -1,5 +1,6 @@
 import json
 import logging
+import select
 import time

 from kazoo.client import KazooClient, KazooState, KazooRetry
@@ -37,12 +38,21 @@ class PatroniSequentialThreadingHandler(SequentialThreadingHandler):
                     `connect_timeout` (negotiated session timeout) as the second element."""

        args = list(args)
-        if len(args) == 1:
+        if len(args) == 0:  # kazoo 2.6.0 slightly changed the way how it calls create_connection method
+            kwargs['timeout'] = max(self._connect_timeout, kwargs.get('timeout', self._connect_timeout*10)/10.0)
+        elif len(args) == 1:
            args.append(self._connect_timeout)
        else:
            args[1] = max(self._connect_timeout, args[1]/10.0)
        return super(PatroniSequentialThreadingHandler, self).create_connection(*args, **kwargs)

+    def select(self, *args, **kwargs):
+        """Python3 raises `ValueError` if socket is closed, because fd == -1"""
+        try:
+            return super(PatroniSequentialThreadingHandler, self).select(*args, **kwargs)
+        except ValueError as e:
+            raise select.error(9, str(e))
+

 class ZooKeeper(AbstractDCS):

@@ -116,6 +126,10 @@ class ZooKeeper(AbstractDCS):
            self._client.restart()
            return True

+    @property
+    def ttl(self):
+        return self._client._session_timeout
+
    def set_retry_timeout(self, retry_timeout):
        retry = self._client.retry if isinstance(self._client.retry, KazooRetry) else self._client._retry
        retry.deadline = retry_timeout
@@ -196,16 +210,18 @@ class ZooKeeper(AbstractDCS):
        failover = self.get_node(self.failover_path, watch=self.cluster_watcher) if self._FAILOVER in nodes else None
        failover = failover and Failover.from_node(failover[1].version, failover[0])

-        self._cluster = Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)
+        return Cluster(initialize, config, leader, last_leader_operation, members, failover, sync, history)

    def _load_cluster(self):
-        if self._fetch_cluster or self._cluster is None:
+        cluster = self.cluster
+        if self._fetch_cluster or cluster is None:
            try:
-                self._client.retry(self._inner_load_cluster)
+                cluster = self._client.retry(self._inner_load_cluster)
            except Exception:
                logger.exception('get_cluster')
                self.cluster_watcher(None)
                raise ZooKeeperError('ZooKeeper in not responding properly')
+        return cluster

    def _create(self, path, value, retry=False, ephemeral=False):
        try:
@@ -254,11 +270,14 @@ class ZooKeeper(AbstractDCS):
        return self._create(self.initialize_path, sysid, retry=True) if create_new \
            else self._client.retry(self._client.set, self.initialize_path, sysid)

-    def touch_member(self, data, ttl=None, permanent=False):
+    def touch_member(self, data, permanent=False):
        cluster = self.cluster
        member = cluster and cluster.get_member(self._name, fallback_to_leader=False)
        encoded_data = json.dumps(data, separators=(',', ':')).encode('utf-8')
-        if member and self._client.client_id is not None and member.session != self._client.client_id[0]:
+        if member and (self._client.client_id is not None and member.session != self._client.client_id[0] or
+                       not (deep_compare(member.data.get('tags', {}), data.get('tags', {})) and
+                            member.data.get('version') == data.get('version') and
+                            member.data.get('checkpoint_after_promote') == data.get('checkpoint_after_promote'))):
            try:
                self._client.delete_async(self.member_path).get(timeout=1)
            except NoNodeError:
@@ -13,6 +13,8 @@ from multiprocessing.pool import ThreadPool
 from patroni.async_executor import AsyncExecutor, CriticalTask
 from patroni.exceptions import DCSError, PostgresConnectionException, PatroniException
 from patroni.postgresql import ACTION_ON_START, ACTION_ON_ROLE_CHANGE
+from patroni.postgresql.misc import postgres_version_to_int
+from patroni.postgresql.rewind import Rewind
 from patroni.utils import polling_loop, tzutc
 from patroni.dcs import RemoteMember
 from threading import RLock
@@ -20,25 +22,28 @@ from threading import RLock
 logger = logging.getLogger(__name__)


-class _MemberStatus(namedtuple('_MemberStatus', 'member,reachable,in_recovery,wal_position,tags,watchdog_failed')):
+class _MemberStatus(namedtuple('_MemberStatus', ['member', 'reachable', 'in_recovery', 'timeline',
+                                                 'wal_position', 'tags', 'watchdog_failed'])):
    """Node status distilled from API response:

        member - dcs.Member object of the node
        reachable - `!False` if the node is not reachable or is not responding with correct JSON
        in_recovery - `!True` if pg_is_in_recovery() == true
-        wal_position - value of `replayed_location` or `location` from JSON, dependin on its role.
+        timeline - timeline value from JSON
+        wal_position - maximum value of `replayed_location` or `received_location` from JSON
        tags - dictionary with values of different tags (i.e. nofailover)
        watchdog_failed - indicates that watchdog is required by configuration but not available or failed
    """
    @classmethod
    def from_api_response(cls, member, json):
        is_master = json['role'] == 'master'
+        timeline = json.get('timeline', 0)
        wal = not is_master and max(json['xlog'].get('received_location', 0), json['xlog'].get('replayed_location', 0))
-        return cls(member, True, not is_master, wal, json.get('tags', {}), json.get('watchdog_failed', False))
+        return cls(member, True, not is_master, timeline, wal, json.get('tags', {}), json.get('watchdog_failed', False))

    @classmethod
    def unknown(cls, member):
-        return cls(member, False, None, 0, {}, False)
+        return cls(member, False, None, 0, 0, {}, False)

    def failover_limitation(self):
        """Returns reason why this node can't promote or None if everything is ok."""
@@ -56,6 +61,7 @@ class Ha(object):
    def __init__(self, patroni):
        self.patroni = patroni
        self.state_handler = patroni.postgresql
+        self._rewind = Rewind(self.state_handler)
        self.dcs = patroni.dcs
        self.cluster = None
        self.old_cluster = None
@@ -68,7 +74,7 @@ class Ha(object):
        self._post_bootstrap_task = None
        self._crash_recovery_executed = False
        self._start_timeout = None
-        self._async_executor = AsyncExecutor(self.state_handler, self.wakeup)
+        self._async_executor = AsyncExecutor(self.state_handler.cancellable, self.wakeup)
        self.watchdog = patroni.watchdog

        # Each member publishes various pieces of information to the DCS using touch_member. This lock protects
@@ -92,6 +98,9 @@ class Ha(object):
    def is_paused(self):
        return self.check_mode('pause')

+    def check_timeline(self):
+        return self.check_mode('check_timeline')
+
    def get_standby_cluster_config(self):
        if self.cluster and self.cluster.config and self.cluster.config.modify_index:
            config = self.cluster.config.data
@@ -106,11 +115,11 @@ class Ha(object):

    def is_leader(self):
        with self._is_leader_lock:
-            return self._is_leader and not self._leader_access_is_restricted
+            return self._is_leader > time.time() and not self._leader_access_is_restricted

    def set_is_leader(self, value):
        with self._is_leader_lock:
-            self._is_leader = value
+            self._is_leader = time.time() + self.dcs.ttl if value else 0

    def set_leader_access_is_restricted(self, value):
        with self._is_leader_lock:
@@ -124,7 +133,7 @@ class Ha(object):
            self.old_cluster = cluster
        self.cluster = cluster

-        if self.cluster.is_unlocked() or self.cluster.leader.name != self.state_handler.name:
+        if not self.has_lock(False):
            self.set_is_leader(False)

        self._leader_timeline = None if cluster.is_unlocked() else cluster.leader.timeline
@@ -148,9 +157,10 @@ class Ha(object):
            self.watchdog.keepalive()
        return ret

-    def has_lock(self):
+    def has_lock(self, info=True):
        lock_owner = self.cluster.leader and self.cluster.leader.name
-        logger.info('Lock owner: %s; I am %s', lock_owner, self.state_handler.name)
+        if info:
+            logger.info('Lock owner: %s; I am %s', lock_owner, self.state_handler.name)
        return lock_owner == self.state_handler.name

    def get_effective_tags(self):
@@ -167,12 +177,15 @@ class Ha(object):
                'conn_url': self.state_handler.connection_string,
                'api_url': self.patroni.api.connection_string,
                'state': self.state_handler.state,
-                'role': self.state_handler.role
+                'role': self.state_handler.role,
+                'version': self.patroni.version
            }

            # following two lines are mainly necessary for consul, to avoid creation of master service
            if data['role'] == 'master' and not self.is_leader():
                data['role'] = 'promoted'
+            if self.is_leader() and not self._rewind.checkpoint_after_promote():
+                data['checkpoint_after_promote'] = False
            tags = self.get_effective_tags()
            if tags:
                data['tags'] = tags
@@ -200,7 +213,11 @@ class Ha(object):
            return self.dcs.touch_member(data)

    def clone(self, clone_member=None, msg='(without leader)'):
-        if self.state_handler.clone(clone_member):
+        if self.is_standby_cluster() and not isinstance(clone_member, RemoteMember):
+            clone_member = self.get_remote_member(clone_member)
+
+        self._rewind.reset_state()
+        if self.state_handler.bootstrap.clone(clone_member):
            logger.info('bootstrapped %s', msg)
            cluster = self.dcs.get_cluster()
            node_to_follow = self._get_node_to_follow(cluster)
@@ -231,19 +248,21 @@ class Ha(object):
                else:
                    self._async_executor.schedule('bootstrap')
                    self._async_executor.run_async(
-                        self.state_handler.bootstrap,
+                        self.state_handler.bootstrap.bootstrap,
                        args=(self.patroni.config['bootstrap'],)
                    )
                    return 'trying to bootstrap a new cluster'
            else:
                return 'failed to acquire initialize lock'
        else:
-            if self.state_handler.can_create_replica_without_replication_connection():
+            create_replica_methods = self.get_standby_cluster_config().get('create_replica_methods', []) \
+                                     if self.is_standby_cluster() else None
+            if self.state_handler.can_create_replica_without_replication_connection(create_replica_methods):
                msg = 'bootstrap (without leader)'
                self._async_executor.schedule(msg)
                self._async_executor.run_async(self.clone)
                return 'trying to ' + msg
-            return 'waiting for leader to bootstrap'
+            return 'waiting for {0}leader to bootstrap'.format('standby_' if self.is_standby_cluster() else '')

    def bootstrap_standby_leader(self):
        """ If we found 'standby' key in the configuration, we need to bootstrap
@@ -259,11 +278,20 @@ class Ha(object):

        return result

-    def _handle_rewind(self):
+    def _handle_rewind_or_reinitialize(self):
        leader = self.get_remote_master() if self.is_standby_cluster() else self.cluster.leader
-        if self.state_handler.rewind_needed_and_possible(leader):
+        if not self._rewind.rewind_or_reinitialize_needed_and_possible(leader):
+            return None
+
+        if self._rewind.can_rewind:
            self._async_executor.schedule('running pg_rewind from ' + leader.name)
-            self._async_executor.run_async(self.state_handler.rewind, (leader,))
+            self._async_executor.run_async(self._rewind.execute, (leader,))
+            return True
+
+        # remove_data_directory_on_diverged_timelines is set
+        if not self.is_standby_cluster():
+            self._async_executor.schedule('reinitializing due to diverged timelines')
+            self._async_executor.run_async(self._do_reinitialize, args=(self.cluster, ))
            return True

    def recover(self):
@@ -286,8 +314,10 @@ class Ha(object):
            timeout = None

        data = self.state_handler.controldata()
-        if data.get('Database cluster state') in ('in production', 'shutting down', 'in crash recovery') and \
-                not self._crash_recovery_executed and (self.cluster.is_unlocked() or self.state_handler.can_rewind):
+        logger.info('pg_controldata:\n%s\n', '\n'.join('  {0}: {1}'.format(k, v) for k, v in data.items()))
+        if data.get('Database cluster state') in ('in production', 'shutting down', 'in crash recovery') \
+                and not self._crash_recovery_executed and \
+                (self.cluster.is_unlocked() or self._rewind.can_rewind):
            self._crash_recovery_executed = True
            self._async_executor.schedule('doing crash recovery in a single user mode')
            self._async_executor.run_async(self.state_handler.fix_cluster_state)
@@ -295,14 +325,16 @@ class Ha(object):

        self.load_cluster_from_dcs()

+        role = 'replica'
        if self.is_standby_cluster() or not self.has_lock():
-            if not self.state_handler.rewind_executed:
-                self.state_handler.trigger_check_diverged_lsn()
-            if self._handle_rewind():
+            if not self._rewind.executed:
+                self._rewind.trigger_check_diverged_lsn()
+            if self._handle_rewind_or_reinitialize():
                return self._async_executor.scheduled_action

            if self.has_lock():  # in standby cluster
                msg = "starting as a standby leader because i had the session lock"
+                role = 'standby_leader'
                node_to_follow = self._get_node_to_follow(self.cluster)
            elif self.is_standby_cluster() and self.cluster.is_unlocked():
                msg = "trying to follow a remote master because standby cluster is unhealthy"
@@ -317,24 +349,20 @@ class Ha(object):
        self.recovering = True

        self._async_executor.schedule('restarting after failure')
-        self._async_executor.run_async(self.state_handler.follow, (node_to_follow, timeout))
+        self._async_executor.run_async(self.state_handler.follow, (node_to_follow, role, timeout))
        return msg

    def _get_node_to_follow(self, cluster):
        # determine the node to follow. If replicatefrom tag is set,
        # try to follow the node mentioned there, otherwise, follow the leader.
-        is_leader = self.cluster.leader and self.state_handler.name == self.cluster.leader.name
-
-        if self.is_standby_cluster() and (is_leader or self.cluster.is_unlocked()):
+        if self.is_standby_cluster() and (self.cluster.is_unlocked() or self.has_lock(False)):
            node_to_follow = self.get_remote_master()
        elif self.patroni.replicatefrom and self.patroni.replicatefrom != self.state_handler.name:
            node_to_follow = cluster.get_member(self.patroni.replicatefrom)
        else:
            node_to_follow = cluster.leader

-        return (node_to_follow if
-                node_to_follow and
-                node_to_follow.name != self.state_handler.name else None)
+        return node_to_follow if node_to_follow and node_to_follow.name != self.state_handler.name else None

    def follow(self, demote_reason, follow_reason, refresh=True):
        if refresh:
@@ -345,7 +373,8 @@ class Ha(object):
        node_to_follow = self._get_node_to_follow(self.cluster)

        if self.is_paused():
-            if not (self.state_handler.need_rewind and self.state_handler.can_rewind) or self.cluster.is_unlocked():
+            if not (self._rewind.is_needed and self._rewind.can_rewind_or_reinitialize_allowed)\
+                    or self.cluster.is_unlocked():
                self.state_handler.set_role('master' if is_leader else 'replica')
                if is_leader:
                    return 'continue to run as master without lock'
@@ -355,12 +384,20 @@ class Ha(object):
            self.demote('immediate-nolock')
            return demote_reason

-        if self._handle_rewind():
+        if self._handle_rewind_or_reinitialize():
            return self._async_executor.scheduled_action

-        if not self.state_handler.check_recovery_conf(node_to_follow):
+        role = 'standby_leader' if isinstance(node_to_follow, RemoteMember) and self.has_lock(False) else 'replica'
+        # It might happen that leader key in the standby cluster references non-exiting member.
+        # In this case it is safe to continue running without changing recovery.conf
+        if self.is_standby_cluster() and role == 'replica' and not (node_to_follow and node_to_follow.conn_url):
+            return 'continue following the old known standby leader'
+        elif not self.state_handler.config.check_recovery_conf(node_to_follow):
            self._async_executor.schedule('changing primary_conninfo and restarting')
-            self._async_executor.run_async(self.state_handler.follow, (node_to_follow,))
+            self._async_executor.run_async(self.state_handler.follow, (node_to_follow, role))
+        elif role == 'standby_leader' and self.state_handler.role != role:
+            self.state_handler.set_role(role)
+            self.state_handler.call_nowait(ACTION_ON_ROLE_CHANGE)

        return follow_reason

@@ -395,14 +432,17 @@ class Ha(object):
                    logger.warning("No standbys available!")

                logger.info("Assigning synchronous standby status to %s", picked)
-                self.state_handler.set_synchronous_standby(picked)
+                self.state_handler.config.set_synchronous_standby(picked)

                if picked and picked != '*' and not allow_promote:
                    # Wait for PostgreSQL to enable synchronous mode and see if we can immediately set sync_standby
                    time.sleep(2)
                    picked, allow_promote = self.state_handler.pick_synchronous_standby(self.cluster)
                if allow_promote:
-                    cluster = self.dcs.get_cluster()
+                    try:
+                        cluster = self.dcs.get_cluster()
+                    except DCSError:
+                        return logger.warning("Could not get cluster state from DCS during process_sync_replication()")
                    if cluster.sync.leader and cluster.sync.leader != self.state_handler.name:
                        logger.info("Synchronous replication key updated by someone else")
                        return
@@ -413,7 +453,7 @@ class Ha(object):
        else:
            if self.cluster.sync.leader and self.dcs.delete_sync_state(index=self.cluster.sync.index):
                logger.info("Disabled synchronous replication")
-            self.state_handler.set_synchronous_standby(None)
+            self.state_handler.config.set_synchronous_standby(None)

    def is_sync_standby(self, cluster):
        return cluster.leader and cluster.sync.leader == cluster.leader.name \
@@ -475,9 +515,7 @@ class Ha(object):
                self.dcs.set_history_value(json.dumps(history, separators=(',', ':')))

    def enforce_follow_remote_master(self, message):
-        self.state_handler.set_role('standby_leader')
        demote_reason = 'cannot be a real master in standby cluster'
-
        return self.follow(demote_reason, message)

    def enforce_master_role(self, message, promote_message):
@@ -507,12 +545,17 @@ class Ha(object):
                    # Somebody else updated sync state, it may be due to us losing the lock. To be safe, postpone
                    # promotion until next cycle. TODO: trigger immediate retry of run_cycle
                    return 'Postponing promotion because synchronous replication state was updated by somebody else'
-                self.state_handler.set_synchronous_standby('*' if self.is_synchronous_mode_strict() else None)
+                self.state_handler.config.set_synchronous_standby('*' if self.is_synchronous_mode_strict() else None)
            if self.state_handler.role != 'master':
                self.set_leader_access_is_restricted(self.cluster.has_permanent_logical_slots(self.state_handler.name))
+
+                def on_success():
+                    self._rewind.reset_state()
+                    logger.info("cleared rewind state after becoming the leader")
+
                self._async_executor.schedule('promote')
                self._async_executor.run_async(self.state_handler.promote,
-                                               args=(self.dcs.loop_wait, self._leader_access_is_restricted))
+                                               args=(self.dcs.loop_wait, on_success, self._leader_access_is_restricted))
            return promote_message

    @staticmethod
@@ -543,15 +586,23 @@ class Ha(object):
        :returns True when node is lagging
        """
        lag = (self.cluster.last_leader_operation or 0) - wal_position
-        return lag > self.state_handler.config.get('maximum_lag_on_failover', 0)
+        return lag > self.patroni.config.get('maximum_lag_on_failover', 0)

    def _is_healthiest_node(self, members, check_replication_lag=True):
        """This method tries to determine whether I am healthy enough to became a new leader candidate or not."""

        _, my_wal_position = self.state_handler.timeline_wal_position()
        if check_replication_lag and self.is_lagging(my_wal_position):
+            logger.info('My wal position exceeds maximum replication lag')
            return False  # Too far behind last reported wal position on master

+        if not self.is_standby_cluster() and self.check_timeline():
+            cluster_timeline = self.cluster.timeline
+            my_timeline = self.state_handler.replica_cached_timeline(cluster_timeline)
+            if my_timeline < cluster_timeline:
+                logger.info('My timeline %s is behind last known cluster timeline %s', my_timeline, cluster_timeline)
+                return False
+
        # Prepare list of nodes to run check against
        members = [m for m in members if m.name != self.state_handler.name and not m.nofailover and m.api_url]

@@ -562,11 +613,17 @@ class Ha(object):
                        logger.warning('Master (%s) is still alive', st.member.name)
                        return False
                    if my_wal_position < st.wal_position:
-                        return False
+                        logger.info('Wal position of %s is ahead of my wal position', st.member.name)
+                        # In synchronous mode the former leader might be still accessible and even be ahead of us.
+                        # We should not disqualify himself from the leader race in such a situation.
+                        if not self.is_synchronous_mode() or st.member.name != self.cluster.sync.leader:
+                            return False
+                        logger.info('Ignoring the former leader being ahead of us')
        return True

    def is_failover_possible(self, members):
        ret = False
+        cluster_timeline = self.cluster.timeline
        members = [m for m in members if m.name != self.state_handler.name and not m.nofailover and m.api_url]
        if members:
            for st in self.fetch_nodes_statuses(members):
@@ -575,6 +632,9 @@ class Ha(object):
                    logger.info('Member %s is %s', st.member.name, not_allowed_reason)
                elif self.is_lagging(st.wal_position):
                    logger.info('Member %s exceeds maximum replication lag', st.member.name)
+                elif self.check_timeline() and (not st.timeline or st.timeline < cluster_timeline):
+                    logger.info('Timeline %s of member %s is behind the cluster timeline %s',
+                                st.timeline, st.member.name, cluster_timeline)
                else:
                    ret = True
        else:
@@ -666,10 +726,14 @@ class Ha(object):

        return self._is_healthiest_node(members.values())

-    def release_leader_key_voluntarily(self):
+    def _delete_leader(self):
+        self.set_is_leader(False)
        self.dcs.delete_leader()
-        self.touch_member()
        self.dcs.reset_cluster()
+
+    def release_leader_key_voluntarily(self):
+        self._delete_leader()
+        self.touch_member()
        logger.info("Leader key released")

    def demote(self, mode):
@@ -690,14 +754,15 @@ class Ha(object):
            'immediate-nolock': dict(stop='immediate', checkpoint=False, release=False, offline=False, async_req=True),
        }[mode]

-        self.state_handler.trigger_check_diverged_lsn()
+        self._rewind.trigger_check_diverged_lsn()
        self.state_handler.stop(mode_control['stop'], checkpoint=mode_control['checkpoint'],
                                on_safepoint=self.watchdog.disable if self.watchdog.is_running else None)
        self.state_handler.set_role('demoted')
        self.set_is_leader(False)

        if mode_control['release']:
-            self.release_leader_key_voluntarily()
+            with self._async_executor:
+                self.release_leader_key_voluntarily()
            time.sleep(2)  # Give a time to somebody to take the leader lock
        if mode_control['offline']:
            node_to_follow, leader = None, None
@@ -713,8 +778,8 @@ class Ha(object):
            self._async_executor.run_async(self.state_handler.follow, (node_to_follow,))
        else:
            if self.is_synchronous_mode():
-                self.state_handler.set_synchronous_standby(None)
-            if self.state_handler.rewind_needed_and_possible(leader):
+                self.state_handler.config.set_synchronous_standby(None)
+            if self._rewind.rewind_or_reinitialize_needed_and_possible(leader):
                return False  # do not start postgres, but run pg_rewind on the next iteration
            self.state_handler.follow(node_to_follow)

@@ -816,7 +881,7 @@ class Ha(object):
                    # standby leader disappeared, and this is a healthiest
                    # replica, so it should become a new standby leader.
                    # This imply that we need to start following a remote master
-                    msg = 'promoted self to a standby leader because i had the session lock'
+                    msg = 'promoted self to a standby leader by acquiring session lock'
                    return self.enforce_follow_remote_master(msg)
                else:
                    return self.enforce_master_role(
@@ -830,7 +895,7 @@ class Ha(object):
            # when we are doing manual failover there is no guaranty that new leader is ahead of any other node
            # node tagged as nofailover can be ahead of the new leader either, but it is always excluded from elections
            if bool(self.cluster.failover) or self.patroni.nofailover:
-                self.state_handler.trigger_check_diverged_lsn()
+                self._rewind.trigger_check_diverged_lsn()
                time.sleep(2)  # Give a time to somebody to take the leader lock

            if self.patroni.nofailover:
@@ -845,12 +910,11 @@ class Ha(object):
                if self.cluster.failover and self.cluster.failover.candidate == self.state_handler.name:
                    return 'waiting to become master after promote...'

-                self.dcs.delete_leader()
-                self.dcs.reset_cluster()
+                self._delete_leader()
                return 'removed leader lock because postgres is not running as master'

            if self.state_handler.is_leader() and self._leader_access_is_restricted:
-                self.state_handler.sync_replication_slots(self.cluster)
+                self.state_handler.slots_handler.sync_replication_slots(self.cluster)
                self.state_handler.call_nowait(ACTION_ON_ROLE_CHANGE)
                self.set_leader_access_is_restricted(False)

@@ -859,11 +923,16 @@ class Ha(object):
                if msg is not None:
                    return msg

+                # check if the node is ready to be used by pg_rewind
+                self._rewind.check_for_checkpoint_after_promote()
+
                if self.is_standby_cluster():
                    # in case of standby cluster we don't really need to
                    # enforce anything, since the leader is not a master.
                    # So just remind the role.
-                    msg = 'no action.  i am the standby leader with the lock'
+                    msg = 'no action.  i am the standby leader with the lock' \
+                          if self.state_handler.role == 'standby_leader' else \
+                          'promoted self to a standby leader because i had the session lock'
                    return self.enforce_follow_remote_master(msg)
                else:
                    return self.enforce_master_role(
@@ -882,6 +951,9 @@ class Ha(object):
                    return 'not promoting because failed to update leader lock in DCS'
        else:
            logger.info('does not have lock')
+        if self.is_standby_cluster():
+            return self.follow('cannot be a real master in standby cluster',
+                               'no action.  i am a secondary and i am following a standby leader', refresh=False)
        return self.follow('demoting self because i do not have the lock and i was a leader',
                           'no action.  i am a secondary and i am following a leader', refresh=False)

@@ -918,8 +990,7 @@ class Ha(object):
        if role and role != self.state_handler.role:
            reason_to_cancel = "host role mismatch"

-        if (postgres_version and
-           self.state_handler.postgres_version_to_int(postgres_version) <= int(self.state_handler.server_version)):
+        if postgres_version and postgres_version_to_int(postgres_version) <= int(self.state_handler.server_version):
            reason_to_cancel = "postgres version mismatch"

        if pending_restart and not self.state_handler.pending_restart:
@@ -1013,7 +1084,7 @@ class Ha(object):
            if self.cluster.is_unlocked():
                return 'Cluster has no leader, can not reinitialize'

-            if self.cluster.leader.name == self.state_handler.name:
+            if self.has_lock(False):
                return 'I am the leader, can not reinitialize'

        if force:
@@ -1059,8 +1130,7 @@ class Ha(object):
            self.watchdog.disable()
            if self.has_lock():
                self.state_handler.set_role('demoted')
-                self.dcs.delete_leader()
-                self.dcs.reset_cluster()
+                self._delete_leader()
                return 'removed leader key after trying and failing to start postgres'
            return 'failed to start postgres'
        self._crash_recovery_executed = False
@@ -1084,7 +1154,7 @@ class Ha(object):

            self.state_handler.set_role('master')
            self._async_executor.schedule('post_bootstrap')
-            self._async_executor.run_async(self.state_handler.post_bootstrap,
+            self._async_executor.run_async(self.state_handler.bootstrap.post_bootstrap,
                                           args=(self.patroni.config['bootstrap'], self._post_bootstrap_task))
            return 'running post_bootstrap'

@@ -1093,7 +1163,7 @@ class Ha(object):
        if not self.watchdog.activate():
            logger.error('Cancelling bootstrap because watchdog activation failed')
            self.cancel_initialization()
-        self.state_handler.sync_replication_slots(self.cluster)
+        self.state_handler.slots_handler.sync_replication_slots(self.cluster)
        self.dcs.take_leader()
        self.set_is_leader(True)
        self.state_handler.call_nowait(ACTION_ON_START)
@@ -1182,7 +1252,7 @@ class Ha(object):
            if self.state_handler.bootstrapping:
                return self.post_bootstrap()

-            if self.recovering and not self.state_handler.need_rewind:
+            if self.recovering and not self._rewind.is_needed:
                self.recovering = False
                # Check if we tried to recover and failed
                msg = self.post_recover()
@@ -1226,16 +1296,15 @@ class Ha(object):
            if not self.state_handler.is_healthy():
                if self.is_paused():
                    if self.has_lock():
-                        self.dcs.delete_leader()
-                        self.dcs.reset_cluster()
+                        self._delete_leader()
                        return 'removed leader lock because postgres is not running'
                    # Normally we don't start Postgres in a paused state. We make an exception for the demoted primary
                    # that needs to be started after it had been stopped by demote. When there is no need to call rewind
                    # the demote code follows through to starting Postgres right away, however, in the rewind case
                    # it returns from demote and reaches this point to start PostgreSQL again after rewind. In that
                    # case it makes no sense to continue to recover() unless rewind has finished successfully.
-                    elif (self.state_handler.rewind_failed or
-                          not (self.state_handler.need_rewind and self.state_handler.can_rewind)):
+                    elif self._rewind.failed or not self._rewind.executed and not \
+                            (self._rewind.is_needed and self._rewind.can_rewind_or_reinitialize_allowed):
                        return 'postgres is not running'

                # try to start dead postgres
@@ -1252,10 +1321,10 @@ class Ha(object):
                # stops PostgreSQL, therefore, we only reload replication slots if no
                # asynchronous processes are running (should be always the case for the master)
                if not self._async_executor.busy and not self.state_handler.is_starting():
-                    self.state_handler.sync_replication_slots(self.cluster)
+                    self.state_handler.slots_handler.sync_replication_slots(self.cluster)
                    if not self.state_handler.cb_called:
                        if not self.state_handler.is_leader():
-                            self.state_handler.trigger_check_diverged_lsn()
+                            self._rewind.trigger_check_diverged_lsn()
                        self.state_handler.call_nowait(ACTION_ON_START)
        except DCSError:
            dcs_failed = True
@@ -1298,13 +1367,11 @@ class Ha(object):
                             (" Leaving watchdog running." if self.watchdog.is_running else ""))

    def watch(self, timeout):
-        cluster = self.cluster
        # watch on leader key changes if the postgres is running and leader is known and current node is not lock owner
-        if not self._async_executor.busy and cluster and cluster.leader \
-                and cluster.leader.name != self.state_handler.name:
-            leader_index = cluster.leader.index
-        else:
+        if self._async_executor.busy or self.cluster.is_unlocked() or self.has_lock(False):
            leader_index = None
+        else:
+            leader_index = self.cluster.leader.index

        return self.dcs.watch(leader_index, timeout)

@@ -1314,7 +1381,7 @@ class Ha(object):
        This usually happens on the master or if the node is running async action"""
        self.dcs.event.set()

-    def get_remote_master(self):
+    def get_remote_member(self, member=None):
        """ In case of standby cluster this will tel us from which remote
            master to stream. Config can be both patroni config or
            cluster.config.data
@@ -1322,17 +1389,16 @@ class Ha(object):
        cluster_params = self.get_standby_cluster_config()

        if cluster_params:
-            unique_name = 'remote_master:{}'.format(uuid.uuid1())
-            data = {
-                'conn_kwargs': {
-                    "host": cluster_params.get('host'),
-                    "port": cluster_params.get('port'),
-                },
-                'no_replication_slot': 'primary_slot_name' not in cluster_params,
-            }
-            data.update({
-                k: v for k, v in cluster_params.items()
-                if k in RemoteMember.allowed_keys()
-            })
+            name = member.name if member else 'remote_master:{}'.format(uuid.uuid1())

-            return RemoteMember(unique_name, data)
+            data = {k: v for k, v in cluster_params.items() if k in RemoteMember.allowed_keys()}
+            data['no_replication_slot'] = 'primary_slot_name' not in cluster_params
+            conn_kwargs = member.conn_kwargs() if member else \
+                {k: cluster_params[k] for k in ('host', 'port') if k in cluster_params}
+            if conn_kwargs:
+                data['conn_kwargs'] = conn_kwargs
+
+            return RemoteMember(name, data)
+
+    def get_remote_master(self):
+        return self.get_remote_member()
@@ -0,0 +1,158 @@
+import logging
+import os
+import sys
+
+from copy import deepcopy
+from logging.handlers import RotatingFileHandler
+from patroni.utils import deep_compare
+from six.moves.queue import Queue, Full
+from threading import Lock, Thread
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class QueueHandler(logging.Handler):
+
+    def __init__(self):
+        logging.Handler.__init__(self)
+        self.queue = Queue()
+        self._records_lost = 0
+
+    def _put_record(self, record):
+        self.format(record)
+        record.msg = record.message
+        record.args = None
+        record.exc_info = None
+        self.queue.put_nowait(record)
+
+    def _try_to_report_lost_records(self):
+        if self._records_lost:
+            try:
+                record = _LOGGER.makeRecord(_LOGGER.name, logging.WARNING, __file__, 0,
+                                            'QueueHandler has lost %s log records',
+                                            (self._records_lost,), None, 'emit')
+                self._put_record(record)
+                self._records_lost = 0
+            except Exception:
+                pass
+
+    def emit(self, record):
+        try:
+            self._put_record(record)
+            self._try_to_report_lost_records()
+        except Exception:
+            self._records_lost += 1
+
+    @property
+    def records_lost(self):
+        return self._records_lost
+
+
+class PatroniLogger(Thread):
+
+    DEFAULT_LEVEL = 'INFO'
+    DEFAULT_FORMAT = '%(asctime)s %(levelname)s: %(message)s'
+
+    NORMAL_LOG_QUEUE_SIZE = 2  # When everything goes normal Patroni writes only 2 messages per HA loop
+    DEFAULT_MAX_QUEUE_SIZE = 1000
+    LOGGING_BROKEN_EXIT_CODE = 5
+
+    def __init__(self):
+        super(PatroniLogger, self).__init__()
+        self.daemon = True
+        self._queue_handler = QueueHandler()
+        self._root_logger = logging.getLogger()
+        self._root_logger.addHandler(self._queue_handler)
+        self._config = None
+        self._log_handler = None
+        self._old_handlers = []
+        self._log_handler_lock = Lock()
+        self.reload_config({'level': 'DEBUG'})
+        self.start()
+
+    def update_loggers(self):
+        loggers = deepcopy(self._config.get('loggers') or {})
+        for name, logger in self._root_logger.manager.loggerDict.items():
+            if not isinstance(logger, logging.PlaceHolder):
+                level = loggers.pop(name, logging.NOTSET)
+                logger.setLevel(level)
+
+        for name, level in loggers.items():
+            logger = self._root_logger.manager.getLogger(name)
+            logger.setLevel(level)
+
+    def reload_config(self, config):
+        if self._config is None or not deep_compare(self._config, config):
+            with self._queue_handler.queue.mutex:
+                self._queue_handler.queue.maxsize = config.get('max_queue_size', self.DEFAULT_MAX_QUEUE_SIZE)
+
+            self._root_logger.setLevel(config.get('level', PatroniLogger.DEFAULT_LEVEL))
+
+            new_handler = None
+            if 'dir' in config:
+                if not isinstance(self._log_handler, RotatingFileHandler):
+                    new_handler = RotatingFileHandler(os.path.join(config['dir'], __name__))
+                handler = new_handler or self._log_handler
+                handler.maxBytes = int(config.get('file_size', 25000000))
+                handler.backupCount = int(config.get('file_num', 4))
+            else:
+                if self._log_handler is None or isinstance(self._log_handler, RotatingFileHandler):
+                    new_handler = logging.StreamHandler()
+                handler = new_handler or self._log_handler
+
+            oldlogformat = (self._config or {}).get('format', PatroniLogger.DEFAULT_FORMAT)
+            logformat = config.get('format', PatroniLogger.DEFAULT_FORMAT)
+
+            olddateformat = (self._config or {}).get('dateformat') or None
+            dateformat = config.get('dateformat') or None  # Convert empty string to `None`
+
+            if oldlogformat != logformat or olddateformat != dateformat or new_handler:
+                handler.setFormatter(logging.Formatter(logformat, dateformat))
+
+            if new_handler:
+                with self._log_handler_lock:
+                    if self._log_handler:
+                        self._old_handlers.append(self._log_handler)
+                    self._log_handler = new_handler
+
+            self._config = config.copy()
+            self.update_loggers()
+
+    def _close_old_handlers(self):
+        while True:
+            with self._log_handler_lock:
+                if not self._old_handlers:
+                    break
+                handler = self._old_handlers.pop()
+            try:
+                handler.close()
+            except Exception:
+                _LOGGER.exception('Failed to close the old log handler %s', handler)
+
+    def run(self):
+        while True:
+            self._close_old_handlers()
+
+            record = self._queue_handler.queue.get(True)
+            if record is None:
+                break
+
+            self._log_handler.handle(record)
+            self._queue_handler.queue.task_done()
+
+    def shutdown(self):
+        try:
+            self._queue_handler.queue.put_nowait(None)
+        except Full:  # Queue is full.
+            # It seems that logging is not working, exiting with non-standard exit-code is the best we can do.
+            sys.exit(self.LOGGING_BROKEN_EXIT_CODE)
+        self.join()
+        logging.shutdown()
+
+    @property
+    def queue_size(self):
+        return self._queue_handler.queue.qsize()
+
+    @property
+    def records_lost(self):
+        return self._queue_handler.records_lost
@@ -0,0 +1,902 @@
+import logging
+import os
+import psycopg2
+import shlex
+import shutil
+import subprocess
+import time
+
+from contextlib import contextmanager
+from copy import deepcopy
+from patroni.postgresql.callback_executor import CallbackExecutor
+from patroni.postgresql.bootstrap import Bootstrap
+from patroni.postgresql.cancellable import CancellableSubprocess
+from patroni.postgresql.config import ConfigHandler
+from patroni.postgresql.connection import Connection, get_connection_cursor
+from patroni.postgresql.misc import parse_history, postgres_major_version_to_int
+from patroni.postgresql.postmaster import PostmasterProcess
+from patroni.postgresql.slots import SlotsHandler
+from patroni.exceptions import PostgresConnectionException
+from patroni.utils import Retry, RetryFailedError, polling_loop
+from patroni.dcs import slot_name_from_member_name, RemoteMember
+from threading import current_thread, Lock
+
+
+logger = logging.getLogger(__name__)
+
+ACTION_ON_START = "on_start"
+ACTION_ON_STOP = "on_stop"
+ACTION_ON_RESTART = "on_restart"
+ACTION_ON_RELOAD = "on_reload"
+ACTION_ON_ROLE_CHANGE = "on_role_change"
+ACTION_NOOP = "noop"
+
+STATE_RUNNING = 'running'
+STATE_REJECT = 'rejecting connections'
+STATE_NO_RESPONSE = 'not responding'
+STATE_UNKNOWN = 'unknown'
+
+STOP_POLLING_INTERVAL = 1
+
+cluster_info_query = ("SELECT CASE WHEN pg_catalog.pg_is_in_recovery() THEN 0 "
+                      "ELSE ('x' || pg_catalog.substr(pg_catalog.pg_{0}file_name("
+                      "pg_catalog.pg_current_{0}_{1}()), 1, 8))::bit(32)::int END, "
+                      "CASE WHEN pg_catalog.pg_is_in_recovery() THEN GREATEST("
+                      " pg_catalog.pg_{0}_{1}_diff(COALESCE("
+                      "pg_catalog.pg_last_{0}_receive_{1}(), '0/0'), '0/0')::bigint,"
+                      " pg_catalog.pg_{0}_{1}_diff(pg_catalog.pg_last_{0}_replay_{1}(), '0/0')::bigint)"
+                      "ELSE pg_catalog.pg_{0}_{1}_diff(pg_catalog.pg_current_{0}_{1}(), '0/0')::bigint END")
+
+
+@contextmanager
+def null_context():
+    yield
+
+
+class Postgresql(object):
+
+    def __init__(self, config):
+        self.name = config['name']
+        self.scope = config['scope']
+        self._data_dir = config['data_dir']
+        self._database = config.get('database', 'postgres')
+        self._version_file = os.path.join(self._data_dir, 'PG_VERSION')
+        self._major_version = self.get_major_version()
+
+        self._state_lock = Lock()
+        self.set_state('stopped')
+
+        self._pending_restart = False
+        self._connection = Connection()
+        self.config = ConfigHandler(self, config)
+
+        self._bin_dir = config.get('bin_dir') or ''
+        self.bootstrap = Bootstrap(self)
+        self.bootstrapping = False
+        self.__thread_ident = current_thread().ident
+
+        self.slots_handler = SlotsHandler(self)
+
+        self._pgpass = config.get('pgpass') or os.path.join(os.path.expanduser('~'), 'pgpass')
+        self._callback_executor = CallbackExecutor()
+        self.__cb_called = False
+        self.__cb_pending = None
+
+        self.cancellable = CancellableSubprocess()
+
+        self._sysid = None
+        self.retry = Retry(max_tries=-1, deadline=config['retry_timeout']/2.0, max_delay=1,
+                           retry_exceptions=PostgresConnectionException)
+
+        # Retry 'pg_is_in_recovery()' only once
+        self._is_leader_retry = Retry(max_tries=1, deadline=config['retry_timeout']/2.0, max_delay=1,
+                                      retry_exceptions=PostgresConnectionException)
+
+        self._role_lock = Lock()
+        self.set_role(self.get_postgres_role_from_data_directory())
+        self._state_entry_timestamp = None
+
+        self._cluster_info_state = {}
+        self._cached_replica_timeline = None
+
+        # Last known running process
+        self._postmaster_proc = None
+
+        if self.is_running():
+            self.set_state('running')
+            self.set_role('master' if self.is_leader() else 'replica')
+            self.config.write_postgresql_conf()  # we are "joining" already running postgres
+            hba_saved = self.config.replace_pg_hba()
+            ident_saved = self.config.replace_pg_ident()
+            if hba_saved or ident_saved:
+                self.reload()
+        elif self.role == 'master':
+            self.set_role('demoted')
+
+    @property
+    def create_replica_methods(self):
+        return self.config.get('create_replica_methods', []) or self.config.get('create_replica_method', [])
+
+    @property
+    def major_version(self):
+        return self._major_version
+
+    @property
+    def database(self):
+        return self._database
+
+    @property
+    def data_dir(self):
+        return self._data_dir
+
+    @property
+    def callback(self):
+        return self.config.get('callbacks') or {}
+
+    @property
+    def wal_name(self):
+        return 'wal' if self._major_version >= 100000 else 'xlog'
+
+    @property
+    def lsn_name(self):
+        return 'lsn' if self._major_version >= 100000 else 'location'
+
+    def _version_file_exists(self):
+        return not self.data_directory_empty() and os.path.isfile(self._version_file)
+
+    def get_major_version(self):
+        if self._version_file_exists():
+            try:
+                with open(self._version_file) as f:
+                    return postgres_major_version_to_int(f.read().strip())
+            except Exception:
+                logger.exception('Failed to read PG_VERSION from %s', self._data_dir)
+        return 0
+
+    def pgcommand(self, cmd):
+        """Returns path to the specified PostgreSQL command"""
+        return os.path.join(self._bin_dir, cmd)
+
+    def pg_ctl(self, cmd, *args, **kwargs):
+        """Builds and executes pg_ctl command
+
+        :returns: `!True` when return_code == 0, otherwise `!False`"""
+
+        pg_ctl = [self.pgcommand('pg_ctl'), cmd]
+        return subprocess.call(pg_ctl + ['-D', self._data_dir] + list(args), **kwargs) == 0
+
+    def pg_isready(self):
+        """Runs pg_isready to see if PostgreSQL is accepting connections.
+
+        :returns: 'ok' if PostgreSQL is up, 'reject' if starting up, 'no_resopnse' if not up."""
+
+        r = self.config.local_connect_kwargs
+        cmd = [self.pgcommand('pg_isready'), '-p', r['port'], '-d', self._database]
+
+        # Host is not set if we are connecting via default unix socket
+        if 'host' in r:
+            cmd.extend(['-h', r['host']])
+
+        # We only need the username because pg_isready does not try to authenticate
+        if 'user' in r:
+            cmd.extend(['-U', r['user']])
+
+        ret = subprocess.call(cmd)
+        return_codes = {0: STATE_RUNNING,
+                        1: STATE_REJECT,
+                        2: STATE_NO_RESPONSE,
+                        3: STATE_UNKNOWN}
+        return return_codes.get(ret, STATE_UNKNOWN)
+
+    def reload_config(self, config):
+        self.config.reload_config(config)
+        self._is_leader_retry.deadline = self.retry.deadline = config['retry_timeout']/2.0
+
+    @property
+    def pending_restart(self):
+        return self._pending_restart
+
+    def set_pending_restart(self, value):
+        self._pending_restart = value
+
+    @property
+    def sysid(self):
+        if not self._sysid and not self.bootstrapping:
+            data = self.controldata()
+            self._sysid = data.get('Database system identifier', "")
+        return self._sysid
+
+    def get_postgres_role_from_data_directory(self):
+        if self.data_directory_empty():
+            return 'uninitialized'
+        elif self.config.recovery_conf_exists():
+            return 'replica'
+        else:
+            return 'master'
+
+    @property
+    def server_version(self):
+        return self._connection.server_version
+
+    def connection(self):
+        return self._connection.get()
+
+    def set_connection_kwargs(self, kwargs):
+        self._connection.set_conn_kwargs(kwargs)
+
+    def _query(self, sql, *params):
+        """We are always using the same cursor, therefore this method is not thread-safe!!!
+        You can call it from different threads only if you are holding explicit `AsyncExecutor` lock,
+        because the main thread is always holding this lock when running HA cycle."""
+        cursor = None
+        try:
+            cursor = self._connection.cursor()
+            cursor.execute(sql, params)
+            return cursor
+        except psycopg2.Error as e:
+            if cursor and cursor.connection.closed == 0:
+                # When connected via unix socket, psycopg2 can't recoginze 'connection lost'
+                # and leaves `_cursor_holder.connection.closed == 0`, but psycopg2.OperationalError
+                # is still raised (what is correct). It doesn't make sense to continiue with existing
+                # connection and we will close it, to avoid its reuse by the `cursor` method.
+                if isinstance(e, psycopg2.OperationalError):
+                    self._connection.close()
+                else:
+                    raise e
+            if self.state == 'restarting':
+                raise RetryFailedError('cluster is being restarted')
+            raise PostgresConnectionException('connection problems')
+
+    def query(self, sql, *args, **kwargs):
+        if not kwargs.get('retry', True):
+            return self._query(sql, *args)
+        try:
+            return self.retry(self._query, sql, *args)
+        except RetryFailedError as e:
+            raise PostgresConnectionException(str(e))
+
+    def data_directory_empty(self):
+        return not os.path.exists(self._data_dir) or os.listdir(self._data_dir) == []
+
+    def write_pgpass(self, record):
+        if 'user' not in record or 'password' not in record:
+            return os.environ.copy()
+
+        with open(self._pgpass, 'w') as f:
+            if os.name != 'nt':
+                os.fchmod(f.fileno(), 0o600)
+            f.write('{host}:{port}:*:{user}:{password}\n'.format(**record))
+
+        env = os.environ.copy()
+        env['PGPASSFILE'] = self._pgpass
+        return env
+
+    def replica_method_options(self, method):
+        return deepcopy(self.config.get(method, {}))
+
+    def replica_method_can_work_without_replication_connection(self, method):
+        return method != 'basebackup' and self.replica_method_options(method).get('no_master')
+
+    def can_create_replica_without_replication_connection(self, replica_methods=None):
+        """ go through the replication methods to see if there are ones
+            that does not require a working replication connection.
+        """
+        if replica_methods is None:
+            replica_methods = self.create_replica_methods
+        return any(self.replica_method_can_work_without_replication_connection(m) for m in replica_methods)
+
+    def reset_cluster_info_state(self):
+        self._cluster_info_state = {}
+
+    def _cluster_info_state_get(self, name):
+        if not self._cluster_info_state:
+            stmt = cluster_info_query.format(self.wal_name, self.lsn_name)
+            try:
+                result = self._is_leader_retry(self._query, stmt).fetchone()
+                self._cluster_info_state = dict(zip(['timeline', 'wal_position'], result))
+            except RetryFailedError as e:  # SELECT failed two times
+                self._cluster_info_state = {'error': str(e)}
+                if not self.is_starting() and self.pg_isready() == STATE_REJECT:
+                    self.set_state('starting')
+
+        if 'error' in self._cluster_info_state:
+            raise PostgresConnectionException(self._cluster_info_state['error'])
+
+        return self._cluster_info_state.get(name)
+
+    def is_leader(self):
+        return bool(self._cluster_info_state_get('timeline'))
+
+    def is_running(self):
+        """Returns PostmasterProcess if one is running on the data directory or None. If most recently seen process
+        is running updates the cached process based on pid file."""
+        if self._postmaster_proc:
+            if self._postmaster_proc.is_running():
+                return self._postmaster_proc
+            self._postmaster_proc = None
+
+        # we noticed that postgres was restarted, force syncing of replication
+        self.slots_handler.schedule()
+
+        self._postmaster_proc = PostmasterProcess.from_pidfile(self._data_dir)
+        return self._postmaster_proc
+
+    @property
+    def cb_called(self):
+        return self.__cb_called
+
+    def call_nowait(self, cb_name):
+        """ pick a callback command and call it without waiting for it to finish """
+        if self.bootstrapping:
+            return
+        if cb_name in (ACTION_ON_START, ACTION_ON_STOP, ACTION_ON_RESTART, ACTION_ON_ROLE_CHANGE):
+            self.__cb_called = True
+
+        if self.callback and cb_name in self.callback:
+            cmd = self.callback[cb_name]
+            try:
+                cmd = shlex.split(self.callback[cb_name]) + [cb_name, self.role, self.scope]
+                self._callback_executor.call(cmd)
+            except Exception:
+                logger.exception('callback %s %s %s %s failed', cmd, cb_name, self.role, self.scope)
+
+    @property
+    def role(self):
+        with self._role_lock:
+            return self._role
+
+    def set_role(self, value):
+        with self._role_lock:
+            self._role = value
+
+    @property
+    def state(self):
+        with self._state_lock:
+            return self._state
+
+    def set_state(self, value):
+        with self._state_lock:
+            self._state = value
+            self._state_entry_timestamp = time.time()
+
+    def time_in_state(self):
+        return time.time() - self._state_entry_timestamp
+
+    def is_starting(self):
+        return self.state == 'starting'
+
+    def wait_for_port_open(self, postmaster, timeout):
+        """Waits until PostgreSQL opens ports."""
+        for _ in polling_loop(timeout):
+            if self.cancellable.is_cancelled:
+                return False
+
+            if not postmaster.is_running():
+                logger.error('postmaster is not running')
+                self.set_state('start failed')
+                return False
+
+            isready = self.pg_isready()
+            if isready != STATE_NO_RESPONSE:
+                if isready not in [STATE_REJECT, STATE_RUNNING]:
+                    logger.warning("Can't determine PostgreSQL startup status, assuming running")
+                return True
+
+        logger.warning("Timed out waiting for PostgreSQL to start")
+        return False
+
+    def start(self, timeout=None, task=None, block_callbacks=False, role=None):
+        """Start PostgreSQL
+
+        Waits for postmaster to open ports or terminate so pg_isready can be used to check startup completion
+        or failure.
+
+        :returns: True if start was initiated and postmaster ports are open, False if start failed"""
+        # make sure we close all connections established against
+        # the former node, otherwise, we might get a stalled one
+        # after kill -9, which would report incorrect data to
+        # patroni.
+        self._connection.close()
+
+        if self.is_running():
+            logger.error('Cannot start PostgreSQL because one is already running.')
+            self.set_state('starting')
+            return True
+
+        if not block_callbacks:
+            self.__cb_pending = ACTION_ON_START
+
+        self.set_role(role or self.get_postgres_role_from_data_directory())
+
+        self.set_state('starting')
+        self._pending_restart = False
+
+        configuration = self.config.effective_configuration
+        self.config.write_postgresql_conf(configuration)
+        self.config.resolve_connection_addresses()
+        self.config.replace_pg_hba()
+        self.config.replace_pg_ident()
+
+        options = ['--{0}={1}'.format(p, configuration[p]) for p in self.config.CMDLINE_OPTIONS
+                   if p in configuration and p != 'wal_keep_segments']
+
+        if self.cancellable.is_cancelled:
+            return False
+
+        with task or null_context():
+            if task and task.is_cancelled:
+                logger.info("PostgreSQL start cancelled.")
+                return False
+
+            self._postmaster_proc = PostmasterProcess.start(self.pgcommand('postgres'),
+                                                            self._data_dir,
+                                                            self.config.postgresql_conf,
+                                                            options)
+
+            if task:
+                task.complete(self._postmaster_proc)
+
+        start_timeout = timeout
+        if not start_timeout:
+            try:
+                start_timeout = float(self.config.get('pg_ctl_timeout', 60))
+            except ValueError:
+                start_timeout = 60
+
+        # We want postmaster to open ports before we continue
+        if not self._postmaster_proc or not self.wait_for_port_open(self._postmaster_proc, start_timeout):
+            return False
+
+        ret = self.wait_for_startup(start_timeout)
+        if ret is not None:
+            return ret
+        elif timeout is not None:
+            return False
+        else:
+            return None
+
+    def checkpoint(self, connect_kwargs=None):
+        check_not_is_in_recovery = connect_kwargs is not None
+        connect_kwargs = connect_kwargs or self.config.local_connect_kwargs
+        for p in ['connect_timeout', 'options']:
+            connect_kwargs.pop(p, None)
+        try:
+            with get_connection_cursor(**connect_kwargs) as cur:
+                cur.execute("SET statement_timeout = 0")
+                if check_not_is_in_recovery:
+                    cur.execute('SELECT pg_catalog.pg_is_in_recovery()')
+                    if cur.fetchone()[0]:
+                        return 'is_in_recovery=true'
+                return cur.execute('CHECKPOINT')
+        except psycopg2.Error:
+            logger.exception('Exception during CHECKPOINT')
+            return 'not accessible or not healty'
+
+    def stop(self, mode='fast', block_callbacks=False, checkpoint=None, on_safepoint=None):
+        """Stop PostgreSQL
+
+        Supports a callback when a safepoint is reached. A safepoint is when no user backend can return a successful
+        commit to users. Currently this means we wait for user backends to close. But in the future alternate mechanisms
+        could be added.
+
+        :param on_safepoint: This callback is called when no user backends are running.
+        """
+        if checkpoint is None:
+            checkpoint = False if mode == 'immediate' else True
+
+        success, pg_signaled = self._do_stop(mode, block_callbacks, checkpoint, on_safepoint)
+        if success:
+            # block_callbacks is used during restart to avoid
+            # running start/stop callbacks in addition to restart ones
+            if not block_callbacks:
+                self.set_state('stopped')
+                if pg_signaled:
+                    self.call_nowait(ACTION_ON_STOP)
+        else:
+            logger.warning('pg_ctl stop failed')
+            self.set_state('stop failed')
+        return success
+
+    def _do_stop(self, mode, block_callbacks, checkpoint, on_safepoint):
+        postmaster = self.is_running()
+        if not postmaster:
+            if on_safepoint:
+                on_safepoint()
+            return True, False
+
+        if checkpoint and not self.is_starting():
+            self.checkpoint()
+
+        if not block_callbacks:
+            self.set_state('stopping')
+
+        # Send signal to postmaster to stop
+        success = postmaster.signal_stop(mode)
+        if success is not None:
+            if success and on_safepoint:
+                on_safepoint()
+            return success, True
+
+        # We can skip safepoint detection if we don't have a callback
+        if on_safepoint:
+            # Wait for our connection to terminate so we can be sure that no new connections are being initiated
+            self._wait_for_connection_close(postmaster)
+            postmaster.wait_for_user_backends_to_close()
+            on_safepoint()
+
+        postmaster.wait()
+
+        return True, True
+
+    @staticmethod
+    def terminate_starting_postmaster(postmaster):
+        """Terminates a postmaster that has not yet opened ports or possibly even written a pid file. Blocks
+        until the process goes away."""
+        postmaster.signal_stop('immediate')
+        postmaster.wait()
+
+    def _wait_for_connection_close(self, postmaster):
+        try:
+            with self.connection().cursor() as cur:
+                while postmaster.is_running():  # Need a timeout here?
+                    cur.execute("SELECT 1")
+                    time.sleep(STOP_POLLING_INTERVAL)
+        except psycopg2.Error:
+            pass
+
+    def reload(self):
+        ret = self.pg_ctl('reload')
+        if ret:
+            self.call_nowait(ACTION_ON_RELOAD)
+        return ret
+
+    def check_for_startup(self):
+        """Checks PostgreSQL status and returns if PostgreSQL is in the middle of startup."""
+        return self.is_starting() and not self.check_startup_state_changed()
+
+    def check_startup_state_changed(self):
+        """Checks if PostgreSQL has completed starting up or failed or still starting.
+
+        Should only be called when state == 'starting'
+
+        :returns: True if state was changed from 'starting'
+        """
+        ready = self.pg_isready()
+
+        if ready == STATE_REJECT:
+            return False
+        elif ready == STATE_NO_RESPONSE:
+            self.set_state('start failed')
+            self.slots_handler.schedule(False)  # TODO: can remove this?
+            self.config.save_configuration_files(True)  # TODO: maybe remove this?
+            return True
+        else:
+            if ready != STATE_RUNNING:
+                # Bad configuration or unexpected OS error. No idea of PostgreSQL status.
+                # Let the main loop of run cycle clean up the mess.
+                logger.warning("%s status returned from pg_isready",
+                               "Unknown" if ready == STATE_UNKNOWN else "Invalid")
+            self.set_state('running')
+            self.slots_handler.schedule()
+            self.config.save_configuration_files(True)
+            # TODO: __cb_pending can be None here after PostgreSQL restarts on its own. Do we want to call the callback?
+            # Previously we didn't even notice.
+            action = self.__cb_pending or ACTION_ON_START
+            self.call_nowait(action)
+            self.__cb_pending = None
+
+            return True
+
+    def wait_for_startup(self, timeout=None):
+        """Waits for PostgreSQL startup to complete or fail.
+
+        :returns: True if start was successful, False otherwise"""
+        if not self.is_starting():
+            # Should not happen
+            logger.warning("wait_for_startup() called when not in starting state")
+
+        while not self.check_startup_state_changed():
+            if self.cancellable.is_cancelled or timeout and self.time_in_state() > timeout:
+                return None
+            time.sleep(1)
+
+        return self.state == 'running'
+
+    def restart(self, timeout=None, task=None, block_callbacks=False, role=None):
+        """Restarts PostgreSQL.
+
+        When timeout parameter is set the call will block either until PostgreSQL has started, failed to start or
+        timeout arrives.
+
+        :returns: True when restart was successful and timeout did not expire when waiting.
+        """
+        self.set_state('restarting')
+        if not block_callbacks:
+            self.__cb_pending = ACTION_ON_RESTART
+        ret = self.stop(block_callbacks=True) and self.start(timeout, task, True, role)
+        if not ret and not self.is_starting():
+            self.set_state('restart failed ({0})'.format(self.state))
+        return ret
+
+    def is_healthy(self):
+        if not self.is_running():
+            logger.warning('Postgresql is not running.')
+            return False
+        return True
+
+    def controldata(self):
+        """ return the contents of pg_controldata, or non-True value if pg_controldata call failed """
+        result = {}
+        # Don't try to call pg_controldata during backup restore
+        if self._version_file_exists() and self.state != 'creating replica':
+            try:
+                env = {'LANG': 'C', 'LC_ALL': 'C', 'PATH': os.getenv('PATH')}
+                if os.getenv('SYSTEMROOT') is not None:
+                    env['SYSTEMROOT'] = os.getenv('SYSTEMROOT')
+                data = subprocess.check_output([self.pgcommand('pg_controldata'), self._data_dir], env=env)
+                if data:
+                    data = data.decode('utf-8').splitlines()
+                    # pg_controldata output depends on major verion. Some of parameters are prefixed by 'Current '
+                    result = {l.split(':')[0].replace('Current ', '', 1): l.split(':', 1)[1].strip() for l in data
+                              if l and ':' in l}
+            except subprocess.CalledProcessError:
+                logger.exception("Error when calling pg_controldata")
+        return result
+
+    @contextmanager
+    def get_replication_connection_cursor(self, host='localhost', port=5432, database=None, **kwargs):
+        replication = self.config.replication
+        with get_connection_cursor(host=host, port=int(port), database=database or self._database, replication=1,
+                                   user=replication['username'], password=replication.get('password'),
+                                   connect_timeout=3, options='-c statement_timeout=2000') as cur:
+            yield cur
+
+    def get_local_timeline_lsn_from_replication_connection(self):
+        timeline = lsn = None
+        try:
+            with self.get_replication_connection_cursor(**self.config.local_replication_address) as cur:
+                cur.execute('IDENTIFY_SYSTEM')
+                timeline, lsn = cur.fetchone()[1:3]
+        except Exception:
+            logger.exception('Can not fetch local timeline and lsn from replication connection')
+        return timeline, lsn
+
+    def get_replica_timeline(self):
+        return self.get_local_timeline_lsn_from_replication_connection()[0]
+
+    def replica_cached_timeline(self, master_timeline):
+        if not self._cached_replica_timeline or not master_timeline or self._cached_replica_timeline != master_timeline:
+            self._cached_replica_timeline = self.get_replica_timeline()
+        return self._cached_replica_timeline
+
+    def get_master_timeline(self):
+        return self._cluster_info_state_get('timeline')
+
+    def get_history(self, timeline):
+        history_path = 'pg_{0}/{1:08X}.history'.format(self.wal_name, timeline)
+        try:
+            cursor = self._connection.cursor()
+            cursor.execute('SELECT isdir, modification FROM pg_catalog.pg_stat_file(%s)', (history_path,))
+            isdir, modification = cursor.fetchone()
+            if not isdir:
+                cursor.execute('SELECT pg_catalog.pg_read_file(%s)', (history_path,))
+                history = list(parse_history(cursor.fetchone()[0]))
+                if history[-1][0] == timeline - 1:
+                    history[-1].append(modification.isoformat())
+                return history
+        except Exception:
+            logger.exception('Failed to read and parse %s', (history_path,))
+
+    def follow(self, member, role='replica', timeout=None):
+        is_remote_master = isinstance(member, RemoteMember)
+        no_replication_slot = is_remote_master and member.no_replication_slot
+        restore_command = is_remote_master and member.restore_command
+        min_apply_delay = is_remote_master and member.recovery_min_apply_delay
+        archive_cleanup = is_remote_master and member.archive_cleanup_command
+
+        primary_conninfo = self.config.primary_conninfo(member)
+        change_role = self.cb_called and (self.role in ('master', 'demoted') or
+                                          not {'standby_leader', 'replica'} - {self.role, role})
+
+        recovery_params = self.config.get('recovery_conf', {}).copy()
+        recovery_params.update({'standby_mode': 'on', 'recovery_target_timeline': 'latest'})
+        if primary_conninfo:
+            recovery_params['primary_conninfo'] = primary_conninfo
+        if self.slots_handler.use_slots and not no_replication_slot:
+            required_name = is_remote_master and member.data.get('primary_slot_name')
+            name = required_name or slot_name_from_member_name(self.name)
+            recovery_params['primary_slot_name'] = name
+        if restore_command:
+            recovery_params['restore_command'] = restore_command
+        if min_apply_delay:
+            recovery_params['recovery_min_apply_delay'] = min_apply_delay
+        if archive_cleanup:
+            recovery_params['archive_cleanup_command'] = archive_cleanup
+
+        self.config.write_recovery_conf(recovery_params)
+
+        # When we demoting the master or standby_leader to replica or promoting replica to a standby_leader
+        # and we know for sure that postgres was already running before, we will only execute on_role_change
+        # callback and prevent execution of on_restart/on_start callback.
+        # If the role remains the same (replica or standby_leader), we will execute on_start or on_restart
+        if change_role:
+            self.__cb_pending = ACTION_NOOP
+
+        if self.is_running():
+            self.restart(block_callbacks=change_role, role=role)
+        else:
+            self.start(timeout=timeout, block_callbacks=change_role, role=role)
+
+        if change_role:
+            # TODO: postpone this until start completes, or maybe do even earlier
+            self.call_nowait(ACTION_ON_ROLE_CHANGE)
+        return True
+
+    def _wait_promote(self, wait_seconds):
+        for _ in polling_loop(wait_seconds):
+            data = self.controldata()
+            if data.get('Database cluster state') == 'in production':
+                return True
+
+    def promote(self, wait_seconds, on_success=None, access_is_restricted=False):
+        if self.role == 'master':
+            return True
+        ret = self.pg_ctl('promote', '-W')
+        if ret:
+            self.set_role('master')
+            if on_success is not None:
+                on_success()
+            if not access_is_restricted:
+                self.call_nowait(ACTION_ON_ROLE_CHANGE)
+            ret = self._wait_promote(wait_seconds)
+        return ret
+
+    def timeline_wal_position(self):
+        # This method could be called from different threads (simultaneously with some other `_query` calls).
+        # If it is called not from main thread we will create a new cursor to execute statement.
+        if current_thread().ident == self.__thread_ident:
+            return self._cluster_info_state_get('timeline'), self._cluster_info_state_get('wal_position')
+
+        with self.connection().cursor() as cursor:
+            cursor.execute(cluster_info_query.format(self.wal_name, self.lsn_name))
+            return cursor.fetchone()[:2]
+
+    def postmaster_start_time(self):
+        try:
+            cursor = self.query("SELECT pg_catalog.to_char(pg_catalog.pg_postmaster_start_time(),"
+                                " 'YYYY-MM-DD HH24:MI:SS.MS TZ')")
+            return cursor.fetchone()[0]
+        except psycopg2.Error:
+            return None
+
+    def last_operation(self):
+        return str(self._cluster_info_state_get('wal_position'))
+
+    def configure_server_parameters(self):
+        self._major_version = self.get_major_version()
+        self.config.setup_server_parameters()
+        return True
+
+    def move_data_directory(self):
+        if os.path.isdir(self._data_dir) and not self.is_running():
+            try:
+                new_name = '{0}_{1}'.format(self._data_dir, time.strftime('%Y-%m-%d-%H-%M-%S'))
+                logger.info('renaming data directory to %s', new_name)
+                os.rename(self._data_dir, new_name)
+            except OSError:
+                logger.exception("Could not rename data directory %s", self._data_dir)
+
+    def remove_data_directory(self):
+        self.set_role('uninitialized')
+        logger.info('Removing data directory: %s', self._data_dir)
+        try:
+            if os.path.islink(self._data_dir):
+                os.unlink(self._data_dir)
+            elif not os.path.exists(self._data_dir):
+                return
+            elif os.path.isfile(self._data_dir):
+                os.remove(self._data_dir)
+            elif os.path.isdir(self._data_dir):
+
+                # let's see if pg_xlog|pg_wal is a symlink, in this case we
+                # should clean the target
+                for pg_wal_dir in ('pg_xlog', 'pg_wal'):
+                    pg_wal_path = os.path.join(self._data_dir, pg_wal_dir)
+                    if os.path.exists(pg_wal_path) and os.path.islink(pg_wal_path):
+                        pg_wal_realpath = os.path.realpath(pg_wal_path)
+                        logger.info('Removing WAL directory: %s', pg_wal_realpath)
+                        shutil.rmtree(pg_wal_realpath)
+
+                shutil.rmtree(self._data_dir)
+        except (IOError, OSError):
+            logger.exception('Could not remove data directory %s', self._data_dir)
+            self.move_data_directory()
+
+    def pick_synchronous_standby(self, cluster):
+        """Finds the best candidate to be the synchronous standby.
+
+        Current synchronous standby is always preferred, unless it has disconnected or does not want to be a
+        synchronous standby any longer.
+
+        :returns tuple of candidate name or None, and bool showing if the member is the active synchronous standby.
+        """
+        current = cluster.sync.sync_standby
+        current = current.lower() if current else current
+        members = {m.name.lower(): m for m in cluster.members}
+        candidates = []
+        # Pick candidates based on who has flushed WAL farthest.
+        # TODO: for synchronous_commit = remote_write we actually want to order on write_location
+        for app_name, state, sync_state in self.query(
+                "SELECT pg_catalog.lower(application_name), state, sync_state"
+                " FROM pg_catalog.pg_stat_replication"
+                " ORDER BY flush_{0} DESC".format(self.lsn_name)):
+            member = members.get(app_name)
+            if state != 'streaming' or not member or member.tags.get('nosync', False):
+                continue
+            if sync_state == 'sync':
+                return app_name, True
+            if sync_state == 'potential' and app_name == current:
+                # Prefer current even if not the best one any more to avoid indecisivness and spurious swaps.
+                return current, False
+            if sync_state in ('async', 'potential'):
+                candidates.append(app_name)
+
+        if candidates:
+            return candidates[0], False
+        return None, False
+
+    def read_postmaster_opts(self):
+        """returns the list of option names/values from postgres.opts, Empty dict if read failed or no file"""
+        result = {}
+        try:
+            with open(os.path.join(self._data_dir, 'postmaster.opts')) as f:
+                data = f.read()
+                for opt in data.split('" "'):
+                    if '=' in opt and opt.startswith('--'):
+                        name, val = opt.split('=', 1)
+                        result[name.strip('-')] = val.rstrip('"\n')
+        except IOError:
+            logger.exception('Error when reading postmaster.opts')
+        return result
+
+    def single_user_mode(self, command=None, options=None):
+        """run a given command in a single-user mode. If the command is empty - then just start and stop"""
+        cmd = [self.pgcommand('postgres'), '--single', '-D', self._data_dir]
+        for opt, val in sorted((options or {}).items()):
+            cmd.extend(['-c', '{0}={1}'.format(opt, val)])
+        # need a database name to connect
+        cmd.append(self._database)
+        return self.cancellable.call(cmd, communicate_input=command)
+
+    def cleanup_archive_status(self):
+        status_dir = os.path.join(self._data_dir, 'pg_' + self.wal_name, 'archive_status')
+        try:
+            for f in os.listdir(status_dir):
+                path = os.path.join(status_dir, f)
+                try:
+                    if os.path.islink(path):
+                        os.unlink(path)
+                    elif os.path.isfile(path):
+                        os.remove(path)
+                except OSError:
+                    logger.exception('Unable to remove %s', path)
+        except OSError:
+            logger.exception('Unable to list %s', status_dir)
+
+    def fix_cluster_state(self):
+        self.cleanup_archive_status()
+
+        # Start in a single user mode and stop to produce a clean shutdown
+        opts = self.read_postmaster_opts()
+        opts.update({'archive_mode': 'on', 'archive_command': 'false'})
+        self.config.remove_recovery_conf()
+        return self.single_user_mode(options=opts) == 0 or None
+
+    def schedule_sanity_checks_after_pause(self):
+        """
+            After coming out of pause we have to:
+            1. sync replication slots, because it might happen that slots were removed
+            2. get new 'Database system identifier' to make sure that it wasn't changed
+        """
+        self.slots_handler.schedule()
+        self._sysid = None
@@ -0,0 +1,381 @@
+import logging
+import os
+import shlex
+import tempfile
+import time
+
+from patroni.dcs import RemoteMember
+from patroni.utils import deep_compare, uri
+from six import string_types
+from six.moves.urllib.parse import quote_plus
+
+logger = logging.getLogger(__name__)
+
+
+class Bootstrap(object):
+
+    def __init__(self, postgresql):
+        self._postgresql = postgresql
+        self._running_custom_bootstrap = False
+
+    @property
+    def running_custom_bootstrap(self):
+        return self._running_custom_bootstrap
+
+    @property
+    def keep_existing_recovery_conf(self):
+        return self._running_custom_bootstrap and self._keep_existing_recovery_conf
+
+    @staticmethod
+    def process_user_options(tool, options, not_allowed_options, error_handler):
+        user_options = []
+
+        def option_is_allowed(name):
+            ret = name not in not_allowed_options
+            if not ret:
+                error_handler('{0} option for {1} is not allowed'.format(name, tool))
+            return ret
+
+        if isinstance(options, dict):
+            for k, v in options.items():
+                if k and v:
+                    user_options.append('--{0}={1}'.format(k, v))
+        elif isinstance(options, list):
+            for opt in options:
+                if isinstance(opt, string_types) and option_is_allowed(opt):
+                    user_options.append('--{0}'.format(opt))
+                elif isinstance(opt, dict):
+                    keys = list(opt.keys())
+                    if len(keys) != 1 or not isinstance(opt[keys[0]], string_types) or not option_is_allowed(keys[0]):
+                        error_handler('Error when parsing {0} key-value option {1}: only one key-value is allowed'
+                                      ' and value should be a string'.format(tool, opt[keys[0]]))
+                    user_options.append('--{0}={1}'.format(keys[0], opt[keys[0]]))
+                else:
+                    error_handler('Error when parsing {0} option {1}: value should be string value'
+                                  ' or a single key-value pair'.format(tool, opt))
+        else:
+            error_handler('{0} options must be list ot dict'.format(tool))
+        return user_options
+
+    def _initdb(self, config):
+        self._postgresql.set_state('initalizing new cluster')
+        not_allowed_options = ('pgdata', 'nosync', 'pwfile', 'sync-only', 'version')
+
+        def error_handler(e):
+            raise Exception(e)
+
+        options = self.process_user_options('initdb', config or [], not_allowed_options, error_handler)
+        pwfile = None
+
+        if self._postgresql.config.superuser:
+            if 'username' in self._postgresql.config.superuser:
+                options.append('--username={0}'.format(self._postgresql.config.superuser['username']))
+            if 'password' in self._postgresql.config.superuser:
+                (fd, pwfile) = tempfile.mkstemp()
+                os.write(fd, self._postgresql.config.superuser['password'].encode('utf-8'))
+                os.close(fd)
+                options.append('--pwfile={0}'.format(pwfile))
+        options = ['-o', ' '.join(options)] if options else []
+
+        ret = self._postgresql.pg_ctl('initdb', *options)
+        if pwfile:
+            os.remove(pwfile)
+        if ret:
+            self._postgresql.configure_server_parameters()
+        else:
+            self._postgresql.set_state('initdb failed')
+        return ret
+
+    def _post_restore(self):
+        self._postgresql.config.restore_configuration_files()
+        self._postgresql.configure_server_parameters()
+
+        # make sure there is no trigger file or postgres will be automatically promoted
+        trigger_file = 'promote_trigger_file' if self._postgresql.major_version >= 120000 else 'trigger_file'
+        trigger_file = self._postgresql.config.get('recovery_conf', {}).get(trigger_file) or 'promote'
+        trigger_file = os.path.abspath(os.path.join(self._postgresql.data_dir, trigger_file))
+        if os.path.exists(trigger_file):
+            os.unlink(trigger_file)
+
+    def _custom_bootstrap(self, config):
+        self._postgresql.set_state('running custom bootstrap script')
+        params = ['--scope=' + self._postgresql.scope, '--datadir=' + self._postgresql.data_dir]
+        try:
+            logger.info('Running custom bootstrap script: %s', config['command'])
+            if self._postgresql.cancellable.call(shlex.split(config['command']) + params) != 0:
+                self._postgresql.set_state('custom bootstrap failed')
+                return False
+        except Exception:
+            logger.exception('Exception during custom bootstrap')
+            return False
+        self._post_restore()
+
+        if 'recovery_conf' in config:
+            self._postgresql.config.write_recovery_conf(config['recovery_conf'])
+        elif not self.keep_existing_recovery_conf:
+            self._postgresql.config.remove_recovery_conf()
+        return True
+
+    def call_post_bootstrap(self, config):
+        """
+        runs a script after initdb or custom bootstrap script is called and waits until completion.
+        """
+        cmd = config.get('post_bootstrap') or config.get('post_init')
+        if cmd:
+            r = self._postgresql.config.local_connect_kwargs
+
+            if 'host' in r:
+                # '/tmp' => '%2Ftmp' for unix socket path
+                host = quote_plus(r['host']) if r['host'].startswith('/') else r['host']
+            else:
+                host = ''
+
+                # https://www.postgresql.org/docs/current/static/libpq-pgpass.html
+                # A host name of localhost matches both TCP (host name localhost) and Unix domain socket
+                # (pghost empty or the default socket directory) connections coming from the local machine.
+                r['host'] = 'localhost'  # set it to localhost to write into pgpass
+
+            if 'user' in r:
+                user = r['user']
+            else:
+                user = ''
+                if 'password' in r:
+                    import getpass
+                    r.setdefault('user', os.environ.get('PGUSER', getpass.getuser()))
+
+            connstring = uri('postgres', (host, r['port']), r['database'], user)
+            env = self._postgresql.write_pgpass(r) if 'password' in r else None
+
+            try:
+                ret = self._postgresql.cancellable.call(shlex.split(cmd) + [connstring], env=env)
+            except OSError:
+                logger.error('post_init script %s failed', cmd)
+                return False
+            if ret != 0:
+                logger.error('post_init script %s returned non-zero code %d', cmd, ret)
+                return False
+        return True
+
+    def create_replica(self, clone_member):
+        """
+            create the replica according to the replica_method
+            defined by the user.  this is a list, so we need to
+            loop through all methods the user supplies
+        """
+
+        self._postgresql.set_state('creating replica')
+        self._postgresql.schedule_sanity_checks_after_pause()
+
+        is_remote_master = isinstance(clone_member, RemoteMember)
+
+        # get list of replica methods either from clone member or from
+        # the config. If there is no configuration key, or no value is
+        # specified, use basebackup
+        replica_methods = (clone_member.create_replica_methods if is_remote_master
+                           else self._postgresql.create_replica_methods) or ['basebackup']
+
+        if clone_member and clone_member.conn_url:
+            r = clone_member.conn_kwargs(self._postgresql.config.replication)
+            connstring = uri('postgres', (r['host'], r['port']), r['database'], r['user'])
+            # add the credentials to connect to the replica origin to pgpass.
+            env = self._postgresql.write_pgpass(r)
+        else:
+            connstring = ''
+            env = os.environ.copy()
+            # if we don't have any source, leave only replica methods that work without it
+            replica_methods = [r for r in replica_methods
+                               if self._postgresql.replica_method_can_work_without_replication_connection(r)]
+
+        # go through them in priority order
+        ret = 1
+        for replica_method in replica_methods:
+            if self._postgresql.cancellable.is_cancelled:
+                break
+
+            method_config = self._postgresql.replica_method_options(replica_method)
+
+            # if the method is basebackup, then use the built-in
+            if replica_method == "basebackup":
+                ret = self.basebackup(connstring, env, method_config)
+                if ret == 0:
+                    logger.info("replica has been created using basebackup")
+                    # if basebackup succeeds, exit with success
+                    break
+            else:
+                if not self._postgresql.data_directory_empty():
+                    if method_config.get('keep_data', False):
+                        logger.info('Leaving data directory uncleaned')
+                    else:
+                        self._postgresql.remove_data_directory()
+
+                cmd = replica_method
+                # user-defined method; check for configuration
+                # not required, actually
+                if method_config:
+                    # look to see if the user has supplied a full command path
+                    # if not, use the method name as the command
+                    cmd = method_config.pop('command', cmd)
+
+                # add the default parameters
+                if not method_config.get('no_params', False):
+                    method_config.update({"scope": self._postgresql.scope,
+                                          "role": "replica",
+                                          "datadir": self._postgresql.data_dir,
+                                          "connstring": connstring})
+                else:
+                    for param in ('no_params', 'no_master', 'keep_data'):
+                        method_config.pop(param, None)
+                params = ["--{0}={1}".format(arg, val) for arg, val in method_config.items()]
+                try:
+                    # call script with the full set of parameters
+                    ret = self._postgresql.cancellable.call(shlex.split(cmd) + params, env=env)
+                    # if we succeeded, stop
+                    if ret == 0:
+                        logger.info('replica has been created using %s', replica_method)
+                        break
+                    else:
+                        logger.error('Error creating replica using method %s: %s exited with code=%s',
+                                     replica_method, cmd, ret)
+                except Exception:
+                    logger.exception('Error creating replica using method %s', replica_method)
+                    ret = 1
+
+        self._postgresql.set_state('stopped')
+        return ret
+
+    def basebackup(self, conn_url, env, options):
+        # creates a replica data dir using pg_basebackup.
+        # this is the default, built-in create_replica_methods
+        # tries twice, then returns failure (as 1)
+        # uses "stream" as the xlog-method to avoid sync issues
+        # supports additional user-supplied options, those are not validated
+        maxfailures = 2
+        ret = 1
+        not_allowed_options = ('pgdata', 'format', 'wal-method', 'xlog-method', 'gzip',
+                               'version', 'compress', 'dbname', 'host', 'port', 'username', 'password')
+        user_options = self.process_user_options('basebackup', options, not_allowed_options, logger.error)
+
+        for bbfailures in range(0, maxfailures):
+            if self._postgresql.cancellable.is_cancelled:
+                break
+            if not self._postgresql.data_directory_empty():
+                self._postgresql.remove_data_directory()
+            try:
+                ret = self._postgresql.cancellable.call([self._postgresql.pgcommand('pg_basebackup'),
+                                                         '--pgdata=' + self._postgresql.data_dir, '-X', 'stream',
+                                                         '--dbname=' + conn_url] + user_options, env=env)
+                if ret == 0:
+                    break
+                else:
+                    logger.error('Error when fetching backup: pg_basebackup exited with code=%s', ret)
+
+            except Exception as e:
+                logger.error('Error when fetching backup with pg_basebackup: %s', e)
+
+            if bbfailures < maxfailures - 1:
+                logger.warning('Trying again in 5 seconds')
+                time.sleep(5)
+
+        return ret
+
+    def clone(self, clone_member):
+        """
+             - initialize the replica from an existing member (master or replica)
+             - initialize the replica using the replica creation method that
+               works without the replication connection (i.e. restore from on-disk
+               base backup)
+        """
+
+        ret = self.create_replica(clone_member) == 0
+        if ret:
+            self._post_restore()
+        return ret
+
+    def bootstrap(self, config):
+        """ Initialize a new node from scratch and start it. """
+        pg_hba = config.get('pg_hba', [])
+        method = config.get('method') or 'initdb'
+        if method != 'initdb' and method in config and 'command' in config[method]:
+            self._keep_existing_recovery_conf = config[method].get('keep_existing_recovery_conf')
+            self._running_custom_bootstrap = True
+            do_initialize = self._custom_bootstrap
+        else:
+            method = 'initdb'
+            do_initialize = self._initdb
+        return do_initialize(config.get(method)) and self._postgresql.config.append_pg_hba(pg_hba) \
+            and self._postgresql.config.save_configuration_files() and self._postgresql.start()
+
+    def create_or_update_role(self, name, password, options):
+        options = list(map(str.upper, options))
+        if 'NOLOGIN' not in options and 'LOGIN' not in options:
+            options.append('LOGIN')
+
+        params = [name]
+        if password:
+            options.extend(['PASSWORD', '%s'])
+            params.extend([password, password])
+
+        sql = """DO $$
+BEGIN
+    SET local synchronous_commit = 'local';
+    PERFORM * FROM pg_authid WHERE rolname = %s;
+    IF FOUND THEN
+        ALTER ROLE "{0}" WITH {1};
+    ELSE
+        CREATE ROLE "{0}" WITH {1};
+    END IF;
+END;$$""".format(name, ' '.join(options))
+        self._postgresql.query(sql, *params)
+
+    def post_bootstrap(self, config, task):
+        try:
+            postgresql = self._postgresql
+            superuser = postgresql.config.superuser
+            if 'username' in superuser and 'password' in superuser:
+                self.create_or_update_role(superuser['username'], superuser['password'], ['SUPERUSER'])
+
+            task.complete(self.call_post_bootstrap(config))
+            if task.result:
+                replication = postgresql.config.replication
+                self.create_or_update_role(replication['username'], replication.get('password'), ['REPLICATION'])
+
+                rewind = postgresql.config.rewind_credentials
+                if not deep_compare(rewind, superuser):
+                    self.create_or_update_role(rewind['username'], rewind.get('password'), [])
+                    for f in ('pg_ls_dir(text, boolean, boolean)', 'pg_stat_file(text, boolean)',
+                              'pg_read_binary_file(text)', 'pg_read_binary_file(text, bigint, bigint, boolean)'):
+                        postgresql.query('GRANT EXECUTE ON function pg_catalog.{0} TO "{1}"'
+                                         .format(f, rewind['username']))
+
+                for name, value in (config.get('users') or {}).items():
+                    if all(name != a.get('username') for a in (superuser, replication, rewind)):
+                        self.create_or_update_role(name, value.get('password'), value.get('options', []))
+
+                # We were doing a custom bootstrap instead of running initdb, therefore we opened trust
+                # access from certain addresses to be able to reach cluster and change password
+                if self._running_custom_bootstrap:
+                    self._running_custom_bootstrap = False
+                    # If we don't have custom configuration for pg_hba.conf we need to restore original file
+                    if not postgresql.config.get('pg_hba'):
+                        os.unlink(postgresql.config.pg_hba_conf)
+                        postgresql.config.restore_configuration_files()
+                    postgresql.config.write_postgresql_conf()
+                    postgresql.config.replace_pg_ident()
+
+                    # at this point there should be no recovery.conf
+                    postgresql.config.remove_recovery_conf()
+
+                    if postgresql.config.hba_file and postgresql.config.hba_file != postgresql.config.pg_hba_conf:
+                        postgresql.restart()
+                    else:
+                        postgresql.config.replace_pg_hba()
+                        if postgresql.pending_restart:
+                            postgresql.restart()
+                        else:
+                            postgresql.reload()
+                            time.sleep(1)  # give a time to postgres to "reload" configuration files
+                            postgresql.connection().close()  # close connection to reconnect with a new password
+        except Exception:
+            logger.exception('post_bootstrap')
+            task.complete(False)
+        return task.result
@@ -19,8 +19,11 @@ class CallbackExecutor(Thread):
    def call(self, cmd):
        with self._lock:
            if self._process and self._process.poll() is None:
-                self._process.kill()
-                logger.warning('Killed the old callback process because it was still running: %s', self._cmd)
+                try:
+                    self._process.kill()
+                    logger.warning('Killed the old callback process because it was still running: %s', self._cmd)
+                except OSError:
+                    logger.exception('Failed to kill the old callback')
        self._cmd = cmd
        self._callback_event.set()

@@ -0,0 +1,76 @@
+import logging
+import os
+import subprocess
+
+from patroni.exceptions import PostgresException
+from patroni.utils import polling_loop
+from six import string_types
+from threading import Lock
+
+logger = logging.getLogger(__name__)
+
+
+class CancellableSubprocess(object):
+
+    def __init__(self):
+        self._is_cancelled = False
+        self._process = None
+        self._lock = Lock()
+
+    def call(self, *args, **kwargs):
+        for s in ('stdin', 'stdout', 'stderr'):
+            kwargs.pop(s, None)
+
+        communicate_input = 'communicate_input' in kwargs
+        if communicate_input:
+            input_data = kwargs.pop('communicate_input', None)
+            if not isinstance(input_data, string_types):
+                input_data = ''
+            if input_data and input_data[-1] != '\n':
+                input_data += '\n'
+            kwargs['stdin'] = subprocess.PIPE
+            kwargs['stdout'] = open(os.devnull, 'w')
+            kwargs['stderr'] = subprocess.STDOUT
+
+        try:
+            with self._lock:
+                if self._is_cancelled:
+                    raise PostgresException('cancelled')
+
+                self._is_cancelled = False
+                self._process = subprocess.Popen(*args, **kwargs)
+
+            if communicate_input:
+                if input_data:
+                    self._process.communicate(input_data)
+                self._process.stdin.close()
+
+            return self._process.wait()
+        finally:
+            with self._lock:
+                self._process = None
+
+    def reset_is_cancelled(self):
+        with self._lock:
+            self._is_cancelled = False
+
+    @property
+    def is_cancelled(self):
+        with self._lock:
+            return self._is_cancelled
+
+    def cancel(self):
+        with self._lock:
+            self._is_cancelled = True
+            if self._process is None or self._process.returncode is not None:
+                return
+            self._process.terminate()
+
+        for _ in polling_loop(10):
+            with self._lock:
+                if self._process is None or self._process.returncode is not None:
+                    return
+
+        with self._lock:
+            if self._process is not None and self._process.returncode is None:
+                self._process.kill()
@@ -0,0 +1,763 @@
+import logging
+import os
+import re
+import shutil
+import socket
+import stat
+
+from requests.structures import CaseInsensitiveDict
+from six.moves.urllib_parse import urlparse, parse_qsl, unquote
+
+from ..utils import compare_values, parse_bool, parse_int, split_host_port, uri
+
+logger = logging.getLogger(__name__)
+
+SYNC_STANDBY_NAME_RE = re.compile(r'^[A-Za-z_][A-Za-z_0-9\$]*$')
+PARAMETER_RE = re.compile(r'([a-z_]+)\s*=\s*')
+
+
+def quote_ident(value):
+    """Very simplified version of quote_ident"""
+    return value if SYNC_STANDBY_NAME_RE.match(value) else '"' + value + '"'
+
+
+def conninfo_uri_parse(dsn):
+    ret = {}
+    r = urlparse(dsn)
+    if r.username:
+        ret['user'] = r.username
+    if r.password:
+        ret['password'] = r.password
+    if r.path[1:]:
+        ret['dbname'] = r.path[1:]
+    hosts = []
+    ports = []
+    for netloc in r.netloc.split('@')[-1].split(','):
+        host = port = None
+        if '[' in netloc and ']' in netloc:
+            host = netloc.split(']')[0][1:]
+        tmp = netloc.split(':', 1)
+        if host is None:
+            host = tmp[0]
+        if len(tmp) == 2:
+            host, port = tmp
+        if host is not None:
+            hosts.append(host)
+        if port is not None:
+            ports.append(port)
+    if hosts:
+        ret['host'] = ','.join(hosts)
+    if ports:
+        ret['port'] = ','.join(ports)
+    ret = {name: unquote(value) for name, value in ret.items()}
+    ret.update({name: value for name, value in parse_qsl(r.query)})
+    if ret.get('ssl') == 'true':
+        del ret['ssl']
+        ret['sslmode'] = 'require'
+    return ret
+
+
+def read_param_value(value, is_quoted=False):
+    length = len(value)
+    ret = ''
+    i = 0
+    while i < length:
+        if is_quoted:
+            if value[i] == "'":
+                return ret, i
+        elif value[i].isspace():
+            break
+        if value[i] == '\\':
+            i += 1
+            if i >= length:
+                break
+        ret += value[i]
+        i += 1
+    return (None, None) if is_quoted else (ret, i)
+
+
+def conninfo_parse(dsn):
+    ret = {}
+    length = len(dsn)
+    i = 0
+    while i < length:
+        if dsn[i].isspace():
+            i += 1
+            continue
+
+        param_match = PARAMETER_RE.match(dsn[i:])
+        if not param_match:
+            return
+
+        param = param_match.group(1)
+        i += param_match.end()
+
+        if i >= length:
+            return
+
+        is_quoted = dsn[i] == "'"
+        i += int(is_quoted)
+        value, end = read_param_value(dsn[i:], is_quoted)
+        if value is None:
+            return
+        i += end + int(is_quoted)
+        ret[param] = value
+    return ret
+
+
+def parse_dsn(value):
+    """
+    Very simple equivalent of `psycopg2.extensions.parse_dsn` introduced in 2.7.0.
+    We are not using psycopg2 function in order to remain compatible with 2.5.4+.
+    There is one minor difference though, this function removes `dbname` from the result
+    and sets the sslmode` to `prefer` if it is not present in the connection string.
+    This is necessary to simplify comparison of the old and the new values.
+
+    >>> r = parse_dsn('postgresql://u%2Fse:pass@:%2f123,[%2Fhost2]/db%2Fsdf?application_name=mya%2Fpp&ssl=true')
+    >>> r == {'application_name': 'mya/pp', 'host': ',/host2', 'sslmode': 'require',\
+              'password': 'pass', 'port': '/123', 'user': 'u/se'}
+    True
+    >>> r = parse_dsn(" host = 'host' dbname = db\\ name requiressl=1 ")
+    >>> r == {'host': 'host', 'sslmode': 'require'}
+    True
+    >>> parse_dsn('requiressl = 0\\\\') == {'sslmode': 'prefer'}
+    True
+    >>> parse_dsn("host=a foo = '") is None
+    True
+    >>> parse_dsn("host=a foo = ") is None
+    True
+    >>> parse_dsn("1") is None
+    True
+    """
+    if value.startswith('postgres://') or value.startswith('postgresql://'):
+        ret = conninfo_uri_parse(value)
+    else:
+        ret = conninfo_parse(value)
+
+    if ret:
+        if 'sslmode' not in ret:  # allow sslmode to take precedence over requiressl
+            requiressl = ret.pop('requiressl', None)
+            if requiressl == '1':
+                ret['sslmode'] = 'require'
+            elif requiressl is not None:
+                ret['sslmode'] = 'prefer'
+            ret.setdefault('sslmode', 'prefer')
+        if 'dbname' in ret:
+            del ret['dbname']
+    return ret
+
+
+def mtime(filename):
+    try:
+        return os.stat(filename).st_mtime
+    except OSError:
+        return None
+
+
+class ConfigHandler(object):
+
+    # List of parameters which must be always passed to postmaster as command line options
+    # to make it not possible to change them with 'ALTER SYSTEM'.
+    # Some of these parameters have sane default value assigned and Patroni doesn't allow
+    # to decrease this value. E.g. 'wal_level' can't be lower then 'hot_standby' and so on.
+    # These parameters could be changed only globally, i.e. via DCS.
+    # P.S. 'listen_addresses' and 'port' are added here just for convenience, to mark them
+    # as a parameters which should always be passed through command line.
+    #
+    # Format:
+    #  key - parameter name
+    #  value - tuple(default_value, check_function, min_version)
+    #    default_value -- some sane default value
+    #    check_function -- if the new value is not correct must return `!False`
+    #    min_version -- major version of PostgreSQL when parameter was introduced
+    CMDLINE_OPTIONS = CaseInsensitiveDict({
+        'listen_addresses': (None, lambda _: False, 90100),
+        'port': (None, lambda _: False, 90100),
+        'cluster_name': (None, lambda _: False, 90500),
+        'wal_level': ('hot_standby', lambda v: v.lower() in ('hot_standby', 'replica', 'logical'), 90100),
+        'hot_standby': ('on', lambda _: False, 90100),
+        'max_connections': (100, lambda v: int(v) >= 100, 90100),
+        'max_wal_senders': (10, lambda v: int(v) >= 10, 90100),
+        'wal_keep_segments': (8, lambda v: int(v) >= 8, 90100),
+        'max_prepared_transactions': (0, lambda v: int(v) >= 0, 90100),
+        'max_locks_per_transaction': (64, lambda v: int(v) >= 64, 90100),
+        'track_commit_timestamp': ('off', lambda v: parse_bool(v) is not None, 90500),
+        'max_replication_slots': (10, lambda v: int(v) >= 10, 90400),
+        'max_worker_processes': (8, lambda v: int(v) >= 8, 90400),
+        'wal_log_hints': ('on', lambda _: False, 90400)
+    })
+
+    _RECOVERY_PARAMETERS = {
+        'archive_cleanup_command',
+        'restore_command',
+        'recovery_end_command',
+        'recovery_target',
+        'recovery_target_name',
+        'recovery_target_time',
+        'recovery_target_xid',
+        'recovery_target_lsn',
+        'recovery_target_inclusive',
+        'recovery_target_timeline',
+        'recovery_target_action',
+        'recovery_min_apply_delay',
+        'primary_conninfo',
+        'primary_slot_name',
+        'promote_trigger_file',
+        'trigger_file'
+    }
+
+    _CONFIG_WARNING_HEADER = '# Do not edit this file manually!\n# It will be overwritten by Patroni!\n'
+
+    def __init__(self, postgresql, config):
+        self._postgresql = postgresql
+        self._config_dir = os.path.abspath(config.get('config_dir') or postgresql.data_dir)
+        config_base_name = config.get('config_base_name', 'postgresql')
+        self._postgresql_conf = os.path.join(self._config_dir, config_base_name + '.conf')
+        self._postgresql_conf_mtime = None
+        self._postgresql_base_conf_name = config_base_name + '.base.conf'
+        self._postgresql_base_conf = os.path.join(self._config_dir, self._postgresql_base_conf_name)
+        self._pg_hba_conf = os.path.join(self._config_dir, 'pg_hba.conf')
+        self._pg_ident_conf = os.path.join(self._config_dir, 'pg_ident.conf')
+        self._recovery_conf = os.path.join(postgresql.data_dir, 'recovery.conf')
+        self._recovery_conf_mtime = None
+        self._recovery_signal = os.path.join(postgresql.data_dir, 'recovery.signal')
+        self._standby_signal = os.path.join(postgresql.data_dir, 'standby.signal')
+        self._auto_conf = os.path.join(postgresql.data_dir, 'postgresql.auto.conf')
+        self._auto_conf_mtime = None
+        self._synchronous_standby_names = None
+        self._postmaster_ctime = None
+        self._primary_conninfo = None
+        self._config = {}
+        self._recovery_params = {}
+        self.reload_config(config)
+
+    def setup_server_parameters(self):
+        self._server_parameters = self.get_server_parameters(self._config)
+        self._adjust_recovery_parameters()
+
+    @property
+    def _configuration_to_save(self):
+        configuration = [os.path.basename(self._postgresql_conf)]
+        if 'custom_conf' not in self._config:
+            configuration.append(os.path.basename(self._postgresql_base_conf_name))
+        if not self.hba_file:
+            configuration.append('pg_hba.conf')
+        if not self._server_parameters.get('ident_file'):
+            configuration.append('pg_ident.conf')
+        return configuration
+
+    def save_configuration_files(self, check_custom_bootstrap=False):
+        """
+            copy postgresql.conf to postgresql.conf.backup to be able to retrive configuration files
+            - originally stored as symlinks, those are normally skipped by pg_basebackup
+            - in case of WAL-E basebackup (see http://comments.gmane.org/gmane.comp.db.postgresql.wal-e/239)
+        """
+        if not (check_custom_bootstrap and self._postgresql.bootstrap.running_custom_bootstrap):
+            try:
+                for f in self._configuration_to_save:
+                    config_file = os.path.join(self._config_dir, f)
+                    backup_file = os.path.join(self._postgresql.data_dir, f + '.backup')
+                    if os.path.isfile(config_file):
+                        shutil.copy(config_file, backup_file)
+            except IOError:
+                logger.exception('unable to create backup copies of configuration files')
+        return True
+
+    def restore_configuration_files(self):
+        """ restore a previously saved postgresql.conf """
+        try:
+            for f in self._configuration_to_save:
+                config_file = os.path.join(self._config_dir, f)
+                backup_file = os.path.join(self._postgresql.data_dir, f + '.backup')
+                if not os.path.isfile(config_file):
+                    if os.path.isfile(backup_file):
+                        shutil.copy(backup_file, config_file)
+                    # Previously we didn't backup pg_ident.conf, if file is missing just create empty
+                    elif f == 'pg_ident.conf':
+                        open(config_file, 'w').close()
+        except IOError:
+            logger.exception('unable to restore configuration files from backup')
+
+    def write_postgresql_conf(self, configuration=None):
+        # rename the original configuration if it is necessary
+        if 'custom_conf' not in self._config and not os.path.exists(self._postgresql_base_conf):
+            os.rename(self._postgresql_conf, self._postgresql_base_conf)
+
+        with open(self._postgresql_conf, 'w') as f:
+            os.chmod(self._postgresql_conf, stat.S_IWRITE | stat.S_IREAD)
+            f.write(self._CONFIG_WARNING_HEADER)
+            f.write("include '{0}'\n\n".format(self._config.get('custom_conf') or self._postgresql_base_conf_name))
+            for name, value in sorted((configuration or self._server_parameters).items()):
+                if (not self._postgresql.bootstrap.running_custom_bootstrap or name != 'hba_file') \
+                        and name not in self._RECOVERY_PARAMETERS:
+                    f.write("{0} = '{1}'\n".format(name, value))
+            # when we are doing custom bootstrap we assume that we don't know superuser password
+            # and in order to be able to change it, we are opening trust access from a certain address
+            # therefore we need to make sure that hba_file is not overriden
+            # after changing superuser password we will "revert" all these "changes"
+            if self._postgresql.bootstrap.running_custom_bootstrap or 'hba_file' not in self._server_parameters:
+                f.write("hba_file = '{0}'\n".format(self._pg_hba_conf.replace('\\', '\\\\')))
+            if 'ident_file' not in self._server_parameters:
+                f.write("ident_file = '{0}'\n".format(self._pg_ident_conf.replace('\\', '\\\\')))
+
+            if self._postgresql.major_version >= 120000:
+                if self._recovery_params:
+                    f.write('\n# recovery.conf\n')
+                    for name, value in sorted(self._recovery_params.items()):
+                        f.write("{0} = '{1}'\n".format(name, value))
+
+                if not self._postgresql.bootstrap.keep_existing_recovery_conf:
+                    self._sanitize_auto_conf()
+
+    def append_pg_hba(self, config):
+        if not self.hba_file and not self._config.get('pg_hba'):
+            with open(self._pg_hba_conf, 'a') as f:
+                f.write('\n{}\n'.format('\n'.join(config)))
+        return True
+
+    def replace_pg_hba(self):
+        """
+        Replace pg_hba.conf content in the PGDATA if hba_file is not defined in the
+        `postgresql.parameters` and pg_hba is defined in `postgresql` configuration section.
+
+        :returns: True if pg_hba.conf was rewritten.
+        """
+
+        # when we are doing custom bootstrap we assume that we don't know superuser password
+        # and in order to be able to change it, we are opening trust access from a certain address
+        if self._postgresql.bootstrap.running_custom_bootstrap:
+            addresses = {'': 'local'}
+            if 'host' in self.local_replication_address and not self.local_replication_address['host'].startswith('/'):
+                addresses.update({sa[0] + '/32': 'host' for _, _, _, _, sa in socket.getaddrinfo(
+                                  self.local_replication_address['host'], self.local_replication_address['port'],
+                                  0, socket.SOCK_STREAM, socket.IPPROTO_TCP)})
+
+            with open(self._pg_hba_conf, 'w') as f:
+                f.write(self._CONFIG_WARNING_HEADER)
+                for address, t in addresses.items():
+                    f.write((
+                        '{0}\treplication\t{1}\t{3}\ttrust\n'
+                        '{0}\tall\t{2}\t{3}\ttrust\n'
+                    ).format(t, self.replication['username'], self._superuser.get('username') or 'all', address))
+        elif not self.hba_file and self._config.get('pg_hba'):
+            with open(self._pg_hba_conf, 'w') as f:
+                f.write(self._CONFIG_WARNING_HEADER)
+                for line in self._config['pg_hba']:
+                    f.write('{0}\n'.format(line))
+            return True
+
+    def replace_pg_ident(self):
+        """
+        Replace pg_ident.conf content in the PGDATA if ident_file is not defined in the
+        `postgresql.parameters` and pg_ident is defined in the `postgresql` section.
+
+        :returns: True if pg_ident.conf was rewritten.
+        """
+
+        if not self._server_parameters.get('ident_file') and self._config.get('pg_ident'):
+            with open(self._pg_ident_conf, 'w') as f:
+                f.write(self._CONFIG_WARNING_HEADER)
+                for line in self._config['pg_ident']:
+                    f.write('{0}\n'.format(line))
+            return True
+
+    def primary_conninfo_params(self, member):
+        name = self._postgresql.name
+        if not (member and member.conn_url) or member.name == name:
+            return None
+        ret = member.conn_kwargs(self.replication)
+        ret.update(application_name=name, sslmode='prefer')
+        if self._krbsrvname:
+            ret['krbsrvname'] = self._krbsrvname
+        if 'database' in ret:
+            del ret['database']
+        return ret
+
+    def primary_conninfo(self, member):
+        r = self.primary_conninfo_params(member)
+        if not r:
+            return None
+        keywords = 'user password host port sslmode application_name krbsrvname'.split()
+        return ' '.join('{0}={{{0}}}'.format(kw) for kw in keywords if r.get(kw)).format(**r)
+
+    def recovery_conf_exists(self):
+        if self._postgresql.major_version >= 120000:
+            return os.path.exists(self._standby_signal) or os.path.exists(self._recovery_signal)
+        return os.path.exists(self._recovery_conf)
+
+    def _read_primary_conninfo(self):
+        pg_conf_mtime = mtime(self._postgresql_conf)
+        auto_conf_mtime = mtime(self._auto_conf)
+        postmaster_ctime = self._postgresql.is_running()
+        if postmaster_ctime:
+            postmaster_ctime = postmaster_ctime.create_time()
+
+        if self._postgresql_conf_mtime == pg_conf_mtime and self._auto_conf_mtime == auto_conf_mtime \
+                and self._postmaster_ctime == postmaster_ctime:
+            return None, False
+
+        try:
+            primary_conninfo = self._postgresql.query('SHOW primary_conninfo').fetchone()[0]
+            self._postgresql_conf_mtime = pg_conf_mtime
+            self._auto_conf_mtime = auto_conf_mtime
+            self._postmaster_ctime = postmaster_ctime
+        except Exception:
+            primary_conninfo = None
+        return primary_conninfo, True
+
+    def _read_primary_conninfo_pre_v12(self):
+        recovery_conf_mtime = mtime(self._recovery_conf)
+        if recovery_conf_mtime == self._recovery_conf_mtime:
+            return None, False
+
+        primary_conninfo = ''
+        with open(self._recovery_conf, 'r') as f:
+            for line in f:
+                match = PARAMETER_RE.match(line)
+                if match and match.group(1) == 'primary_conninfo':
+                    i = match.end()
+                    if i < len(line):
+                        is_quoted = line[i] == "'"
+                        i += int(is_quoted)
+                        primary_conninfo, _ = read_param_value(line[i:], is_quoted)
+            self._recovery_conf_mtime = recovery_conf_mtime
+        return primary_conninfo, True
+
+    def check_recovery_conf(self, member):  # Name is confusing. In fact it checks the value of primary_conninfo
+        # TODO: recovery.conf could be stale, would be nice to detect that.
+        if self._postgresql.major_version >= 120000:
+            if not os.path.exists(self._standby_signal):
+                return False
+
+            _read_primary_conninfo = self._read_primary_conninfo
+        else:
+            if not self.recovery_conf_exists():
+                return False
+
+            _read_primary_conninfo = self._read_primary_conninfo_pre_v12
+
+        primary_conninfo, updated = _read_primary_conninfo()
+        # updated indicates that mtime of postgresql.conf, postgresql.auto.conf, or recovery.conf was changed
+        # and the primary_conninfo value was read either from config or from the database connection.
+        if updated:
+            # primary_conninfo is one of:
+            # - None (exception or unparsable config)
+            # - '' (not in config)
+            # - or the actual dsn value
+            self._primary_conninfo = primary_conninfo
+            if primary_conninfo:
+                # We will cache parsed value until the next config change.
+                self._primary_conninfo = parse_dsn(primary_conninfo)
+                # If we failed to parse non-empty connection string this indicates that config if broken.
+                if not self._primary_conninfo:
+                    return False
+            elif primary_conninfo is not None:
+                self._primary_conninfo = {}
+            else:  # primary_conninfo is None, config is probably broken
+                return False
+
+        wanted_primary_conninfo = self.primary_conninfo_params(member)
+        # first we will cover corner cases, when we are replicating from somewhere while shouldn't
+        # or there is no primary_conninfo but we should replicate from some specific node.
+        if not wanted_primary_conninfo:
+            return not self._primary_conninfo
+        elif not self._primary_conninfo:
+            return False
+
+        return all(self._primary_conninfo.get(p) == str(v) for p, v in wanted_primary_conninfo.items())
+
+    @staticmethod
+    def _remove_file_if_exists(name):
+        if os.path.isfile(name) or os.path.islink(name):
+            os.unlink(name)
+
+    def write_recovery_conf(self, recovery_params):
+        if self._postgresql.major_version >= 120000:
+            if parse_bool(recovery_params.pop('standby_mode', None)):
+                open(self._standby_signal, 'w').close()
+            else:
+                self._remove_file_if_exists(self._standby_signal)
+                open(self._recovery_signal, 'w').close()
+            self._recovery_params = recovery_params
+        else:
+            with open(self._recovery_conf, 'w') as f:
+                os.chmod(self._recovery_conf, stat.S_IWRITE | stat.S_IREAD)
+                for name, value in recovery_params.items():
+                    f.write("{0} = '{1}'\n".format(name, value))
+
+    def remove_recovery_conf(self):
+        for name in (self._recovery_conf, self._standby_signal, self._recovery_signal):
+            self._remove_file_if_exists(name)
+        self._recovery_params = {}
+
+    def _sanitize_auto_conf(self):
+        overwrite = False
+        lines = []
+
+        if os.path.exists(self._auto_conf):
+            try:
+                with open(self._auto_conf) as f:
+                    for raw_line in f:
+                        line = raw_line.strip()
+                        match = PARAMETER_RE.match(line)
+                        if match and match.group(1).lower() in self._RECOVERY_PARAMETERS:
+                            overwrite = True
+                        else:
+                            lines.append(raw_line)
+            except Exception:
+                logger.info('Failed to read %s', self._auto_conf)
+
+        if overwrite:
+            try:
+                with open(self._auto_conf, 'w') as f:
+                    for raw_line in lines:
+                        f.write(raw_line)
+            except Exception:
+                logger.exception('Failed to remove some unwanted parameters from %s', self._auto_conf)
+
+    def _adjust_recovery_parameters(self):
+        # It is not strictly necessary, but we can make patroni configs crossi-compatible with all postgres versions.
+        recovery_conf = {n: v for n, v in self._server_parameters.items() if n.lower() in self._RECOVERY_PARAMETERS}
+        if recovery_conf:
+            self._config['recovery_conf'] = recovery_conf
+
+        if self.get('recovery_conf'):
+            good_name, bad_name = 'trigger_file', 'promote_trigger_file'
+            if self._postgresql.major_version >= 120000:
+                good_name, bad_name = bad_name, good_name
+
+            value = self._config['recovery_conf'].pop(bad_name, None)
+            if good_name not in self._config['recovery_conf'] and value:
+                self._config['recovery_conf'][good_name] = value
+
+    def get_server_parameters(self, config):
+        parameters = config['parameters'].copy()
+        listen_addresses, port = split_host_port(config['listen'], 5432)
+        parameters.update(cluster_name=self._postgresql.scope, listen_addresses=listen_addresses, port=str(port))
+        if config.get('synchronous_mode', False):
+            if self._synchronous_standby_names is None:
+                if config.get('synchronous_mode_strict', False):
+                    parameters['synchronous_standby_names'] = '*'
+                else:
+                    parameters.pop('synchronous_standby_names', None)
+            else:
+                parameters['synchronous_standby_names'] = self._synchronous_standby_names
+        if self._postgresql.major_version >= 90600 and parameters['wal_level'] == 'hot_standby':
+            parameters['wal_level'] = 'replica'
+        ret = CaseInsensitiveDict({k: v for k, v in parameters.items() if not self._postgresql.major_version or
+                                   self._postgresql.major_version >= self.CMDLINE_OPTIONS.get(k, (0, 1, 90100))[2]})
+        ret.update({k: os.path.join(self._config_dir, ret[k]) for k in ('hba_file', 'ident_file') if k in ret})
+        return ret
+
+    @staticmethod
+    def _get_unix_local_address(unix_socket_directories):
+        for d in unix_socket_directories.split(','):
+            d = d.strip()
+            if d.startswith('/'):  # Only absolute path can be used to connect via unix-socket
+                return d
+        return ''
+
+    def _get_tcp_local_address(self):
+        listen_addresses = self._server_parameters['listen_addresses'].split(',')
+
+        for la in listen_addresses:
+            if la.strip().lower() in ('*', '0.0.0.0', '127.0.0.1', 'localhost'):  # we are listening on '*' or localhost
+                return 'localhost'  # connection via localhost is preferred
+        return listen_addresses[0].strip()  # can't use localhost, take first address from listen_addresses
+
+    @property
+    def local_connect_kwargs(self):
+        ret = self._local_address.copy()
+        ret.update({'database': self._postgresql.database,
+                    'fallback_application_name': 'Patroni',
+                    'connect_timeout': 3,
+                    'options': '-c statement_timeout=2000'})
+        if 'username' in self._superuser:
+            ret['user'] = self._superuser['username']
+        if 'password' in self._superuser:
+            ret['password'] = self._superuser['password']
+        return ret
+
+    def resolve_connection_addresses(self):
+        port = self._server_parameters['port']
+        tcp_local_address = self._get_tcp_local_address()
+
+        local_address = {'port': port}
+        if self._config.get('use_unix_socket'):
+            unix_socket_directories = self._server_parameters.get('unix_socket_directories')
+            if unix_socket_directories is not None:
+                # fallback to tcp if unix_socket_directories is set, but there are no sutable values
+                local_address['host'] = self._get_unix_local_address(unix_socket_directories) or tcp_local_address
+
+            # if unix_socket_directories is not specified, but use_unix_socket is set to true - do our best
+            # to use default value, i.e. don't specify a host neither in connection url nor arguments
+        else:
+            local_address['host'] = tcp_local_address
+
+        self._local_address = local_address
+        self.local_replication_address = {'host': tcp_local_address, 'port': port}
+
+        netloc = self._config.get('connect_address') or tcp_local_address + ':' + port
+        self._postgresql.connection_string = uri('postgres', netloc, self._postgresql.database)
+
+        self._postgresql.set_connection_kwargs(self.local_connect_kwargs)
+
+    def reload_config(self, config):
+        self._superuser = config['authentication'].get('superuser', {})
+        server_parameters = self.get_server_parameters(config)
+
+        conf_changed = hba_changed = ident_changed = local_connection_address_changed = pending_restart = False
+        if self._postgresql.state == 'running':
+            changes = CaseInsensitiveDict({p: v for p, v in server_parameters.items() if '.' not in p})
+            changes.update({p: None for p in self._server_parameters.keys() if not ('.' in p or p in changes)})
+            if changes:
+                # XXX: query can raise an exception
+                for r in self._postgresql.query(('SELECT name, setting, unit, vartype, context '
+                                                 + 'FROM pg_catalog.pg_settings ' +
+                                                 ' WHERE pg_catalog.lower(name) IN ('
+                                                 + ', '.join(['%s'] * len(changes)) +
+                                                 ')'), *(k.lower() for k in changes.keys())):
+                    if r[4] != 'internal' and r[0] in changes:
+                        new_value = changes.pop(r[0])
+                        if new_value is None or not compare_values(r[3], r[2], r[1], new_value):
+                            if r[4] == 'postmaster':
+                                pending_restart = True
+                                logger.info('Changed %s from %s to %s (restart required)', r[0], r[1], new_value)
+                                if config.get('use_unix_socket') and r[0] == 'unix_socket_directories'\
+                                        or r[0] in ('listen_addresses', 'port'):
+                                    local_connection_address_changed = True
+                            else:
+                                logger.info('Changed %s from %s to %s', r[0], r[1], new_value)
+                                conf_changed = True
+                for param in changes:
+                    if param in server_parameters:
+                        logger.warning('Removing invalid parameter `%s` from postgresql.parameters', param)
+                        server_parameters.pop(param)
+
+            # Check that user-defined-paramters have changed (parameters with period in name)
+            if not conf_changed:
+                for p, v in server_parameters.items():
+                    if '.' in p and (p not in self._server_parameters or str(v) != str(self._server_parameters[p])):
+                        logger.info('Changed %s from %s to %s', p, self._server_parameters.get(p), v)
+                        conf_changed = True
+                        break
+                if not conf_changed:
+                    for p, v in self._server_parameters.items():
+                        if '.' in p and (p not in server_parameters or str(v) != str(server_parameters[p])):
+                            logger.info('Changed %s from %s to %s', p, v, server_parameters.get(p))
+                            conf_changed = True
+                            break
+
+            if not server_parameters.get('hba_file') and config.get('pg_hba'):
+                hba_changed = self._config.get('pg_hba', []) != config['pg_hba']
+
+            if not server_parameters.get('ident_file') and config.get('pg_ident'):
+                ident_changed = self._config.get('pg_ident', []) != config['pg_ident']
+
+        self._config = config
+        self._postgresql.set_pending_restart(pending_restart)
+        self._server_parameters = server_parameters
+        self._adjust_recovery_parameters()
+        self._connect_address = config.get('connect_address')
+        self._krbsrvname = config.get('krbsrvname')
+
+        # for not so obvious connection attempts that may happen outside of pyscopg2
+        if self._krbsrvname:
+            os.environ['PGKRBSRVNAME'] = self._krbsrvname
+
+        if not local_connection_address_changed:
+            self.resolve_connection_addresses()
+
+        if conf_changed:
+            self.write_postgresql_conf()
+
+        if hba_changed:
+            self.replace_pg_hba()
+
+        if ident_changed:
+            self.replace_pg_ident()
+
+        if conf_changed or hba_changed or ident_changed:
+            logger.info('PostgreSQL configuration items changed, reloading configuration.')
+            self._postgresql.reload()
+        elif not pending_restart:
+            logger.info('No PostgreSQL configuration items changed, nothing to reload.')
+
+    def set_synchronous_standby(self, name):
+        """Sets a node to be synchronous standby and if changed does a reload for PostgreSQL."""
+        if name and name != '*':
+            name = quote_ident(name)
+        if name != self._synchronous_standby_names:
+            if name is None:
+                self._server_parameters.pop('synchronous_standby_names', None)
+            else:
+                self._server_parameters['synchronous_standby_names'] = name
+            self._synchronous_standby_names = name
+            if self._postgresql.state == 'running':
+                self.write_postgresql_conf()
+                self._postgresql.reload()
+
+    @property
+    def effective_configuration(self):
+        """It might happen that the current value of one (or more) below parameters stored in
+        the controldata is higher than the value stored in the global cluster configuration.
+
+        Example: max_connections in global configuration is 100, but in controldata
+        `Current max_connections setting: 200`. If we try to start postgres with
+        max_connections=100, it will immediately exit.
+        As a workaround we will start it with the values from controldata and set `pending_restart`
+        to true as an indicator that current values of parameters are not matching expectations."""
+
+        if self._postgresql.role == 'master':
+            return self._server_parameters
+
+        options_mapping = {
+            'max_connections': 'max_connections setting',
+            'max_prepared_transactions': 'max_prepared_xacts setting',
+            'max_locks_per_transaction': 'max_locks_per_xact setting'
+        }
+
+        if self._postgresql.major_version >= 90400:
+            options_mapping['max_worker_processes'] = 'max_worker_processes setting'
+
+        if self._postgresql.major_version >= 120000:
+            options_mapping['max_wal_senders'] = 'max_wal_senders setting'
+
+        data = self._postgresql.controldata()
+        effective_configuration = self._server_parameters.copy()
+
+        for name, cname in options_mapping.items():
+            value = parse_int(effective_configuration[name])
+            cvalue = parse_int(data[cname])
+            if cvalue > value:
+                effective_configuration[name] = cvalue
+                self._postgresql.set_pending_restart(True)
+        return effective_configuration
+
+    @property
+    def replication(self):
+        return self._config['authentication']['replication']
+
+    @property
+    def superuser(self):
+        return self._superuser
+
+    @property
+    def rewind_credentials(self):
+        return self._config['authentication'].get('rewind', self._superuser) \
+                if self._postgresql.major_version >= 110000 else self._superuser
+
+    @property
+    def hba_file(self):
+        return self._server_parameters.get('hba_file')
+
+    @property
+    def pg_hba_conf(self):
+        return self._pg_hba_conf
+
+    @property
+    def postgresql_conf(self):
+        return self._postgresql_conf
+
+    def get(self, key, default=None):
+        return self._config.get(key, default)
@@ -0,0 +1,46 @@
+import logging
+import psycopg2
+
+from contextlib import contextmanager
+from threading import Lock
+
+logger = logging.getLogger(__name__)
+
+
+class Connection(object):
+
+    def __init__(self):
+        self._lock = Lock()
+        self._connection = None
+        self._cursor_holder = None
+
+    def set_conn_kwargs(self, conn_kwargs):
+        self._conn_kwargs = conn_kwargs
+
+    def get(self):
+        with self._lock:
+            if not self._connection or self._connection.closed != 0:
+                self._connection = psycopg2.connect(**self._conn_kwargs)
+                self._connection.autocommit = True
+                self.server_version = self._connection.server_version
+        return self._connection
+
+    def cursor(self):
+        if not self._cursor_holder or self._cursor_holder.closed or self._cursor_holder.connection.closed != 0:
+            logger.info("establishing a new patroni connection to the postgres cluster")
+            self._cursor_holder = self.get().cursor()
+        return self._cursor_holder
+
+    def close(self):
+        if self._connection and self._connection.closed == 0:
+            self._connection.close()
+            logger.info("closed patroni connection to the postgresql cluster")
+        self._cursor_holder = self._connection = None
+
+
+@contextmanager
+def get_connection_cursor(**kwargs):
+    with psycopg2.connect(**kwargs) as conn:
+        conn.autocommit = True
+        with conn.cursor() as cur:
+            yield cur
@@ -0,0 +1,70 @@
+import logging
+
+from patroni.exceptions import PostgresException
+
+logger = logging.getLogger(__name__)
+
+
+def postgres_version_to_int(pg_version):
+    """Convert the server_version to integer
+
+    >>> postgres_version_to_int('9.5.3')
+    90503
+    >>> postgres_version_to_int('9.3.13')
+    90313
+    >>> postgres_version_to_int('10.1')
+    100001
+    >>> postgres_version_to_int('10')  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    PostgresException: 'Invalid PostgreSQL version format: X.Y or X.Y.Z is accepted: 10'
+    >>> postgres_version_to_int('9.6')  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    PostgresException: 'Invalid PostgreSQL version format: X.Y or X.Y.Z is accepted: 9.6'
+    >>> postgres_version_to_int('a.b.c')  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    PostgresException: 'Invalid PostgreSQL version: a.b.c'
+    """
+
+    try:
+        components = list(map(int, pg_version.split('.')))
+    except ValueError:
+        raise PostgresException('Invalid PostgreSQL version: {0}'.format(pg_version))
+
+    if len(components) < 2 or len(components) == 2 and components[0] < 10 or len(components) > 3:
+        raise PostgresException('Invalid PostgreSQL version format: X.Y or X.Y.Z is accepted: {0}'.format(pg_version))
+
+    if len(components) == 2:
+        # new style verion numbers, i.e. 10.1 becomes 100001
+        components.insert(1, 0)
+
+    return int(''.join('{0:02d}'.format(c) for c in components))
+
+
+def postgres_major_version_to_int(pg_version):
+    """
+    >>> postgres_major_version_to_int('10')
+    100000
+    >>> postgres_major_version_to_int('9.6')
+    90600
+    """
+    return postgres_version_to_int(pg_version + '.0')
+
+
+def parse_lsn(lsn):
+    t = lsn.split('/')
+    return int(t[0], 16) * 0x100000000 + int(t[1], 16)
+
+
+def parse_history(data):
+    for line in data.split('\n'):
+        values = line.strip().split('\t')
+        if len(values) == 3:
+            try:
+                values[0] = int(values[0])
+                values[1] = parse_lsn(values[1])
+                yield values
+            except (IndexError, ValueError):
+                logger.exception('Exception when parsing timeline history line "%s"', values)
@@ -1,12 +1,11 @@
 import logging
+import multiprocessing
 import os
 import psutil
 import re
 import signal
 import subprocess

-from patroni import call_self
-
 logger = logging.getLogger(__name__)

 STOP_SIGNALS = {
@@ -16,6 +15,18 @@ STOP_SIGNALS = {
 }


+def pg_ctl_start(conn, cmdline, env):
+    if os.name != 'nt':
+        os.setsid()
+    try:
+        postmaster = subprocess.Popen(cmdline, close_fds=True, env=env)
+        conn.send(postmaster.pid)
+    except Exception:
+        logger.exception('Failed to execute %s', cmdline)
+        conn.send(None)
+    conn.close()
+
+
 class PostmasterProcess(psutil.Process):

    def __init__(self, pid):
@@ -102,28 +113,31 @@ class PostmasterProcess(psutil.Process):
        return None

    def wait_for_user_backends_to_close(self):
-        # These regexps are cross checked against versions PostgreSQL 9.1 .. 9.6
-        aux_proc_re = re.compile("(?:postgres:)( .*:)? (?:""(?:startup|logger|checkpointer|writer|wal writer|"
-                                 "autovacuum launcher|autovacuum worker|stats collector|wal receiver|archiver|"
-                                 "wal sender) process|bgworker: )")
+        # These regexps are cross checked against versions PostgreSQL 9.1 .. 11
+        aux_proc_re = re.compile("(?:postgres:)( .*:)? (?:(?:archiver|startup|autovacuum launcher|autovacuum worker|"
+                                 "checkpointer|logger|stats collector|wal receiver|wal writer|writer)(?: process  )?|"
+                                 "walreceiver|wal sender process|walsender|walwriter|background writer|"
+                                 "logical replication launcher|logical replication worker for|bgworker:) ")

        try:
-            user_backends = []
-            user_backends_cmdlines = []
-            for child in self.children():
-                try:
-                    cmdline = child.cmdline()[0]
-                    if not aux_proc_re.match(cmdline):
-                        user_backends.append(child)
-                        user_backends_cmdlines.append(cmdline)
-                except psutil.NoSuchProcess:
-                    pass
-            if user_backends:
-                logger.debug('Waiting for user backends %s to close', ', '.join(user_backends_cmdlines))
-                psutil.wait_procs(user_backends)
-            logger.debug("Backends closed")
+            children = self.children()
        except psutil.Error:
-            logger.exception('wait_for_user_backends_to_close')
+            return logger.debug('Failed to get list of postmaster children')
+
+        user_backends = []
+        user_backends_cmdlines = []
+        for child in children:
+            try:
+                cmdline = child.cmdline()[0]
+                if not aux_proc_re.match(cmdline):
+                    user_backends.append(child)
+                    user_backends_cmdlines.append(cmdline)
+            except psutil.NoSuchProcess:
+                pass
+        if user_backends:
+            logger.debug('Waiting for user backends %s to close', ', '.join(user_backends_cmdlines))
+            psutil.wait_procs(user_backends)
+        logger.debug("Backends closed")

    @staticmethod
    def start(pgcommand, data_dir, conf, options):
@@ -156,10 +170,13 @@ class PostmasterProcess(psutil.Process):
            pass
        cmdline = [pgcommand, '-D', data_dir, '--config-file={}'.format(conf)] + options
        logger.debug("Starting postgres: %s", " ".join(cmdline))
-        proc = call_self(['pg_ctl_start'] + cmdline, close_fds=(os.name != 'nt'),
-                         stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
-        pid = int(proc.stdout.readline().strip())
-        proc.wait()
+        parent_conn, child_conn = multiprocessing.Pipe(False)
+        proc = multiprocessing.Process(target=pg_ctl_start, args=(child_conn, cmdline, env))
+        proc.start()
+        pid = parent_conn.recv()
+        proc.join()
+        if pid is None:
+            return
        logger.info('postmaster pid=%s', pid)

        # TODO: In an extremely unlikely case, the process could have exited and the pid reassigned. The start
@@ -0,0 +1,216 @@
+import logging
+import os
+import subprocess
+
+from patroni.dcs import Leader
+from patroni.postgresql.connection import get_connection_cursor
+from patroni.postgresql.misc import parse_history, parse_lsn
+
+logger = logging.getLogger(__name__)
+
+REWIND_STATUS = type('Enum', (), {'INITIAL': 0, 'CHECKPOINT': 1, 'CHECK': 2, 'NEED': 3,
+                                  'NOT_NEED': 4, 'SUCCESS': 5, 'FAILED': 6})
+
+
+class Rewind(object):
+
+    def __init__(self, postgresql):
+        self._postgresql = postgresql
+        self.reset_state()
+
+    @staticmethod
+    def configuration_allows_rewind(data):
+        return data.get('wal_log_hints setting', 'off') == 'on' or data.get('Data page checksum version', '0') != '0'
+
+    @property
+    def can_rewind(self):
+        """ check if pg_rewind executable is there and that pg_controldata indicates
+            we have either wal_log_hints or checksums turned on
+        """
+        # low-hanging fruit: check if pg_rewind configuration is there
+        if not self._postgresql.config.get('use_pg_rewind'):
+            return False
+
+        cmd = [self._postgresql.pgcommand('pg_rewind'), '--help']
+        try:
+            ret = subprocess.call(cmd, stdout=open(os.devnull, 'w'), stderr=subprocess.STDOUT)
+            if ret != 0:  # pg_rewind is not there, close up the shop and go home
+                return False
+        except OSError:
+            return False
+        return self.configuration_allows_rewind(self._postgresql.controldata())
+
+    @property
+    def can_rewind_or_reinitialize_allowed(self):
+        return self._postgresql.config.get('remove_data_directory_on_diverged_timelines') or self.can_rewind
+
+    def trigger_check_diverged_lsn(self):
+        if self.can_rewind_or_reinitialize_allowed and self._state != REWIND_STATUS.NEED:
+            self._state = REWIND_STATUS.CHECK
+
+    def check_leader_is_not_in_recovery(self, **kwargs):
+        if not kwargs.get('database'):
+            kwargs['database'] = self._postgresql.database
+        try:
+            with get_connection_cursor(connect_timeout=3, options='-c statement_timeout=2000', **kwargs) as cur:
+                cur.execute('SELECT pg_catalog.pg_is_in_recovery()')
+                if not cur.fetchone()[0]:
+                    return True
+                logger.info('Leader is still in_recovery and therefore can\'t be used for rewind')
+        except Exception:
+            return logger.exception('Exception when working with leader')
+
+    def _get_local_timeline_lsn_from_controldata(self):
+        timeline = lsn = None
+        data = self._postgresql.controldata()
+        try:
+            if data.get('Database cluster state') == 'shut down in recovery':
+                lsn = data.get('Minimum recovery ending location')
+                timeline = int(data.get("Min recovery ending loc's timeline"))
+                if lsn == '0/0' or timeline == 0:  # it was a master when it crashed
+                    data['Database cluster state'] = 'shut down'
+            if data.get('Database cluster state') == 'shut down':
+                lsn = data.get('Latest checkpoint location')
+                timeline = int(data.get("Latest checkpoint's TimeLineID"))
+        except (TypeError, ValueError):
+            logger.exception('Failed to get local timeline and lsn from pg_controldata output')
+        return timeline, lsn
+
+    def _get_local_timeline_lsn(self):
+        if self._postgresql.is_running():  # if postgres is running - get timeline and lsn from replication connection
+            timeline, lsn = self._postgresql.get_local_timeline_lsn_from_replication_connection()
+        else:  # otherwise analyze pg_controldata output
+            timeline, lsn = self._get_local_timeline_lsn_from_controldata()
+        logger.info('Local timeline=%s lsn=%s', timeline, lsn)
+        return timeline, lsn
+
+    def _check_timeline_and_lsn(self, leader):
+        local_timeline, local_lsn = self._get_local_timeline_lsn()
+        if local_timeline is None or local_lsn is None:
+            return
+
+        if isinstance(leader, Leader):
+            if leader.member.data.get('role') != 'master':
+                return
+        # standby cluster
+        elif not self.check_leader_is_not_in_recovery(**leader.conn_kwargs(self._postgresql.config.replication)):
+            return
+
+        history = need_rewind = None
+        try:
+            with self._postgresql.get_replication_connection_cursor(**leader.conn_kwargs()) as cur:
+                cur.execute('IDENTIFY_SYSTEM')
+                master_timeline = cur.fetchone()[1]
+                logger.info('master_timeline=%s', master_timeline)
+                if local_timeline > master_timeline:  # Not always supported by pg_rewind
+                    need_rewind = True
+                elif master_timeline > 1:
+                    cur.execute('TIMELINE_HISTORY %s', (master_timeline,))
+                    history = bytes(cur.fetchone()[1]).decode('utf-8')
+                    logger.info('master: history=%s', history)
+                else:  # local_timeline == master_timeline == 1
+                    need_rewind = False
+        except Exception:
+            return logger.exception('Exception when working with master via replication connection')
+
+        if history is not None:
+            for parent_timeline, switchpoint, _ in parse_history(history):
+                if parent_timeline == local_timeline:
+                    try:
+                        need_rewind = parse_lsn(local_lsn) >= switchpoint
+                    except (IndexError, ValueError):
+                        logger.exception('Exception when parsing lsn')
+                    break
+                elif parent_timeline > local_timeline:
+                    break
+
+        self._state = need_rewind and REWIND_STATUS.NEED or REWIND_STATUS.NOT_NEED
+
+    def rewind_or_reinitialize_needed_and_possible(self, leader):
+        if leader and leader.name != self._postgresql.name and leader.conn_url and self._state == REWIND_STATUS.CHECK:
+            self._check_timeline_and_lsn(leader)
+        return leader and leader.conn_url and self._state == REWIND_STATUS.NEED
+
+    def check_for_checkpoint_after_promote(self):
+        if self._state == REWIND_STATUS.INITIAL and self._postgresql.is_leader():
+            try:
+                timeline = int(self._postgresql.controldata().get("Latest checkpoint's TimeLineID"))
+                if self._postgresql.get_master_timeline() == timeline:
+                    self._state = REWIND_STATUS.CHECKPOINT
+            except (TypeError, ValueError):
+                logger.exception('Failed to parse timeline from pg_controldata output')
+
+    def checkpoint_after_promote(self):
+        return self._state == REWIND_STATUS.CHECKPOINT
+
+    def pg_rewind(self, r):
+        # prepare pg_rewind connection
+        env = self._postgresql.write_pgpass(r)
+        dsn_attrs = [
+            ('user', r.get('user')),
+            ('host', r.get('host')),
+            ('port', r.get('port')),
+            ('dbname', r.get('database') or self._postgresql.database),
+            ('sslmode', 'prefer'),
+            ('sslcompression', '1'),
+        ]
+        dsn = " ".join("{0}={1}".format(k, v) for k, v in dsn_attrs if v is not None)
+        logger.info('running pg_rewind from %s', dsn)
+        try:
+            return self._postgresql.cancellable.call([self._postgresql.pgcommand('pg_rewind'), '-D',
+                                                      self._postgresql.data_dir, '--source-server', dsn], env=env) == 0
+        except OSError:
+            return False
+
+    def execute(self, leader):
+        if self._postgresql.is_running() and not self._postgresql.stop(checkpoint=False):
+            return logger.warning('Can not run pg_rewind because postgres is still running')
+
+        # prepare pg_rewind connection
+        r = leader.conn_kwargs(self._postgresql.config.rewind_credentials)
+
+        # 1. make sure that we are really trying to rewind from the master
+        # 2. make sure that pg_control contains the new timeline by:
+        #   running a checkpoint or
+        #   waiting until Patroni on the master will expose checkpoint_after_promote=True
+        checkpoint_status = leader.checkpoint_after_promote if isinstance(leader, Leader) else None
+        if checkpoint_status is None:  # master still runs the old Patroni
+            leader_status = self._postgresql.checkpoint(leader.conn_kwargs(self._postgresql.config.superuser))
+            if leader_status:
+                return logger.warning('Can not use %s for rewind: %s', leader.name, leader_status)
+        elif not checkpoint_status:
+            return logger.info('Waiting for checkpoint on %s before rewind', leader.name)
+        elif not self.check_leader_is_not_in_recovery(**r):
+            return
+
+        if self.pg_rewind(r):
+            self._state = REWIND_STATUS.SUCCESS
+        elif not self.check_leader_is_not_in_recovery(**r):
+            logger.warning('Failed to rewind because master %s become unreachable', leader.name)
+        else:
+            logger.error('Failed to rewind from healty master: %s', leader.name)
+
+            for name in ('remove_data_directory_on_rewind_failure', 'remove_data_directory_on_diverged_timelines'):
+                if self._postgresql.config.get(name):
+                    logger.warning('%s is set. removing...', name)
+                    self._postgresql.remove_data_directory()
+                    self._state = REWIND_STATUS.INITIAL
+                    break
+            else:
+                self._state = REWIND_STATUS.FAILED
+        return False
+
+    def reset_state(self):
+        self._state = REWIND_STATUS.INITIAL
+
+    @property
+    def is_needed(self):
+        return self._state in (REWIND_STATUS.CHECK, REWIND_STATUS.NEED)
+
+    @property
+    def executed(self):
+        return self._state > REWIND_STATUS.NOT_NEED
+
+    @property
+    def failed(self):
+        return self._state == REWIND_STATUS.FAILED
@@ -0,0 +1,108 @@
+import logging
+
+from patroni.postgresql.connection import get_connection_cursor
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+
+def compare_slots(s1, s2):
+    return s1['type'] == s2['type'] and (s1['type'] == 'physical' or
+                                         s1['database'] == s2['database'] and s1['plugin'] == s2['plugin'])
+
+
+class SlotsHandler(object):
+
+    def __init__(self, postgresql):
+        self._postgresql = postgresql
+        self._use_slots = postgresql.config.get('use_slots', True)
+        self._replication_slots = {}  # already existing replication slots
+        self.schedule()
+
+    @property
+    def use_slots(self):
+        return self._use_slots and self._postgresql.major_version >= 90400
+
+    def _query(self, sql, *params):
+        return self._postgresql.query(sql, *params, retry=False)
+
+    def load_replication_slots(self):
+        if self.use_slots and self._schedule_load_slots:
+            replication_slots = {}
+            cursor = self._query('SELECT slot_name, slot_type, plugin, database FROM pg_catalog.pg_replication_slots')
+            for r in cursor:
+                value = {'type': r[1]}
+                if r[1] == 'logical':
+                    value.update({'plugin': r[2], 'database': r[3]})
+                replication_slots[r[0]] = value
+            self._replication_slots = replication_slots
+            self._schedule_load_slots = False
+
+    def drop_replication_slot(self, name):
+        cursor = self._query(('SELECT pg_catalog.pg_drop_replication_slot(%s) WHERE EXISTS (SELECT 1 ' +
+                              'FROM pg_catalog.pg_replication_slots WHERE slot_name = %s AND NOT active)'), name, name)
+        # In normal situation rowcount should be 1, otherwise either slot doesn't exists or it is still active
+        return cursor.rowcount == 1
+
+    def sync_replication_slots(self, cluster):
+        if self.use_slots:
+            try:
+                self.load_replication_slots()
+
+                slots = cluster.get_replication_slots(self._postgresql.name, self._postgresql.role)
+
+                # drop old replication slots which are not presented in desired slots
+                for name in set(self._replication_slots) - set(slots):
+                    if not self.drop_replication_slot(name):
+                        logger.error("Failed to drop replication slot '%s'", name)
+                        self._schedule_load_slots = True
+
+                immediately_reserve = ', true' if self._postgresql.major_version >= 90600 else ''
+
+                logical_slots = defaultdict(dict)
+                for name, value in slots.items():
+                    if name in self._replication_slots and not compare_slots(value, self._replication_slots[name]):
+                        logger.info("Trying to drop replication slot '%s' because value is changing from %s to %s",
+                                    name, self._replication_slots[name], value)
+                        if not self.drop_replication_slot(name):
+                            logger.error("Failed to drop replication slot '%s'", name)
+                            self._schedule_load_slots = True
+                            continue
+                        self._replication_slots.pop(name)
+                    if name not in self._replication_slots:
+                        if value['type'] == 'physical':
+                            try:
+                                self._query(("SELECT pg_catalog.pg_create_physical_replication_slot(%s{0})" +
+                                             " WHERE NOT EXISTS (SELECT 1 FROM pg_catalog.pg_replication_slots" +
+                                             " WHERE slot_type = 'physical' AND slot_name = %s)").format(
+                                                 immediately_reserve), name, name)
+                            except Exception:
+                                logger.exception("Failed to create physical replication slot '%s'", name)
+                                self._schedule_load_slots = True
+                        elif value['type'] == 'logical' and name not in self._replication_slots:
+                            logical_slots[value['database']][name] = value
+
+                # create new logical slots
+                for database, values in logical_slots.items():
+                    conn_kwargs = self._postgresql.config.local_connect_kwargs
+                    conn_kwargs['database'] = database
+                    with get_connection_cursor(**conn_kwargs) as cur:
+                        for name, value in values.items():
+                            try:
+                                cur.execute("SELECT pg_catalog.pg_create_logical_replication_slot(%s, %s)" +
+                                            " WHERE NOT EXISTS (SELECT 1 FROM pg_catalog.pg_replication_slots" +
+                                            " WHERE slot_type = 'logical' AND slot_name = %s)",
+                                            (name, value['plugin'], name))
+                            except Exception:
+                                logger.exception("Failed to create logical replication slot '%s' plugin='%s'",
+                                                 name, value['plugin'])
+                                self._schedule_load_slots = True
+                self._replication_slots = slots
+            except Exception:
+                logger.exception('Exception when changing replication slots')
+                self._schedule_load_slots = True
+
+    def schedule(self, value=None):
+        if value is None:
+            value = self.use_slots
+        self._schedule_load_slots = value
@@ -1,4 +1,6 @@
+import logging
 import random
+import re
 import time

 from dateutil import tz
@@ -6,6 +8,13 @@ from patroni.exceptions import PatroniException

 tzutc = tz.tzutc()

+logger = logging.getLogger(__name__)
+
+OCT_RE = re.compile(r'^[-+]?0[0-7]*')
+DEC_RE = re.compile(r'^[-+]?(0|[1-9][0-9]*)')
+HEX_RE = re.compile(r'^[-+]?0x[0-9a-fA-F]+')
+DBL_RE = re.compile(r'^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?')
+

 def deep_compare(obj1, obj2):
    """
@@ -88,42 +97,77 @@ def strtol(value, strict=True):
    True
    >>> strtol(' d ') == (None, 'd')
    True
+    >>> strtol(' 1 d ') == (1, ' d')
+    True
    >>> strtol('9s', False) == (9, 's')
    True
    >>> strtol(' s ', False) == (1, 's')
    True
    """
    value = str(value).strip()
-    ln = len(value)
-    i = 0
-    # skip sign:
-    if i < ln and value[i] in ('-', '+'):
-        i += 1
+    for regex, base in ((HEX_RE, 16), (OCT_RE, 8), (DEC_RE, 10)):
+        match = regex.match(value)
+        if match:
+            end = match.end()
+            return int(value[:end], base), value[end:]
+    return (None if strict else 1), value

-    # we always expect to get digit in the beginning
-    if i < ln and value[i].isdigit():
-        if value[i] == '0':
-            i += 1
-            if i < ln and value[i] in ('x', 'X'):  # '0' followed by 'x': HEX
-                base = 16
-                i += 1
-            else:  # just starts with '0': OCT
-                base = 8
-        else:  # any other digit: DEC
-            base = 10

-        ret = None
-        while i <= ln:
-            try:  # try to find maximally long number
-                i += 1  # by giving to `int` longer and longer strings
-                ret = int(value[:i], base)
-            except ValueError:  # until we will not get an exception or end of the string
-                i -= 1
-                break
-        if ret is not None:  # yay! there is a number in the beginning of the string
-            return ret, value[i:].strip()  # return the number and the "rest"
+def strtod(value):
+    """As most as possible close equivalent of strtod(3) function used by postgres to parse parameter values.
+    >>> strtod(' A ') == (None, 'A')
+    True
+    """
+    value = str(value).strip()
+    match = DBL_RE.match(value)
+    if match:
+        end = match.end()
+        return float(value[:end]), value[end:]
+    return None, value

-    return (None if strict else 1), value.strip()
+
+def rint(value):
+    """
+    >>> rint(0.5) == 0
+    True
+    >>> rint(0.501) == 1
+    True
+    >>> rint(1.5) == 2
+    True
+    """
+
+    ret = round(value)
+    return 2.0 * round(value / 2.0) if abs(ret - value) == 0.5 else ret
+
+
+def convert_to_base_unit(value, unit, base_unit):
+    convert = {
+        'B': {'B': 1, 'kB': 1024, 'MB': 1024 * 1024, 'GB': 1024 * 1024 * 1024, 'TB': 1024 * 1024 * 1024 * 1024},
+        'kB': {'B': 1.0 / 1024, 'kB': 1, 'MB': 1024, 'GB': 1024 * 1024, 'TB': 1024 * 1024 * 1024},
+        'MB': {'B': 1.0 / (1024 * 1024), 'kB': 1.0 / 1024, 'MB': 1, 'GB': 1024, 'TB': 1024 * 1024},
+        'ms': {'us': 1.0 / 1000, 'ms': 1, 's': 1000, 'min': 1000 * 60, 'h': 1000 * 60 * 60, 'd': 1000 * 60 * 60 * 24},
+        's': {'us': 1.0 / (1000 * 1000), 'ms': 1.0 / 1000, 's': 1, 'min': 60, 'h': 60 * 60, 'd': 60 * 60 * 24},
+        'min': {'us': 1.0 / (1000 * 1000 * 60), 'ms': 1.0 / (1000 * 60), 's': 1.0 / 60, 'min': 1, 'h': 60, 'd': 60 * 24}
+    }
+
+    round_order = {
+        'TB': 'GB', 'GB': 'MB', 'MB': 'kB', 'kB': 'B',
+        'd': 'h', 'h': 'min', 'min': 's', 's': 'ms', 'ms': 'us'
+    }
+
+    if base_unit and base_unit not in convert:
+        base_value, base_unit = strtol(base_unit, False)
+    else:
+        base_value = 1
+
+    if base_unit in convert and unit in convert[base_unit]:
+        value *= convert[base_unit][unit] / float(base_value)
+
+        if unit in round_order:
+            multiplier = convert[base_unit][round_order[unit]]
+            value = rint(value / float(multiplier)) * multiplier
+
+        return value


 def parse_int(value, base_unit=None):
@@ -136,56 +180,71 @@ def parse_int(value, base_unit=None):
    True
    >>> parse_int('1000 ms', 's') == 1
    True
-    >>> parse_int('1GB', 'MB') is None
+    >>> parse_int('1TB', 'GB') is None
    True
    >>> parse_int(0) == 0
    True
+    >>> parse_int('6GB', '16MB') == 384
+    True
+    >>> parse_int('4097.4kB', 'kB') == 4097
+    True
+    >>> parse_int('4097.5kB', 'kB') == 4098
+    True
    """

-    convert = {
-        'kB': {'kB': 1, 'MB': 1024, 'GB': 1024 * 1024, 'TB': 1024 * 1024 * 1024},
-        'ms': {'ms': 1, 's': 1000, 'min': 1000 * 60, 'h': 1000 * 60 * 60, 'd': 1000 * 60 * 60 * 24},
-        's': {'ms': -1000, 's': 1, 'min': 60, 'h': 60 * 60, 'd': 60 * 60 * 24},
-        'min': {'ms': -1000 * 60, 's': -60, 'min': 1, 'h': 60, 'd': 60 * 24}
-    }
+    val, unit = strtol(value)
+    if val is None and unit.startswith('.') or unit and unit[0] in ('.', 'e', 'E'):
+        val, unit = strtod(value)

-    value, unit = strtol(value)
-    if value is not None:
+    if val is not None:
+        unit = unit.strip()
        if not unit:
-            return value
+            return int(rint(val))

-        if base_unit and base_unit not in convert:
-            base_value, base_unit = strtol(base_unit, False)
-        else:
-            base_value = 1
-        if base_unit in convert and unit in convert[base_unit]:
-            multiplier = convert[base_unit][unit]
-            if multiplier < 0:
-                value /= -multiplier
-            else:
-                value *= multiplier
-            return int(value/base_value)
+        val = convert_to_base_unit(val, unit, base_unit)
+        if val is not None:
+            return int(rint(val))
+
+
+def parse_real(value, base_unit=None):
+    """
+    >>> parse_real(' +0.0005 ') == 0.0005
+    True
+    >>> parse_real('0.0005ms', 'ms') == 0.0
+    True
+    >>> parse_real('0.00051ms', 'ms') == 0.001
+    True
+    """
+    val, unit = strtod(value)
+
+    if val is not None:
+        unit = unit.strip()
+        if not unit:
+            return val
+
+        return convert_to_base_unit(val, unit, base_unit)


 def compare_values(vartype, unit, old_value, new_value):
    """
    >>> compare_values('enum', None, 'remote_write', 'REMOTE_WRITE')
    True
-    >>> compare_values('real', None, '1.23', 1.23)
+    >>> compare_values('real', None, '1e-06', 0.000001)
    True
    """

-    # if the integer or bool new_value is not correct this function will return False
-    if vartype == 'bool':
-        old_value = parse_bool(old_value)
-        new_value = parse_bool(new_value)
-    elif vartype == 'integer':
-        old_value = parse_int(old_value)
-        new_value = parse_int(new_value, unit)
-    elif vartype == 'enum':
-        return str(old_value).lower() == str(new_value).lower()
-    else:  # ('string', 'real')
-        return str(old_value) == str(new_value)
+    converters = {
+        'bool': lambda v1, v2: parse_bool(v1),
+        'integer': parse_int,
+        'real': parse_real,
+        'enum': lambda v1, v2: str(v1).lower(),
+        'string': lambda v1, v2: str(v1)
+    }
+
+    convert = converters.get(vartype) or converters['string']
+    old_value = convert(old_value, None)
+    new_value = convert(new_value, unit)
+
    return old_value is not None and new_value is not None and old_value == new_value


@@ -252,17 +311,19 @@ class Retry(object):
                if self.deadline is not None and self._cur_stoptime is None:
                    self._cur_stoptime = time.time() + self.deadline
                return func(*args, **kwargs)
-            except self.retry_exceptions:
+            except self.retry_exceptions as e:
                # Note: max_tries == -1 means infinite tries.
                if self._attempts == self.max_tries:
+                    logger.warning('Retry got exception: %s', e)
                    raise RetryFailedError("Too many retry attempts")
                self._attempts += 1
                sleeptime = self._cur_delay + (random.randint(0, self.max_jitter) / 100.0)

                if self._cur_stoptime is not None and time.time() + sleeptime >= self._cur_stoptime:
+                    logger.warning('Retry got exception: %s', e)
                    raise RetryFailedError("Exceeded retry deadline")
-                else:
-                    self.sleep_func(sleeptime)
+                logger.debug('Retry got exception: %s', e)
+                self.sleep_func(sleeptime)
                self._cur_delay = min(self._cur_delay * self.backoff, self.max_delay)


@@ -281,3 +342,13 @@ def split_host_port(value, default_port):
    t = value.rsplit(':', 1)
    t.append(default_port)
    return t[0], int(t[1])
+
+
+def uri(proto, netloc, path='', user=None):
+    host, port = netloc if isinstance(netloc, (list, tuple)) else split_host_port(netloc, 0)
+    if host and ':' in host and host[0] != '[' and host[-1] != ']':
+        host = '[{0}]'.format(host)
+    port = ':{0}'.format(port) if port else ''
+    path = '/{0}'.format(path) if path and not path.startswith('/') else path
+    user = '{0}@'.format(user) if user else ''
+    return '{0}://{1}{2}{3}{4}'.format(proto, user, host, port, path)
@@ -1 +1 @@
-__version__ = '1.5.1'
+__version__ = '1.6.0'
@@ -1,6 +1,5 @@
 import collections
 import ctypes
-import fcntl
 import os
 import platform
 from patroni.watchdog.base import WatchdogBase, WatchdogError
@@ -162,7 +161,9 @@ class LinuxWatchdogDevice(WatchdogBase):
        Raises OSError or IOError (Python 2) when the ioctl fails."""
        if self._fd is None:
            raise WatchdogError("Watchdog device is closed")
-        fcntl.ioctl(self._fd, func, arg, True)
+        if os.name != 'nt':
+            import fcntl
+            fcntl.ioctl(self._fd, func, arg, True)

    def get_support(self):
        if self._support_cache is None:
@@ -55,6 +55,9 @@ bootstrap:
  - data-checksums

  pg_hba:  # Add following lines to pg_hba.conf after running 'initdb'
+  # For kerberos gss based connectivity (discard @.*$)
+  #- host replication replicator 127.0.0.1/32 gss include_realm=0
+  #- host all all 0.0.0.0/0 gss include_realm=0
  - host replication replicator 127.0.0.1/32 md5
  - host all all 0.0.0.0/0 md5
 #  - hostssl all all 0.0.0.0/0 md5
@@ -84,7 +87,15 @@ postgresql:
    superuser:
      username: postgres
      password: zalando
+    rewind:  # Has no effect on postgres 10 and lower
+      username: rewind_user
+      password: rewind_password
+  # Server side kerberos spn
+#  krbsrvname: postgres
  parameters:
+    # Fully qualified kerberos ticket file for the running user
+    # same as KRB5CCNAME used by the GSS
+#   krb_server_keyfile: /var/spool/keytabs/postgres
    unix_socket_directories: '.'

 #watchdog:
@@ -49,6 +49,9 @@ bootstrap:
  - data-checksums

  pg_hba:  # Add following lines to pg_hba.conf after running 'initdb'
+  # For kerberos gss based connectivity (discard @.*$)
+  #- host replication replicator 127.0.0.1/32 gss include_realm=0
+  #- host all all 0.0.0.0/0 gss include_realm=0
  - host replication replicator 127.0.0.1/32 md5
  - host all all 0.0.0.0/0 md5
 #  - hostssl all all 0.0.0.0/0 md5
@@ -78,7 +81,15 @@ postgresql:
    superuser:
      username: postgres
      password: zalando
+    rewind:  # Has no effect on postgres 10 and lower
+      username: rewind_user
+      password: rewind_password
+  # Server side kerberos spn
+#  krbsrvname: postgres
  parameters:
+    # Fully qualified kerberos ticket file for the running user
+    # same as KRB5CCNAME used by the GSS
+#    krb_server_keyfile: /var/spool/keytabs/postgres
    unix_socket_directories: '.'
  basebackup:
      - verbose
@@ -49,6 +49,9 @@ bootstrap:
  - data-checksums

  pg_hba:  # Add following lines to pg_hba.conf after running 'initdb'
+  # For kerberos gss based connectivity (discard @.*$)
+  #- host replication replicator 127.0.0.1/32 gss include_realm=0
+  #- host all all 0.0.0.0/0 gss include_realm=0
  - host replication replicator 127.0.0.1/32 md5
  - host all all 0.0.0.0/0 md5
 #  - hostssl all all 0.0.0.0/0 md5
@@ -75,7 +78,15 @@ postgresql:
    superuser:
      username: postgres
      password: zalando
+    rewind:  # Has no effect on postgres 10 and lower
+      username: rewind_user
+      password: rewind_password
+  # Server side kerberos spn
+#  krbsrvname: postgres
  parameters:
+    # Fully qualified kerberos ticket file for the running user
+    # same as KRB5CCNAME used by the GSS
+#    krb_server_keyfile: /var/spool/keytabs/postgres
    unix_socket_directories: '.'
 tags:
    nofailover: false
@@ -1,6 +1,5 @@
 urllib3>=1.19.1,!=1.21
 boto
-psycopg2>=2.5.4
 PyYAML
 requests
 six >= 1.7
@@ -11,6 +10,6 @@ click>=4.1
 prettytable>=0.7
 tzlocal
 python-dateutil
-psutil
+psutil>=2.0.0
 cdiff
 kubernetes>=2.0.0,<=7.0.0,!=4.0.*,!=5.0.*
@@ -8,27 +8,22 @@ import inspect
 import os
 import sys

+from patroni import check_psycopg2, fatal
+from patroni.version import __version__ as VERSION
 from setuptools.command.test import test as TestCommand
 from setuptools import find_packages, setup

 if sys.version_info < (2, 7, 0):
-    sys.stderr.write('FATAL: patroni needs to be run with Python 2.7+\n')
-    sys.exit(1)
+    fatal('patroni needs to be run with Python 2.7+')
+check_psycopg2()
+del sys.modules['patroni']
+del sys.modules['patroni.version']

 __location__ = os.path.join(os.getcwd(), os.path.dirname(inspect.getfile(inspect.currentframe())))

-
-def read_version(package):
-    data = {}
-    with open(os.path.join(package, 'version.py'), 'r') as fd:
-        exec(fd.read(), data)
-    return data['__version__']
-
-
 NAME = 'patroni'
 MAIN_PACKAGE = NAME
 SCRIPTS = 'scripts'
-VERSION = read_version(MAIN_PACKAGE)
 DESCRIPTION = 'PostgreSQL High-Available orchestrator and CLI'
 LICENSE = 'The MIT License'
 URL = 'https://github.com/zalando/patroni'
@@ -113,27 +108,23 @@ class PyTest(TestCommand):
        sys.exit(errno)


-def get_install_requirements(path):
-    content = open(os.path.join(__location__, path)).read()
-    return [req for req in content.split('\n') if req != '']
-
-
 def read(fname):
-    return open(os.path.join(__location__, fname)).read()
+    with open(os.path.join(__location__, fname)) as fd:
+        return fd.read()


 def setup_package():
    # Assemble additional setup commands
    cmdclass = {'test': PyTest}

-    # Some helper variables
-    version = os.getenv('GO_PIPELINE_LABEL', VERSION)
-
    install_requires = []
    extras_require = {'aws': ['boto'], 'etcd': ['python-etcd'], 'consul': ['python-consul'],
                      'exhibitor': ['kazoo'], 'zookeeper': ['kazoo'], 'kubernetes': ['kubernetes']}

-    for r in get_install_requirements('requirements.txt'):
+    for r in read('requirements.txt').split('\n'):
+        r = r.strip()
+        if r == '':
+            continue
        extra = False
        for e, v in extras_require.items():
            if r.startswith(v[0]):
@@ -152,7 +143,7 @@ def setup_package():

    setup(
        name=NAME,
-        version=version,
+        version=VERSION,
        url=URL,
        author=AUTHOR,
        author_email=AUTHOR_EMAIL,
@@ -0,0 +1,216 @@
+import datetime
+import json
+import os
+import shutil
+import unittest
+
+from mock import Mock, patch
+from tempfile import gettempdir
+
+import psycopg2
+import requests
+
+from patroni.dcs import Leader, Member
+from patroni.postgresql import Postgresql
+from patroni.postgresql.config import ConfigHandler
+from patroni.utils import RetryFailedError
+
+
+class SleepException(Exception):
+    pass
+
+
+class MockResponse(object):
+
+    def __init__(self, status_code=200):
+        self.status_code = status_code
+        self.content = '{}'
+        self.ok = True
+
+    def json(self):
+        return json.loads(self.content)
+
+    @property
+    def data(self):
+        return self.content.encode('utf-8')
+
+    @property
+    def text(self):
+        return self.content
+
+    @property
+    def status(self):
+        return self.status_code
+
+    @staticmethod
+    def getheader(*args):
+        return ''
+
+
+def requests_get(url, **kwargs):
+    members = '[{"id":14855829450254237642,"peerURLs":["http://localhost:2380","http://localhost:7001"],' +\
+              '"name":"default","clientURLs":["http://localhost:2379","http://localhost:4001"]}]'
+    response = MockResponse()
+    if url.startswith('http://local'):
+        raise requests.exceptions.RequestException()
+    elif ':8011/patroni' in url:
+        response.content = '{"role": "replica", "xlog": {"received_location": 0}, "tags": {}}'
+    elif url.endswith('/members'):
+        response.content = '[{}]' if url.startswith('http://error') else members
+    elif url.startswith('http://exhibitor'):
+        response.content = '{"servers":["127.0.0.1","127.0.0.2","127.0.0.3"],"port":2181}'
+    elif url.endswith(':8011/reinitialize'):
+        data = kwargs.get('data', '')
+        if ' false}' in data:
+            response.status_code = 503
+            response.ok = False
+            response.content = 'restarting after failure already in progress'
+    else:
+        response.status_code = 404
+        response.ok = False
+    return response
+
+
+class MockPostmaster(object):
+    def __init__(self, is_running=True, is_single_master=False):
+        self.is_running = Mock(return_value=is_running)
+        self.is_single_master = Mock(return_value=is_single_master)
+        self.wait_for_user_backends_to_close = Mock()
+        self.signal_stop = Mock(return_value=None)
+        self.wait = Mock()
+
+
+class MockCursor(object):
+
+    def __init__(self, connection):
+        self.connection = connection
+        self.closed = False
+        self.rowcount = 0
+        self.results = []
+
+    def execute(self, sql, *params):
+        if sql.startswith('blabla'):
+            raise psycopg2.ProgrammingError()
+        elif sql == 'CHECKPOINT' or sql.startswith('SELECT pg_catalog.pg_create_'):
+            raise psycopg2.OperationalError()
+        elif sql.startswith('RetryFailedError'):
+            raise RetryFailedError('retry')
+        elif sql.startswith('SELECT slot_name'):
+            self.results = [('blabla', 'physical'), ('foobar', 'physical'), ('ls', 'logical', 'a', 'b')]
+        elif sql.startswith('SELECT CASE WHEN pg_catalog.pg_is_in_recovery()'):
+            self.results = [(1, 2)]
+        elif sql.startswith('SELECT pg_catalog.pg_is_in_recovery()'):
+            self.results = [(False, 2)]
+        elif sql.startswith('WITH replication_info AS ('):
+            replication_info = '[{"application_name":"walreceiver","client_addr":"1.2.3.4",' +\
+                               '"state":"streaming","sync_state":"async","sync_priority":0}]'
+            self.results = [('', 0, '', '', '', '', False, replication_info)]
+        elif sql.startswith('SELECT name, setting'):
+            self.results = [('wal_segment_size', '2048', '8kB', 'integer', 'internal'),
+                            ('search_path', 'public', None, 'string', 'user'),
+                            ('port', '5433', None, 'integer', 'postmaster'),
+                            ('listen_addresses', '*', None, 'string', 'postmaster'),
+                            ('autovacuum', 'on', None, 'bool', 'sighup'),
+                            ('unix_socket_directories', '/tmp', None, 'string', 'postmaster')]
+        elif sql.startswith('IDENTIFY_SYSTEM'):
+            self.results = [('1', 2, '0/402EEC0', '')]
+        elif sql.startswith('SELECT isdir, modification'):
+            self.results = [(False, datetime.datetime.now())]
+        elif sql.startswith('SELECT pg_catalog.pg_read_file'):
+            self.results = [('1\t0/40159C0\tno recovery target specified\n\n'
+                             '2\t1/40159C0\tno recovery target specified\n',)]
+        elif sql.startswith('TIMELINE_HISTORY '):
+            self.results = [('', b'x\t0/40159C0\tno recovery target specified\n\n'
+                                 b'1\t0/40159C0\tno recovery target specified\n\n'
+                                 b'2\t0/402DD98\tno recovery target specified\n\n'
+                                 b'3\t0/403DD98\tno recovery target specified\n')]
+        else:
+            self.results = [(None, None, None, None, None, None, None, None, None, None)]
+
+    def fetchone(self):
+        return self.results[0]
+
+    def fetchall(self):
+        return self.results
+
+    def __iter__(self):
+        for i in self.results:
+            yield i
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
+class MockConnect(object):
+
+    server_version = 99999
+    autocommit = False
+    closed = 0
+
+    def cursor(self):
+        return MockCursor(self)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    @staticmethod
+    def close():
+        pass
+
+
+def psycopg2_connect(*args, **kwargs):
+    return MockConnect()
+
+
+class PostgresInit(unittest.TestCase):
+    _PARAMETERS = {'wal_level': 'hot_standby', 'max_replication_slots': 5, 'f.oo': 'bar',
+                   'search_path': 'public', 'hot_standby': 'on', 'max_wal_senders': 5,
+                   'wal_keep_segments': 8, 'wal_log_hints': 'on', 'max_locks_per_transaction': 64,
+                   'max_worker_processes': 8, 'max_connections': 100, 'max_prepared_transactions': 0,
+                   'track_commit_timestamp': 'off', 'unix_socket_directories': '/tmp', 'trigger_file': 'bla'}
+
+    @patch('psycopg2.connect', psycopg2_connect)
+    @patch.object(ConfigHandler, 'write_postgresql_conf', Mock())
+    @patch.object(ConfigHandler, 'replace_pg_hba', Mock())
+    @patch.object(ConfigHandler, 'replace_pg_ident', Mock())
+    def setUp(self):
+        data_dir = 'data/test0'
+        self.p = Postgresql({'name': 'postgresql0', 'scope': 'batman', 'data_dir': data_dir,
+                             'config_dir': data_dir, 'retry_timeout': 10,
+                             'krbsrvname': 'postgres', 'pgpass': os.path.join(gettempdir(), 'pgpass0'),
+                             'listen': '127.0.0.2, 127.0.0.3:5432', 'connect_address': '127.0.0.2:5432',
+                             'authentication': {'superuser': {'username': 'foo', 'password': 'test'},
+                                                'replication': {'username': '', 'password': 'rep-pass'}},
+                             'remove_data_directory_on_rewind_failure': True,
+                             'use_pg_rewind': True, 'pg_ctl_timeout': 'bla',
+                             'parameters': self._PARAMETERS,
+                             'recovery_conf': {'foo': 'bar'},
+                             'pg_hba': ['host all all 0.0.0.0/0 md5'],
+                             'pg_ident': ['krb realm postgres'],
+                             'callbacks': {'on_start': 'true', 'on_stop': 'true', 'on_reload': 'true',
+                                           'on_restart': 'true', 'on_role_change': 'true'}})
+
+
+class BaseTestPostgresql(PostgresInit):
+
+    def setUp(self):
+        super(BaseTestPostgresql, self).setUp()
+
+        if not os.path.exists(self.p.data_dir):
+            os.makedirs(self.p.data_dir)
+
+        self.leadermem = Member(0, 'leader', 28, {'conn_url': 'postgres://replicator:[email protected]:5435/postgres'})
+        self.leader = Leader(-1, 28, self.leadermem)
+        self.other = Member(0, 'test-1', 28, {'conn_url': 'postgres://replicator:[email protected]:5433/postgres',
+                                              'tags': {'replicatefrom': 'leader'}})
+        self.me = Member(0, 'test0', 28, {'conn_url': 'postgres://replicator:[email protected]:5434/postgres'})
+
+    def tearDown(self):
+        if os.path.exists(self.p.data_dir):
+            shutil.rmtree(self.p.data_dir)
@@ -2,6 +2,7 @@ import datetime
 import json
 import psycopg2
 import unittest
+import socket

 from mock import Mock, PropertyMock, patch
 from patroni.api import RestApiHandler, RestApiServer
@@ -10,7 +11,7 @@ from patroni.ha import _MemberStatus
 from patroni.utils import tzutc
 from six import BytesIO as IO
 from six.moves import BaseHTTPServer
-from test_postgresql import psycopg2_connect, MockCursor
+from . import psycopg2_connect, MockCursor


 future_restart_time = datetime.datetime.now(tzutc) + datetime.timedelta(days=5)
@@ -60,7 +61,7 @@ class MockHa(object):
        return 'reinitialize'

    @staticmethod
-    def restart():
+    def restart(*args, **kwargs):
        return (True, '')

    @staticmethod
@@ -73,7 +74,7 @@ class MockHa(object):

    @staticmethod
    def fetch_nodes_statuses(members):
-        return [_MemberStatus(None, True, None, None, {}, False)]
+        return [_MemberStatus(None, True, None, 0, None, {}, False)]

    @staticmethod
    def schedule_future_restart(data):
@@ -100,12 +101,20 @@ class MockHa(object):
        return False


+class MockLogger(object):
+
+    NORMAL_LOG_QUEUE_SIZE = 2
+    queue_size = 3
+    records_lost = 1
+
+
 class MockPatroni(object):

    ha = MockHa()
    config = Mock()
    postgresql = ha.state_handler
    dcs = Mock()
+    logger = MockLogger()
    tags = {}
    version = '0.00'
    noloadbalance = PropertyMock(return_value=False)
@@ -134,7 +143,6 @@ class MockRestApiServer(RestApiServer):
    def __init__(self, Handler, request, config=None):
        self.socket = 0
        self.serve_forever = Mock()
-        BaseHTTPServer.HTTPServer.__init__ = Mock()
        MockRestApiServer._BaseServer__is_shut_down = Mock()
        MockRestApiServer._BaseServer__shutdown_request = True
        config = config or {'listen': '127.0.0.1:8008', 'auth': 'test:test', 'certfile': 'dumb'}
@@ -142,7 +150,9 @@ class MockRestApiServer(RestApiServer):
        Handler(MockRequest(request), ('0.0.0.0', 8080), self)


-@patch('ssl.wrap_socket', Mock(return_value=0))
+@patch('ssl.SSLContext.load_cert_chain', Mock())
+@patch('ssl.SSLContext.wrap_socket', Mock(return_value=0))
+@patch.object(BaseHTTPServer.HTTPServer, '__init__', Mock())
 class TestRestApiHandler(unittest.TestCase):

    _authorization = '\nAuthorization: Basic dGVzdDp0ZXN0'
@@ -153,6 +163,8 @@ class TestRestApiHandler(unittest.TestCase):
            MockRestApiServer(RestApiHandler, 'GET /replica')
        with patch.object(RestApiHandler, 'get_postgresql_status', Mock(return_value={'role': 'master'})):
            MockRestApiServer(RestApiHandler, 'GET /replica')
+        with patch.object(RestApiHandler, 'get_postgresql_status', Mock(return_value={'state': 'running'})):
+            MockRestApiServer(RestApiHandler, 'GET /health')
        MockRestApiServer(RestApiHandler, 'GET /master')
        MockPatroni.dcs.cluster.sync.sync_standby = MockPostgresql.name
        MockPatroni.dcs.cluster.is_synchronous_mode = Mock(return_value=True)
@@ -391,7 +403,9 @@ class TestRestApiHandler(unittest.TestCase):
        MockRestApiServer(RestApiHandler, post + '37\n\n{"candidate":"2","scheduled_at": "1"}')


-@patch('ssl.wrap_socket', Mock(return_value=0))
+@patch('ssl.SSLContext.load_cert_chain', Mock())
+@patch('ssl.SSLContext.wrap_socket', Mock(return_value=0))
+@patch.object(BaseHTTPServer.HTTPServer, '__init__', Mock())
 class TestRestApiServer(unittest.TestCase):

    def test_reload_config(self):
@@ -400,4 +414,11 @@ class TestRestApiServer(unittest.TestCase):
        srv = MockRestApiServer(lambda a1, a2, a3: None, '')
        self.assertRaises(ValueError, srv.reload_config, bad_config)
        self.assertRaises(ValueError, srv.reload_config, {})
-        srv.reload_config({'listen': '127.0.0.2:8008'})
+        with patch.object(socket.socket, 'setsockopt', Mock(side_effect=socket.error)):
+            srv.reload_config({'listen': ':8008'})
+
+    def test_handle_error(self):
+        try:
+            raise Exception()
+        except Exception:
+            self.assertIsNone(MockRestApiServer.handle_error(None, ('127.0.0.1', 55555)))
@@ -0,0 +1,220 @@
+import os
+
+from mock import Mock, PropertyMock, patch
+
+from patroni.async_executor import CriticalTask
+from patroni.postgresql import Postgresql
+from patroni.postgresql.bootstrap import Bootstrap
+from patroni.postgresql.cancellable import CancellableSubprocess
+from patroni.postgresql.config import ConfigHandler
+
+from . import psycopg2_connect, BaseTestPostgresql
+
+
+@patch('subprocess.call', Mock(return_value=0))
+@patch('psycopg2.connect', psycopg2_connect)
+@patch('os.rename', Mock())
+class TestBootstrap(BaseTestPostgresql):
+
+    def setUp(self):
+        super(TestBootstrap, self).setUp()
+        self.b = self.p.bootstrap
+
+    @patch('time.sleep', Mock())
+    @patch.object(CancellableSubprocess, 'call')
+    @patch.object(Postgresql, 'remove_data_directory', Mock(return_value=True))
+    @patch.object(Postgresql, 'data_directory_empty', Mock(return_value=False))
+    @patch.object(Bootstrap, '_post_restore', Mock(side_effect=OSError))
+    def test_create_replica(self, mock_cancellable_subprocess_call):
+        self.p.config._config['create_replica_methods'] = ['pgBackRest']
+        self.p.config._config['pgBackRest'] = {'command': 'pgBackRest', 'keep_data': True, 'no_params': True}
+        mock_cancellable_subprocess_call.return_value = 0
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+
+        self.p.config._config['create_replica_methods'] = ['basebackup']
+        self.p.config._config['basebackup'] = [{'max_rate': '100M'}, 'no-sync']
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+
+        self.p.config._config['basebackup'] = [{'max_rate': '100M', 'compress': '9'}]
+        with patch('patroni.postgresql.bootstrap.logger.error', new_callable=Mock()) as mock_logger:
+            self.b.create_replica(self.leader)
+            mock_logger.assert_called_once()
+            self.assertTrue("only one key-value is allowed and value should be a string" in mock_logger.call_args[0][0],
+                            "not matching {0}".format(mock_logger.call_args[0][0]))
+
+        self.p.config._config['basebackup'] = [42]
+        with patch('patroni.postgresql.bootstrap.logger.error', new_callable=Mock()) as mock_logger:
+            self.b.create_replica(self.leader)
+            mock_logger.assert_called_once()
+            self.assertTrue("value should be string value or a single key-value pair" in mock_logger.call_args[0][0],
+                            "not matching {0}".format(mock_logger.call_args[0][0]))
+
+        self.p.config._config['basebackup'] = {"foo": "bar"}
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+
+        self.p.config._config['create_replica_methods'] = ['wale', 'basebackup']
+        del self.p.config._config['basebackup']
+        mock_cancellable_subprocess_call.return_value = 1
+        self.assertEqual(self.b.create_replica(self.leader), 1)
+
+        mock_cancellable_subprocess_call.side_effect = Exception('foo')
+        self.assertEqual(self.b.create_replica(self.leader), 1)
+
+        mock_cancellable_subprocess_call.side_effect = [1, 0]
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+
+        mock_cancellable_subprocess_call.side_effect = [Exception(), 0]
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+
+        self.p.cancellable.cancel()
+        self.assertEqual(self.b.create_replica(self.leader), 1)
+
+    @patch('time.sleep', Mock())
+    @patch.object(CancellableSubprocess, 'call')
+    @patch.object(Postgresql, 'remove_data_directory', Mock(return_value=True))
+    @patch.object(Bootstrap, '_post_restore', Mock(side_effect=OSError))
+    def test_create_replica_old_format(self, mock_cancellable_subprocess_call):
+        """ The same test as before but with old 'create_replica_method'
+            to test backward compatibility
+        """
+        self.p.config._config['create_replica_method'] = ['wale', 'basebackup']
+        self.p.config._config['wale'] = {'command': 'foo'}
+        mock_cancellable_subprocess_call.return_value = 0
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+        del self.p.config._config['wale']
+        self.assertEqual(self.b.create_replica(self.leader), 0)
+
+        self.p.config._config['create_replica_method'] = ['wale']
+        mock_cancellable_subprocess_call.return_value = 1
+        self.assertEqual(self.b.create_replica(self.leader), 1)
+
+    def test_basebackup(self):
+        self.p.cancellable.cancel()
+        self.b.basebackup(None, None, {'foo': 'bar'})
+
+    def test__initdb(self):
+        self.assertRaises(Exception, self.b.bootstrap, {'initdb': [{'pgdata': 'bar'}]})
+        self.assertRaises(Exception, self.b.bootstrap, {'initdb': [{'foo': 'bar', 1: 2}]})
+        self.assertRaises(Exception, self.b.bootstrap, {'initdb': [1]})
+        self.assertRaises(Exception, self.b.bootstrap, {'initdb': 1})
+
+    @patch.object(CancellableSubprocess, 'call', Mock())
+    @patch.object(Postgresql, 'is_running', Mock(return_value=True))
+    @patch.object(Postgresql, 'data_directory_empty', Mock(return_value=False))
+    def test_bootstrap(self):
+        with patch('subprocess.call', Mock(return_value=1)):
+            self.assertFalse(self.b.bootstrap({}))
+
+        config = {'users': {'replicator': {'password': 'rep-pass', 'options': ['replication']}}}
+
+        with patch.object(Postgresql, 'is_running', Mock(return_value=False)),\
+                patch('multiprocessing.Process', Mock(side_effect=Exception)):
+            self.assertRaises(Exception, self.b.bootstrap, config)
+        with open(os.path.join(self.p.data_dir, 'pg_hba.conf')) as f:
+            lines = f.readlines()
+            self.assertTrue('host all all 0.0.0.0/0 md5\n' in lines)
+
+        self.p.config._config.pop('pg_hba')
+        config.update({'post_init': '/bin/false',
+                       'pg_hba': ['host replication replicator 127.0.0.1/32 md5',
+                                  'hostssl all all 0.0.0.0/0 md5',
+                                  'host all all 0.0.0.0/0 md5']})
+        self.b.bootstrap(config)
+        with open(os.path.join(self.p.data_dir, 'pg_hba.conf')) as f:
+            lines = f.readlines()
+            self.assertTrue('host replication replicator 127.0.0.1/32 md5\n' in lines)
+
+    @patch.object(CancellableSubprocess, 'call')
+    @patch.object(Postgresql, 'get_major_version', Mock(return_value=90600))
+    def test_custom_bootstrap(self, mock_cancellable_subprocess_call):
+        self.p.config._config.pop('pg_hba')
+        config = {'method': 'foo', 'foo': {'command': 'bar'}}
+
+        mock_cancellable_subprocess_call.return_value = 1
+        self.assertFalse(self.b.bootstrap(config))
+
+        mock_cancellable_subprocess_call.return_value = 0
+        with patch('multiprocessing.Process', Mock(side_effect=Exception("42"))),\
+                patch('os.path.isfile', Mock(return_value=True)),\
+                patch('os.unlink', Mock()),\
+                patch.object(ConfigHandler, 'save_configuration_files', Mock()),\
+                patch.object(ConfigHandler, 'restore_configuration_files', Mock()),\
+                patch.object(ConfigHandler, 'write_recovery_conf', Mock()):
+            with self.assertRaises(Exception) as e:
+                self.b.bootstrap(config)
+            self.assertEqual(str(e.exception), '42')
+
+            config['foo']['recovery_conf'] = {'foo': 'bar'}
+
+            with self.assertRaises(Exception) as e:
+                self.b.bootstrap(config)
+            self.assertEqual(str(e.exception), '42')
+
+        mock_cancellable_subprocess_call.side_effect = Exception
+        self.assertFalse(self.b.bootstrap(config))
+
+    @patch('time.sleep', Mock())
+    @patch('os.unlink', Mock())
+    @patch('shutil.copy', Mock())
+    @patch('os.path.isfile', Mock(return_value=True))
+    @patch.object(Bootstrap, 'call_post_bootstrap', Mock(return_value=True))
+    @patch.object(Bootstrap, '_custom_bootstrap', Mock(return_value=True))
+    @patch.object(Postgresql, 'start', Mock(return_value=True))
+    @patch.object(Postgresql, 'get_major_version', Mock(return_value=110000))
+    def test_post_bootstrap(self):
+        config = {'method': 'foo', 'foo': {'command': 'bar'}}
+        self.b.bootstrap(config)
+
+        task = CriticalTask()
+        with patch.object(Bootstrap, 'create_or_update_role', Mock(side_effect=Exception)):
+            self.b.post_bootstrap({}, task)
+            self.assertFalse(task.result)
+
+        self.p.config._config.pop('pg_hba')
+        self.b.post_bootstrap({}, task)
+        self.assertTrue(task.result)
+
+        self.b.bootstrap(config)
+        with patch.object(Postgresql, 'pending_restart', PropertyMock(return_value=True)), \
+                patch.object(Postgresql, 'restart', Mock()) as mock_restart:
+            self.b.post_bootstrap({}, task)
+            mock_restart.assert_called_once()
+
+        self.b.bootstrap(config)
+        self.p.set_state('stopped')
+        self.p.reload_config({'authentication': {'superuser': {'username': 'p', 'password': 'p'},
+                                                 'replication': {'username': 'r', 'password': 'r'},
+                                                 'rewind': {'username': 'rw', 'password': 'rw'}},
+                              'listen': '*', 'retry_timeout': 10, 'parameters': {'wal_level': '', 'hba_file': 'foo'}})
+        with patch.object(Postgresql, 'major_version', PropertyMock(return_value=110000)), \
+                patch.object(Postgresql, 'restart', Mock()) as mock_restart:
+            self.b.post_bootstrap({}, task)
+            mock_restart.assert_called_once()
+
+    @patch.object(CancellableSubprocess, 'call')
+    def test_call_post_bootstrap(self, mock_cancellable_subprocess_call):
+        mock_cancellable_subprocess_call.return_value = 1
+        self.assertFalse(self.b.call_post_bootstrap({'post_init': '/bin/false'}))
+
+        mock_cancellable_subprocess_call.return_value = 0
+        self.p.config.superuser.pop('username')
+        self.assertTrue(self.b.call_post_bootstrap({'post_init': '/bin/false'}))
+        mock_cancellable_subprocess_call.assert_called()
+        args, kwargs = mock_cancellable_subprocess_call.call_args
+        self.assertTrue('PGPASSFILE' in kwargs['env'])
+        self.assertEqual(args[0], ['/bin/false', 'postgres://127.0.0.2:5432/postgres'])
+
+        mock_cancellable_subprocess_call.reset_mock()
+        self.p.config._local_address.pop('host')
+        self.assertTrue(self.b.call_post_bootstrap({'post_init': '/bin/false'}))
+        mock_cancellable_subprocess_call.assert_called()
+        self.assertEqual(mock_cancellable_subprocess_call.call_args[0][0], ['/bin/false', 'postgres://:5432/postgres'])
+
+        mock_cancellable_subprocess_call.side_effect = OSError
+        self.assertFalse(self.b.call_post_bootstrap({'post_init': '/bin/false'}))
+
+    @patch('os.path.exists', Mock(return_value=True))
+    @patch('os.unlink', Mock())
+    @patch.object(Bootstrap, 'create_replica', Mock(return_value=0))
+    def test_clone(self):
+        self.b.clone(self.leader)
@@ -1,7 +1,7 @@
 import unittest

 from mock import Mock, patch
-from patroni.callback_executor import CallbackExecutor
+from patroni.postgresql.callback_executor import CallbackExecutor


 class TestCallbackExecutor(unittest.TestCase):
@@ -17,6 +17,9 @@ class TestCallbackExecutor(unittest.TestCase):

        self.assertIsNone(ce.call([]))

+        mock_popen.return_value.kill.side_effect = OSError
+        self.assertIsNone(ce.call([]))
+
        mock_popen.side_effect = Exception
        ce = CallbackExecutor()
        ce._callback_event.wait = Mock(side_effect=[None, Exception])
@@ -0,0 +1,23 @@
+import unittest
+
+from mock import Mock, PropertyMock, patch
+from patroni.exceptions import PostgresException
+from patroni.postgresql.cancellable import CancellableSubprocess
+
+
+class TestCancellableSubprocess(unittest.TestCase):
+
+    def setUp(self):
+        self.c = CancellableSubprocess()
+
+    def test_call(self):
+        self.c.cancel()
+        self.assertRaises(PostgresException, self.c.call, communicate_input=None)
+
+    @patch('patroni.postgresql.cancellable.polling_loop', Mock(return_value=[0, 0]))
+    def test_cancel(self):
+        self.c._process = Mock()
+        self.c._process.returncode = None
+        self.c.cancel()
+        type(self.c._process).returncode = PropertyMock(side_effect=[None, -15])
+        self.c.cancel()
@@ -1,6 +1,6 @@
 import os
-import unittest
 import sys
+import unittest

 from mock import MagicMock, Mock, patch
 from patroni.config import Config
@@ -30,6 +30,8 @@ class TestConfig(unittest.TestCase):
            'PATRONI_NAME': 'postgres0',
            'PATRONI_NAMESPACE': '/patroni/',
            'PATRONI_SCOPE': 'batman2',
+            'PATRONI_LOGLEVEL': 'ERROR',
+            'PATRONI_LOG_LOGGERS': 'patroni.postmaster: WARNING, urllib3: DEBUG',
            'PATRONI_RESTAPI_USERNAME': 'username',
            'PATRONI_RESTAPI_PASSWORD': 'password',
            'PATRONI_RESTAPI_LISTEN': '0.0.0.0:8008',
@@ -49,7 +51,8 @@ class TestConfig(unittest.TestCase):
            'PATRONI_ETCD_CERT': '/cert',
            'PATRONI_ETCD_KEY': '/key',
            'PATRONI_CONSUL_HOST': '127.0.0.1:8500',
-            'PATRONI_KUBERNETES_LABELS': 'a:b:c',
+            'PATRONI_CONSUL_REGISTER_SERVICE': 'on',
+            'PATRONI_KUBERNETES_LABELS': 'a: b: c',
            'PATRONI_KUBERNETES_SCOPE_LABEL': 'a',
            'PATRONI_KUBERNETES_PORTS': '[{"name": "postgresql"}]',
            'PATRONI_ZOOKEEPER_HOSTS': "'host1:2181','host2:2181'",
@@ -84,3 +87,15 @@ class TestConfig(unittest.TestCase):
            self.config.save_cache()
        with patch('os.fdopen', MagicMock()):
            self.config.save_cache()
+
+    def test_standby_cluster_parameters(self):
+        dynamic_configuration = {
+            'standby_cluster': {
+                'create_replica_methods': ['wal_e', 'basebackup'],
+                'host': 'localhost',
+                'port': 5432
+            }
+        }
+        self.config.set_dynamic_configuration(dynamic_configuration)
+        for name, value in dynamic_configuration['standby_cluster'].items():
+            self.assertEqual(self.config['standby_cluster'][name], value)
@@ -4,8 +4,8 @@ import unittest
 from consul import ConsulException, NotFound
 from mock import Mock, patch
 from patroni.dcs.consul import AbstractDCS, Cluster, Consul, ConsulInternalError, \
-                                ConsulError, HTTPClient, InvalidSessionTTL
-from test_etcd import SleepException
+                                ConsulError, HTTPClient, InvalidSessionTTL, InvalidSession
+from . import SleepException


 def kv_get(self, key, **kwargs):
@@ -52,6 +52,8 @@ class TestHTTPClient(unittest.TestCase):
        self.assertRaises(ConsulInternalError, self.client.get, Mock(), '')
        self.client.http.request.return_value.data = b"Invalid Session TTL '3000000000', must be between [10s=24h0m0s]"
        self.assertRaises(InvalidSessionTTL, self.client.get, Mock(), '')
+        self.client.http.request.return_value.data = b"invalid session '16492f43-c2d6-5307-432f-e32d6f7bcbd0'"
+        self.assertRaises(InvalidSession, self.client.get, Mock(), '')

    def test_unknown_method(self):
        try:
@@ -81,7 +83,7 @@ class TestConsul(unittest.TestCase):
        self.c = Consul({'ttl': 30, 'scope': 'test', 'name': 'postgresql1', 'host': 'localhost:1', 'retry_timeout': 10,
                         'register_service': True})
        self.c._base_path = '/service/good'
-        self.c._load_cluster()
+        self.c.get_cluster()

    @patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(consul.Consul.Session, 'create', Mock(side_effect=ConsulException))
@@ -110,19 +112,18 @@ class TestConsul(unittest.TestCase):
        self.c._session = 'fd4f44fe-2cac-bba5-a60b-304b51ff39b8'
        self.assertIsInstance(self.c.get_cluster(), Cluster)

-    @patch.object(consul.Consul.KV, 'delete', Mock(side_effect=[ConsulException, True, True]))
-    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=[True, ConsulException]))
+    @patch.object(consul.Consul.KV, 'delete', Mock(side_effect=[ConsulException, True, True, True]))
+    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=[True, ConsulException, InvalidSession]))
    def test_touch_member(self):
-        self.c._register_service = True
-        self.c.refresh_session = Mock(return_value=True)
-        self.c.touch_member({'balbla': 'blabla'})
-        self.c.touch_member({'balbla': 'blabla'})
-        self.c.touch_member({'balbla': 'blabla'})
        self.c.refresh_session = Mock(return_value=False)
        self.c.touch_member({'conn_url': 'postgres://replicator:[email protected]:5433/postgres',
                             'api_url': 'http://127.0.0.1:8009/patroni'})
+        self.c._register_service = True
+        self.c.refresh_session = Mock(return_value=True)
+        for _ in range(0, 4):
+            self.c.touch_member({'balbla': 'blabla'})

-    @patch.object(consul.Consul.KV, 'put', Mock(return_value=False))
+    @patch.object(consul.Consul.KV, 'put', Mock(side_effect=InvalidSession))
    def test_take_leader(self):
        self.c.set_ttl(20)
        self.c.refresh_session = Mock()
@@ -196,3 +197,6 @@ class TestConsul(unittest.TestCase):
        d['state'] = 'running'
        d['role'] = 'bla'
        self.assertIsNone(self.c.update_service({}, d))
+
+    def test_reload_config(self):
+        self.c.reload_config({'consul': {'token': 'foo'}, 'loop_wait': 10, 'ttl': 30, 'retry_timeout': 10})
@@ -13,10 +13,11 @@ from patroni.ctl import ctl, store_config, load_config, output_members, request_
 from patroni.dcs.etcd import Client, Failover
 from patroni.utils import tzutc
 from psycopg2 import OperationalError
-from test_etcd import etcd_read, requests_get, socket_getaddrinfo, MockResponse
-from test_ha import get_cluster_initialized_without_leader, get_cluster_initialized_with_leader, \
+
+from . import MockConnect, MockCursor, MockResponse, psycopg2_connect, requests_get
+from .test_etcd import etcd_read, socket_getaddrinfo
+from .test_ha import get_cluster_initialized_without_leader, get_cluster_initialized_with_leader, \
    get_cluster_initialized_with_only_leader, get_cluster_not_initialized_without_leader, get_cluster, Member
-from test_postgresql import MockConnect, psycopg2_connect

 CONFIG_FILE_PATH = './test-ctl.yaml'

@@ -24,9 +25,9 @@ CONFIG_FILE_PATH = './test-ctl.yaml'
 def test_rw_config():
    runner = CliRunner()
    with runner.isolated_filesystem():
-        store_config({'etcd': {'host': 'localhost:2379'}}, CONFIG_FILE_PATH + '/dummy')
        sys.argv = ['patronictl.py', '']
        load_config(CONFIG_FILE_PATH + '/dummy', None)
+        store_config({'etcd': {'host': 'localhost:2379'}}, CONFIG_FILE_PATH + '/dummy')
        load_config(CONFIG_FILE_PATH + '/dummy', '0.0.0.0')
        os.remove(CONFIG_FILE_PATH + '/dummy')
        os.rmdir(CONFIG_FILE_PATH)
@@ -89,10 +90,15 @@ class TestCtl(unittest.TestCase):
            result = self.runner.invoke(ctl, ['switchover', 'dummy', '--force', '--scheduled', '2015-01-01T12:00:00'])
            assert result.exit_code == 1

-        # Aborting switchover, as we anser NO to the confirmation
+        # Aborting switchover, as we answer NO to the confirmation
        result = self.runner.invoke(ctl, ['switchover', 'dummy'], input='leader\nother\n\nN')
        assert result.exit_code == 1

+        # Aborting scheduled switchover, as we answer NO to the confirmation
+        result = self.runner.invoke(ctl, ['switchover', 'dummy', '--scheduled', '2015-01-01T12:00:00+01:00'],
+                                    input='leader\nother\n\nN')
+        assert result.exit_code == 1
+
        # Target and source are equal
        result = self.runner.invoke(ctl, ['switchover', 'dummy'], input='leader\nleader\n\ny')
        assert result.exit_code == 1
@@ -198,7 +204,7 @@ class TestCtl(unittest.TestCase):
            rows = query_member(None, None, None, 'replica', 'SELECT pg_catalog.pg_is_in_recovery()', {})
            self.assertEqual(rows, (None, None))

-            with patch('test_postgresql.MockCursor.execute', Mock(side_effect=OperationalError('bla'))):
+            with patch.object(MockCursor, 'execute', Mock(side_effect=OperationalError('bla'))):
                rows = query_member(None, None, None, 'replica', 'SELECT pg_catalog.pg_is_in_recovery()', {})

        with patch('patroni.ctl.get_cursor', Mock(return_value=None)):
@@ -245,7 +251,7 @@ class TestCtl(unittest.TestCase):
    @patch('patroni.ctl.get_dcs')
    def test_restart_reinit(self, mock_get_dcs):
        mock_get_dcs.return_value.get_cluster = get_cluster_initialized_with_leader
-        result = self.runner.invoke(ctl, ['restart', 'alpha'], input='y\n\nnow')
+        result = self.runner.invoke(ctl, ['restart', 'alpha'], input='now\ny\n')
        assert 'Failed: restart for' in result.output
        assert result.exit_code == 0

@@ -257,18 +263,22 @@ class TestCtl(unittest.TestCase):
        assert result.exit_code == 0

        # Aborted restart
-        result = self.runner.invoke(ctl, ['restart', 'alpha'], input='N')
+        result = self.runner.invoke(ctl, ['restart', 'alpha'], input='now\nN')
        assert result.exit_code == 1

        result = self.runner.invoke(ctl, ['restart', 'alpha', '--pending', '--force'])
        assert result.exit_code == 0

+        # Aborted scheduled restart
+        result = self.runner.invoke(ctl, ['restart', 'alpha', '--scheduled', '2019-10-01T14:30'], input='N')
+        assert result.exit_code == 1
+
        # Not a member
-        result = self.runner.invoke(ctl, ['restart', 'alpha', 'dummy', '--any'], input='y')
+        result = self.runner.invoke(ctl, ['restart', 'alpha', 'dummy', '--any'], input='now\ny')
        assert result.exit_code == 1

        # Wrong pg version
-        result = self.runner.invoke(ctl, ['restart', 'alpha', '--any', '--pg-version', '9.1'], input='y')
+        result = self.runner.invoke(ctl, ['restart', 'alpha', '--any', '--pg-version', '9.1'], input='now\ny')
        assert 'Error: Invalid PostgreSQL version format' in result.output
        assert result.exit_code == 1

@@ -289,14 +299,14 @@ class TestCtl(unittest.TestCase):
        with patch('requests.post', Mock(return_value=MockResponse())):
            # normal restart, the schedule is actually parsed, but not validated in patronictl
            result = self.runner.invoke(ctl, ['restart', 'alpha', '--pg-version', '42.0.0',
-                                        '--scheduled', '2300-10-01T14:30'], input='y')
+                                              '--scheduled', '2300-10-01T14:30'], input='y')
            assert result.exit_code == 0

        with patch('requests.post', Mock(return_value=MockResponse(204))):
            # get restart with the non-200 return code
            # normal restart, the schedule is actually parsed, but not validated in patronictl
            result = self.runner.invoke(ctl, ['restart', 'alpha', '--pg-version', '42.0',
-                                        '--scheduled', '2300-10-01T14:30'], input='y')
+                                              '--scheduled', '2300-10-01T14:30'], input='y')
            assert result.exit_code == 0

        # force restart with restart already present
@@ -533,10 +543,12 @@ class TestCtl(unittest.TestCase):
        show_diff(b"foo:\n  bar: \xc3\xb6\xc3\xb6\n".decode('utf-8'),
                  b"foo:\n  bar: \xc3\xbc\xc3\xbc\n".decode('utf-8'))

-    def test_invoke_editor(self):
-        for e in ('', 'false'):
-            os.environ['EDITOR'] = e
-            self.assertRaises(PatroniCtlException, invoke_editor, 'foo: bar\n', 'test')
+    @patch('subprocess.call', return_value=1)
+    def test_invoke_editor(self, mock_subprocess_call):
+        os.environ.pop('EDITOR', None)
+        for e in ('', '/bin/vi'):
+            with patch('patroni.ctl.find_executable', Mock(return_value=e)):
+                self.assertRaises(PatroniCtlException, invoke_editor, 'foo: bar\n', 'test')

    @patch('patroni.ctl.get_dcs')
    def test_show_config(self, mock_get_dcs):
@@ -548,13 +560,14 @@ class TestCtl(unittest.TestCase):
    def test_edit_config(self, mock_get_dcs):
        mock_get_dcs.return_value = self.e
        mock_get_dcs.return_value.get_cluster = get_cluster_initialized_with_leader
+        mock_get_dcs.return_value.set_config_value = Mock(return_value=False)
        os.environ['EDITOR'] = 'true'
        self.runner.invoke(ctl, ['edit-config', 'dummy'])
        self.runner.invoke(ctl, ['edit-config', 'dummy', '-s', 'foo=bar'])
        self.runner.invoke(ctl, ['edit-config', 'dummy', '--replace', 'postgres0.yml'])
        self.runner.invoke(ctl, ['edit-config', 'dummy', '--apply', '-'], input='foo: bar')
        self.runner.invoke(ctl, ['edit-config', 'dummy', '--force', '--apply', '-'], input='foo: bar')
-        mock_get_dcs.return_value.set_config_value = Mock(return_value=True)
+        mock_get_dcs.return_value.set_config_value.return_value = True
        self.runner.invoke(ctl, ['edit-config', 'dummy', '--force', '--apply', '-'], input='foo: bar')

    @patch('patroni.ctl.get_dcs')
@@ -1,7 +1,5 @@
 import etcd
-import json
 import urllib3.util.connection
-import requests
 import socket
 import unittest

@@ -11,56 +9,7 @@ from patroni.dcs.etcd import AbstractDCS, Client, Cluster, Etcd, EtcdError, DnsC
 from patroni.exceptions import DCSError
 from urllib3.exceptions import ReadTimeoutError

-
-class MockResponse(object):
-
-    def __init__(self, status_code=200):
-        self.status_code = status_code
-        self.content = '{}'
-        self.ok = True
-
-    def json(self):
-        return json.loads(self.content)
-
-    @property
-    def data(self):
-        return self.content.encode('utf-8')
-
-    @property
-    def text(self):
-        return self.content
-
-    @property
-    def status(self):
-        return self.status_code
-
-    @staticmethod
-    def getheader(*args):
-        return ''
-
-
-def requests_get(url, **kwargs):
-    members = '[{"id":14855829450254237642,"peerURLs":["http://localhost:2380","http://localhost:7001"],' +\
-              '"name":"default","clientURLs":["http://localhost:2379","http://localhost:4001"]}]'
-    response = MockResponse()
-    if url.startswith('http://local'):
-        raise requests.exceptions.RequestException()
-    elif ':8011/patroni' in url:
-        response.content = '{"role": "replica", "xlog": {"received_location": 0}, "tags": {}}'
-    elif url.endswith('/members'):
-        response.content = '[{}]' if url.startswith('http://error') else members
-    elif url.startswith('http://exhibitor'):
-        response.content = '{"servers":["127.0.0.1","127.0.0.2","127.0.0.3"],"port":2181}'
-    elif url.endswith(':8011/reinitialize'):
-        data = kwargs.get('data', '')
-        if ' false}' in data:
-            response.status_code = 503
-            response.ok = False
-            response.content = 'restarting after failure already in progress'
-    else:
-        response.status_code = 404
-        response.ok = False
-    return response
+from . import SleepException, MockResponse, requests_get


 def etcd_watch(self, key, index=None, timeout=None, recursive=None):
@@ -122,10 +71,6 @@ def etcd_read(self, key, **kwargs):
    return result


-class SleepException(Exception):
-    pass
-
-
 def dns_query(name, _):
    if '-server' not in name or '-ssl' in name:
        return []
@@ -148,13 +93,14 @@ def socket_getaddrinfo(*args):
 def http_request(method, url, **kwargs):
    if url == 'http://localhost:2379/timeout':
        raise ReadTimeoutError(None, None, None)
+    ret = MockResponse()
    if url == 'http://localhost:2379/v2/machines':
-        ret = MockResponse()
        ret.content = 'http://localhost:2379,http://localhost:4001'
-        return ret
-    if url == 'http://localhost:2379/':
-        return MockResponse()
-    raise socket.error
+    elif url == 'http://localhost:4001/v2/machines':
+        ret.content = ''
+    elif url != 'http://localhost:2379/':
+        raise socket.error
+    return ret


 class TestDnsCachingResolver(unittest.TestCase):
@@ -209,8 +155,8 @@ class TestClient(unittest.TestCase):
        self.client.api_execute('/', 'POST', timeout=0)
        self.client._machines_cache = [self.client._base_uri]
        self.assertRaises(etcd.EtcdWatchTimedOut, self.client.api_execute, '/timeout', 'POST', params={'wait': 'true'})
+        self.assertRaises(etcd.EtcdWatchTimedOut, self.client.api_execute, '/timeout', 'POST', params={'wait': 'true'})
        self.assertRaises(etcd.EtcdException, self.client.api_execute, '/', '')
-        self.client._update_machines_cache = True
        with patch.object(Client, '_load_machines_cache', Mock(side_effect=etcd.EtcdException)):
            self.assertRaises(etcd.EtcdException, self.client.api_execute, '/', 'GET')

@@ -263,17 +209,18 @@ class TestEtcd(unittest.TestCase):

    @patch('dns.resolver.query', dns_query)
    def test_get_etcd_client(self):
-        with patch.object(Client, 'machines') as mock_machines:
+        with patch('time.sleep', Mock(side_effect=SleepException)),\
+                patch.object(Client, 'machines') as mock_machines:
            mock_machines.__get__ = Mock(side_effect=etcd.EtcdException)
-            with patch('time.sleep', Mock(side_effect=SleepException)):
-                self.assertRaises(SleepException, self.etcd.get_etcd_client,
-                                  {'discovery_srv': 'test', 'retry_timeout': 10, 'cacert': '1', 'key': '1', 'cert': 1})
-                self.assertRaises(SleepException, self.etcd.get_etcd_client,
-                                  {'url': 'https://test:2379', 'retry_timeout': 10})
-                self.assertRaises(SleepException, self.etcd.get_etcd_client,
-                                  {'proxy': 'https://user:password@test:2379', 'retry_timeout': 10})
-                self.assertRaises(SleepException, self.etcd.get_etcd_client,
-                                  {'hosts': 'foo:4001,bar', 'retry_timeout': 10})
+            self.assertRaises(SleepException, self.etcd.get_etcd_client,
+                              {'discovery_srv': 'test', 'retry_timeout': 10, 'cacert': '1', 'key': '1', 'cert': 1})
+            self.assertRaises(SleepException, self.etcd.get_etcd_client,
+                              {'url': 'https://test:2379', 'retry_timeout': 10})
+            self.assertRaises(SleepException, self.etcd.get_etcd_client,
+                              {'hosts': 'foo:4001,bar', 'retry_timeout': 10})
+            mock_machines.__get__ = Mock(return_value=[])
+            self.assertRaises(SleepException, self.etcd.get_etcd_client,
+                              {'proxy': 'https://user:password@test:2379', 'retry_timeout': 10})

    def test_get_cluster(self):
        cluster = self.etcd.get_cluster()
@@ -3,8 +3,9 @@ import unittest
 from mock import Mock, patch
 from patroni.dcs.exhibitor import ExhibitorEnsembleProvider, Exhibitor
 from patroni.dcs.zookeeper import ZooKeeperError
-from test_etcd import SleepException, requests_get
-from test_zookeeper import MockKazooClient
+
+from . import SleepException, requests_get
+from .test_zookeeper import MockKazooClient


@patch('requests.get', requests_get)
@@ -1,7 +1,6 @@
 import datetime
 import etcd
 import os
-import unittest
 import sys

 from mock import Mock, MagicMock, PropertyMock, patch
@@ -11,10 +10,16 @@ from patroni.dcs.etcd import Client
 from patroni.exceptions import DCSError, PostgresConnectionException, PatroniException
 from patroni.ha import Ha, _MemberStatus
 from patroni.postgresql import Postgresql
-from patroni.watchdog import Watchdog
+from patroni.postgresql.bootstrap import Bootstrap
+from patroni.postgresql.cancellable import CancellableSubprocess
+from patroni.postgresql.config import ConfigHandler
+from patroni.postgresql.rewind import Rewind
+from patroni.postgresql.slots import SlotsHandler
 from patroni.utils import tzutc
-from test_etcd import socket_getaddrinfo, etcd_read, etcd_write, requests_get
-from test_postgresql import psycopg2_connect, MockPostmaster
+from patroni.watchdog import Watchdog
+
+from . import PostgresInit, MockPostmaster, psycopg2_connect, requests_get
+from .test_etcd import socket_getaddrinfo, etcd_read, etcd_write

 SYSID = '12345678901'

@@ -28,8 +33,10 @@ def false(*args, **kwargs):


 def get_cluster(initialize, leader, members, failover, sync, cluster_config=None):
-    history = TimelineHistory(1, [(1, 67197376, 'no recovery target specified', datetime.datetime.now().isoformat())])
-    cluster_config = cluster_config or ClusterConfig(1, {1: 2}, 1)
+    t = datetime.datetime.now().isoformat()
+    history = TimelineHistory(1, '[[1,67197376,"no recovery target specified","' + t + '"]]',
+                              [(1, 67197376, 'no recovery target specified', t)])
+    cluster_config = cluster_config or ClusterConfig(1, {'check_timeline': True}, 1)
    return Cluster(initialize, cluster_config, leader, 10, members, failover, sync, history)


@@ -72,12 +79,13 @@ def get_standby_cluster_initialized_with_only_leader(failover=None, sync=None):
    )


-def get_node_status(reachable=True, in_recovery=True, wal_position=10, nofailover=False, watchdog_failed=False):
+def get_node_status(reachable=True, in_recovery=True, timeline=2,
+                    wal_position=10, nofailover=False, watchdog_failed=False):
    def fetch_node_status(e):
        tags = {}
        if nofailover:
            tags['nofailover'] = True
-        return _MemberStatus(e, reachable, in_recovery, wal_position, tags, watchdog_failed)
+        return _MemberStatus(e, reachable, in_recovery, timeline, wal_position, tags, watchdog_failed)
    return fetch_node_status


@@ -115,6 +123,8 @@ zookeeper:
        sys.argv = sys.argv[:1]

        self.config = Config()
+        self.config.set_dynamic_configuration({'maximum_lag_on_failover': 5})
+        self.version = '1.5.7'
        self.postgresql = p
        self.dcs = d
        self.api = Mock()
@@ -140,13 +150,16 @@ def run_async(self, func, args=()):
@patch.object(Postgresql, 'call_nowait', Mock(return_value=True))
@patch.object(Postgresql, 'data_directory_empty', Mock(return_value=False))
@patch.object(Postgresql, 'controldata', Mock(return_value={'Database system identifier': SYSID}))
-@patch.object(Postgresql, 'sync_replication_slots', Mock())
-@patch.object(Postgresql, 'write_pg_hba', Mock())
+@patch.object(SlotsHandler, 'sync_replication_slots', Mock())
+@patch.object(ConfigHandler, 'append_pg_hba', Mock())
@patch.object(Postgresql, 'write_pgpass', Mock(return_value={}))
-@patch.object(Postgresql, 'write_recovery_conf', Mock())
+@patch.object(ConfigHandler, 'write_recovery_conf', Mock())
@patch.object(Postgresql, 'query', Mock())
@patch.object(Postgresql, 'checkpoint', Mock())
-@patch.object(Postgresql, 'cancellable_subprocess_call', Mock(return_value=0))
+@patch.object(CancellableSubprocess, 'call', Mock(return_value=0))
+@patch.object(Postgresql, 'get_local_timeline_lsn_from_replication_connection', Mock(return_value=[2, 10]))
+@patch.object(Postgresql, 'get_master_timeline', Mock(return_value=2))
+@patch.object(ConfigHandler, 'restore_configuration_files', Mock())
@patch.object(etcd.Client, 'write', etcd_write)
@patch.object(etcd.Client, 'read', etcd_read)
@patch.object(etcd.Client, 'delete', Mock(side_effect=etcd.EtcdException))
@@ -155,22 +168,15 @@ def run_async(self, func, args=()):
@patch('patroni.async_executor.AsyncExecutor.run_async', run_async)
@patch('subprocess.call', Mock(return_value=0))
@patch('time.sleep', Mock())
-class TestHa(unittest.TestCase):
+class TestHa(PostgresInit):

    @patch('socket.getaddrinfo', socket_getaddrinfo)
-    @patch('psycopg2.connect', psycopg2_connect)
    @patch('patroni.dcs.dcs_modules', Mock(return_value=['patroni.dcs.foo', 'patroni.dcs.etcd']))
    @patch.object(etcd.Client, 'read', etcd_read)
    def setUp(self):
+        super(TestHa, self).setUp()
        with patch.object(Client, 'machines') as mock_machines:
            mock_machines.__get__ = Mock(return_value=['http://remotehost:2379'])
-            self.p = Postgresql({'name': 'postgresql0', 'scope': 'dummy', 'listen': '127.0.0.1:5432',
-                                 'data_dir': 'data/postgresql0', 'retry_timeout': 10,
-                                 'maximum_lag_on_failover': 5,
-                                 'authentication': {'superuser': {'username': 'foo', 'password': 'bar'},
-                                                    'replication': {'username': '', 'password': ''}},
-                                 'parameters': {'wal_level': 'hot_standby', 'max_replication_slots': 5, 'foo': 'bar',
-                                                'hot_standby': 'on', 'max_wal_senders': 5, 'wal_keep_segments': 8}})
            self.p.set_state('running')
            self.p.set_role('replica')
            self.p.postmaster_start_time = MagicMock(return_value=str(postmaster_start_time))
@@ -199,16 +205,23 @@ class TestHa(unittest.TestCase):
        self.assertEqual(self.ha.run_cycle(), 'starting as a secondary')

    @patch('patroni.dcs.etcd.Etcd.initialize', return_value=True)
-    def test_start_as_standby_leader(self, initialize):
+    def test_bootstrap_as_standby_leader(self, initialize):
        self.p.data_directory_empty = true
        self.ha.cluster = get_cluster_not_initialized_without_leader(cluster_config=ClusterConfig(0, {}, 0))
        self.ha.cluster.is_unlocked = true
        self.ha.patroni.config._dynamic_configuration = {"standby_cluster": {"port": 5432}}
        self.assertEqual(self.ha.run_cycle(), 'trying to bootstrap a new standby leader')

+    def test_bootstrap_waiting_for_standby_leader(self):
+        self.p.data_directory_empty = true
+        self.ha.cluster = get_cluster_initialized_without_leader()
+        self.ha.cluster.config.data.update({'standby_cluster': {'port': 5432}})
+        self.assertEqual(self.ha.run_cycle(), 'waiting for standby_leader to bootstrap')
+
    @patch.object(Cluster, 'get_clone_member',
-                  Mock(return_value=Member(0, 'test', 1, {'api_url': 'http://127.0.0.1:8011/patroni'})))
-    @patch.object(Postgresql, 'create_replica', Mock(return_value=0))
+                  Mock(return_value=Member(0, 'test', 1, {'api_url': 'http://127.0.0.1:8011/patroni',
+                                                          'conn_url': 'postgres://127.0.0.1:5432/postgres'})))
+    @patch.object(Bootstrap, 'create_replica', Mock(return_value=0))
    def test_start_as_cascade_replica_in_standby_cluster(self):
        self.p.data_directory_empty = true
        self.ha.cluster = get_standby_cluster_initialized_with_only_leader()
@@ -237,12 +250,20 @@ class TestHa(unittest.TestCase):
        self.p.controldata = lambda: {'Database cluster state': 'in production', 'Database system identifier': SYSID}
        self.assertEqual(self.ha.run_cycle(), 'doing crash recovery in a single user mode')

-    @patch.object(Postgresql, 'rewind_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'can_rewind', PropertyMock(return_value=True))
    def test_recover_with_rewind(self):
        self.p.is_running = false
        self.ha.cluster = get_cluster_initialized_with_leader()
        self.assertEqual(self.ha.run_cycle(), 'running pg_rewind from leader')

+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Bootstrap, 'create_replica', Mock(return_value=1))
+    def test_recover_with_reinitialize(self):
+        self.p.is_running = false
+        self.ha.cluster = get_cluster_initialized_with_leader()
+        self.assertEqual(self.ha.run_cycle(), 'reinitializing due to diverged timelines')
+
    @patch('sys.exit', return_value=1)
    @patch('patroni.ha.Ha.sysid_valid', MagicMock(return_value=True))
    def test_sysid_no_match(self, exit_mock):
@@ -309,7 +330,7 @@ class TestHa(unittest.TestCase):
            self.assertEqual(self.ha.run_cycle(), 'Not promoting self because watchdog could not be activated')

    def test_leader_with_lock(self):
-        self.ha.cluster = get_cluster_not_initialized_without_leader()
+        self.ha.cluster = get_cluster_initialized_with_leader()
        self.ha.cluster.is_unlocked = false
        self.ha.has_lock = true
        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')
@@ -341,10 +362,11 @@ class TestHa(unittest.TestCase):
        self.p.is_leader = false
        self.assertEqual(self.ha.run_cycle(), 'PAUSE: no action')

-    @patch.object(Postgresql, 'rewind_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'can_rewind', PropertyMock(return_value=True))
    def test_follow_triggers_rewind(self):
        self.p.is_leader = false
-        self.p.trigger_check_diverged_lsn()
+        self.ha._rewind.trigger_check_diverged_lsn()
        self.ha.cluster = get_cluster_initialized_with_leader()
        self.assertEqual(self.ha.run_cycle(), 'running pg_rewind from leader')

@@ -455,12 +477,14 @@ class TestHa(unittest.TestCase):
        f = Failover(0, self.p.name, '', None)
        self.ha.cluster = get_cluster_initialized_with_leader(f)
        self.assertEqual(self.ha.run_cycle(), 'manual failover: demoting myself')
-        self.p.rewind_needed_and_possible = true
+        self.ha._rewind.rewind_or_reinitialize_needed_and_possible = true
        self.assertEqual(self.ha.run_cycle(), 'manual failover: demoting myself')
        self.ha.fetch_node_status = get_node_status(nofailover=True)
        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')
        self.ha.fetch_node_status = get_node_status(watchdog_failed=True)
        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')
+        self.ha.fetch_node_status = get_node_status(timeline=1)
+        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')
        self.ha.fetch_node_status = get_node_status(wal_position=1)
        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')
        # manual failover from the previous leader to us won't happen if we hold the nofailover flag
@@ -561,7 +585,9 @@ class TestHa(unittest.TestCase):
        self.ha.is_paused = true
        self.assertFalse(self.ha.is_healthiest_node())

+    @patch('requests.get', requests_get)
    def test__is_healthiest_node(self):
+        self.ha.cluster = get_cluster_initialized_without_leader(sync=('postgresql1', self.p.name))
        self.assertTrue(self.ha._is_healthiest_node(self.ha.old_cluster.members))
        self.p.is_leader = false
        self.ha.fetch_node_status = get_node_status()  # accessible, in_recovery
@@ -570,8 +596,13 @@ class TestHa(unittest.TestCase):
        self.assertFalse(self.ha._is_healthiest_node(self.ha.old_cluster.members))
        self.ha.fetch_node_status = get_node_status(wal_position=11)  # accessible, in_recovery, wal position ahead
        self.assertFalse(self.ha._is_healthiest_node(self.ha.old_cluster.members))
+        # in synchronous_mode consider itself healthy if the former leader is accessible in read-only and ahead of us
+        with patch.object(Ha, 'is_synchronous_mode', Mock(return_value=True)):
+            self.assertTrue(self.ha._is_healthiest_node(self.ha.old_cluster.members))
        with patch('patroni.postgresql.Postgresql.timeline_wal_position', return_value=(1, 1)):
            self.assertFalse(self.ha._is_healthiest_node(self.ha.old_cluster.members))
+        with patch('patroni.postgresql.Postgresql.replica_cached_timeline', return_value=1):
+            self.assertFalse(self.ha._is_healthiest_node(self.ha.old_cluster.members))
        self.ha.patroni.nofailover = True
        self.assertFalse(self.ha._is_healthiest_node(self.ha.old_cluster.members))
        self.ha.patroni.nofailover = False
@@ -632,7 +663,7 @@ class TestHa(unittest.TestCase):

    def test_restart_matches(self):
        self.p._role = 'replica'
-        self.p.server_version = 90500
+        self.p._connection.server_version = 90500
        self.p._pending_restart = True
        self.assertFalse(self.ha.restart_matches("master", "9.5.0", True))
        self.assertFalse(self.ha.restart_matches("replica", "9.4.3", True))
@@ -653,16 +684,19 @@ class TestHa(unittest.TestCase):
        self.p.is_leader = false
        self.p.name = 'leader'
        self.ha.cluster = get_standby_cluster_initialized_with_only_leader()
-        msg = 'no action.  i am the standby leader with the lock'
-        self.assertEqual(self.ha.run_cycle(), msg)
+        self.p.config.check_recovery_conf = true
+        self.assertEqual(self.ha.run_cycle(), 'promoted self to a standby leader because i had the session lock')
+        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the standby leader with the lock')

    def test_process_healthy_standby_cluster_as_cascade_replica(self):
        self.p.is_leader = false
        self.p.name = 'replica'
        self.ha.cluster = get_standby_cluster_initialized_with_only_leader()
-        msg = 'no action.  i am a secondary and i am following a leader'
-        self.assertEqual(self.ha.run_cycle(), msg)
+        self.assertEqual(self.ha.run_cycle(), 'no action.  i am a secondary and i am following a standby leader')
+        with patch.object(Leader, 'conn_url', PropertyMock(return_value='')):
+            self.assertEqual(self.ha.run_cycle(), 'continue following the old known standby leader')

+    @patch('requests.get', requests_get)
    def test_process_unhealthy_standby_cluster_as_standby_leader(self):
        self.p.is_leader = false
        self.p.name = 'leader'
@@ -670,10 +704,10 @@ class TestHa(unittest.TestCase):
        self.ha.cluster.is_unlocked = true
        self.ha.sysid_valid = true
        self.p._sysid = True
-        msg = 'promoted self to a standby leader because i had the session lock'
-        self.assertEqual(self.ha.run_cycle(), msg)
+        self.assertEqual(self.ha.run_cycle(), 'promoted self to a standby leader by acquiring session lock')

-    @patch.object(Postgresql, 'rewind_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'can_rewind', PropertyMock(return_value=True))
    def test_process_unhealthy_standby_cluster_as_cascade_replica(self):
        self.p.is_leader = false
        self.p.name = 'replica'
@@ -784,7 +818,7 @@ class TestHa(unittest.TestCase):

    def test_process_sync_replication(self):
        self.ha.has_lock = true
-        mock_set_sync = self.p.set_synchronous_standby = Mock()
+        mock_set_sync = self.p.config.set_synchronous_standby = Mock()
        self.p.name = 'leader'

        # Test sync key removed when sync mode disabled
@@ -841,11 +875,15 @@ class TestHa(unittest.TestCase):
        self.ha.run_cycle()
        self.assertEqual(self.ha.dcs.write_sync_state.call_count, 2)

-        # Test changing sync standby failed due to race
+        # Test updating sync standby key failed due to DCS being not accessible
        self.ha.dcs.write_sync_state = Mock(return_value=True)
+        self.ha.dcs.get_cluster = Mock(side_effect=DCSError('foo'))
+        self.ha.run_cycle()
+
+        # Test changing sync standby failed due to race
        self.ha.dcs.get_cluster = Mock(return_value=get_cluster_initialized_with_leader(sync=('somebodyelse', None)))
        self.ha.run_cycle()
-        self.assertEqual(self.ha.dcs.write_sync_state.call_count, 1)
+        self.assertEqual(self.ha.dcs.write_sync_state.call_count, 2)

        # Test sync set to '*' when synchronous_mode_strict is enabled
        mock_set_sync.reset_mock()
@@ -857,7 +895,7 @@ class TestHa(unittest.TestCase):
    def test_sync_replication_become_master(self):
        self.ha.is_synchronous_mode = true

-        mock_set_sync = self.p.set_synchronous_standby = Mock()
+        mock_set_sync = self.p.config.set_synchronous_standby = Mock()
        self.p.is_leader = false
        self.p.set_role('replica')
        self.ha.has_lock = true
@@ -980,13 +1018,16 @@ class TestHa(unittest.TestCase):
        # will not say bootstrap from leader as replica can't self elect
        self.assertEqual(self.ha.run_cycle(), "trying to bootstrap from replica 'other'")

+    @patch('psycopg2.connect', psycopg2_connect)
    def test_update_cluster_history(self):
-        self.p.get_master_timeline = Mock(return_value=1)
        self.ha.has_lock = true
        self.ha.cluster.is_unlocked = false
-        self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')
+        for tl in (1, 3):
+            self.p.get_master_timeline = Mock(return_value=tl)
+            self.assertEqual(self.ha.run_cycle(), 'no action.  i am the leader with the lock')

    @patch('sys.exit', return_value=1)
+    @patch('requests.get', requests_get)
    def test_abort_join(self, exit_mock):
        self.ha.cluster = get_cluster_not_initialized_without_leader()
        self.p.is_leader = false
@@ -1,3 +1,4 @@
+import time
 import unittest

 from mock import Mock, patch
@@ -33,13 +34,14 @@ class TestKubernetes(unittest.TestCase):
    @patch.object(k8s_client.CoreV1Api, 'list_namespaced_pod', mock_list_namespaced_pod)
    def setUp(self):
        self.k = Kubernetes({'ttl': 30, 'scope': 'test', 'name': 'p-0', 'retry_timeout': 10, 'labels': {'f': 'b'}})
-        with patch('time.time', Mock(return_value=1)):
+        self.k.get_cluster()
+
+    def test_get_cluster(self):
+        with patch.object(k8s_client.CoreV1Api, 'list_namespaced_config_map', mock_list_namespaced_config_map), \
+                patch.object(k8s_client.CoreV1Api, 'list_namespaced_pod', mock_list_namespaced_pod), \
+                patch('time.time', Mock(return_value=time.time() + 31)):
            self.k.get_cluster()

-    @patch.object(k8s_client.CoreV1Api, 'list_namespaced_config_map', mock_list_namespaced_config_map)
-    @patch.object(k8s_client.CoreV1Api, 'list_namespaced_pod', mock_list_namespaced_pod)
-    def test_get_cluster(self):
-        self.k.get_cluster()
        with patch.object(k8s_client.CoreV1Api, 'list_namespaced_pod', Mock(side_effect=Exception)):
            self.assertRaises(KubernetesError, self.k.get_cluster)

@@ -72,7 +74,7 @@ class TestKubernetes(unittest.TestCase):

    @patch.object(k8s_client.CoreV1Api, 'patch_namespaced_pod', Mock(return_value=True))
    def test_touch_member(self):
-        self.k.touch_member({})
+        self.k.touch_member({'role': 'replica'})
        self.k._name = 'p-1'
        self.k.touch_member({'state': 'running', 'role': 'replica'})
        self.k.touch_member({'state': 'stopped', 'role': 'master'})
@@ -112,3 +114,15 @@ class TestKubernetes(unittest.TestCase):

    def test_set_history_value(self):
        self.k.set_history_value('{}')
+
+    @patch('kubernetes.config.load_kube_config', Mock())
+    @patch.object(k8s_client.CoreV1Api, 'patch_namespaced_pod', Mock(return_value=True))
+    @patch.object(k8s_client.CoreV1Api, 'create_namespaced_endpoints', Mock())
+    @patch.object(k8s_client.CoreV1Api, 'create_namespaced_service',
+                  Mock(side_effect=[True, False, k8s_client.rest.ApiException(500, '')]))
+    def test__create_config_service(self):
+        k = Kubernetes({'ttl': 30, 'scope': 'test', 'name': 'p-0', 'retry_timeout': 10,
+                        'labels': {'f': 'b'}, 'use_endpoints': True, 'pod_ip': '10.0.0.0'})
+        self.assertIsNotNone(k.patch_or_create_config({'foo': 'bar'}))
+        self.assertIsNotNone(k.patch_or_create_config({'foo': 'bar'}))
+        k.touch_member({'state': 'running', 'role': 'replica'})
@@ -0,0 +1,58 @@
+import logging
+import os
+import sys
+import unittest
+import yaml
+
+from mock import Mock, patch
+from patroni.config import Config
+from patroni.log import PatroniLogger
+from six.moves.queue import Queue, Full
+
+
+class TestPatroniLogger(unittest.TestCase):
+
+    def setUp(self):
+        self._handlers = logging.getLogger().handlers[:]
+
+    def tearDown(self):
+        logging.getLogger().handlers[:] = self._handlers
+
+    @patch('logging.FileHandler._open', Mock())
+    @patch('logging.Handler.close', Mock(side_effect=Exception))
+    def test_patroni_logger(self):
+        config = {
+            'log': {
+                'max_queue_size': 5,
+                'dir': 'foo',
+                'file_size': 4096,
+                'file_num': 5,
+                'loggers': {
+                    'foo.bar': 'INFO'
+                }
+            },
+            'restapi': {}, 'postgresql': {'data_dir': 'foo'}
+        }
+        sys.argv = ['patroni.py']
+        os.environ[Config.PATRONI_CONFIG_VARIABLE] = yaml.dump(config, default_flow_style=False)
+        logger = PatroniLogger()
+        patroni_config = Config()
+        logger.reload_config(patroni_config['log'])
+
+        with patch.object(logging.Handler, 'format', Mock(side_effect=Exception)):
+            logging.error('test')
+
+        self.assertEqual(logger._log_handler.maxBytes, config['log']['file_size'])
+        self.assertEqual(logger._log_handler.backupCount, config['log']['file_num'])
+
+        config['log'].pop('dir')
+        logger.reload_config(config['log'])
+        with patch.object(logging.Logger, 'makeRecord',
+                          Mock(side_effect=[logging.LogRecord('', logging.INFO, '', 0, '', (), None), Exception])):
+            logging.error('test')
+        logging.error('test')
+        with patch.object(Queue, 'put_nowait', Mock(side_effect=Full)):
+            self.assertRaises(SystemExit, logger.shutdown)
+        self.assertRaises(Exception, logger.shutdown)
+        self.assertLessEqual(logger.queue_size, 2)  # "Failed to close the old log handler" could be still in the queue
+        self.assertEqual(logger.records_lost, 0)
@@ -1,4 +1,6 @@
 import etcd
+import logging
+import os
 import signal
 import sys
 import time
@@ -9,10 +11,15 @@ from patroni.api import RestApiServer
 from patroni.async_executor import AsyncExecutor
 from patroni.dcs.etcd import Client
 from patroni.exceptions import DCSError
-from patroni import Patroni, main as _main, patroni_main
-from six.moves import BaseHTTPServer
-from test_etcd import SleepException, etcd_read, etcd_write
-from test_postgresql import Postgresql, psycopg2_connect, MockPostmaster
+from patroni.postgresql import Postgresql
+from patroni.postgresql.config import ConfigHandler
+from patroni import Patroni, main as _main, patroni_main, check_psycopg2
+from six.moves import BaseHTTPServer, builtins
+from threading import Thread
+
+from . import psycopg2_connect, SleepException
+from .test_etcd import etcd_read, etcd_write
+from .test_postgresql import MockPostmaster


 class MockFrozenImporter(object):
@@ -23,29 +30,36 @@ class MockFrozenImporter(object):
@patch('time.sleep', Mock())
@patch('subprocess.call', Mock(return_value=0))
@patch('psycopg2.connect', psycopg2_connect)
-@patch.object(Postgresql, 'write_pg_hba', Mock())
-@patch.object(Postgresql, '_write_postgresql_conf', Mock())
-@patch.object(Postgresql, 'write_recovery_conf', Mock())
+@patch.object(ConfigHandler, 'append_pg_hba', Mock())
+@patch.object(ConfigHandler, 'write_postgresql_conf', Mock())
+@patch.object(ConfigHandler, 'write_recovery_conf', Mock())
@patch.object(Postgresql, 'is_running', Mock(return_value=MockPostmaster()))
@patch.object(Postgresql, 'call_nowait', Mock())
@patch.object(BaseHTTPServer.HTTPServer, '__init__', Mock())
@patch.object(AsyncExecutor, 'run', Mock())
@patch.object(etcd.Client, 'write', etcd_write)
@patch.object(etcd.Client, 'read', etcd_read)
+@patch.object(Thread, 'start', Mock())
 class TestPatroni(unittest.TestCase):

    @patch('pkgutil.get_importer', Mock(return_value=MockFrozenImporter()))
    @patch('sys.frozen', Mock(return_value=True), create=True)
+    @patch.object(BaseHTTPServer.HTTPServer, '__init__', Mock())
    @patch.object(etcd.Client, 'read', etcd_read)
    def setUp(self):
+        self._handlers = logging.getLogger().handlers[:]
        RestApiServer._BaseServer__is_shut_down = Mock()
        RestApiServer._BaseServer__shutdown_request = True
        RestApiServer.socket = 0
        with patch.object(Client, 'machines') as mock_machines:
            mock_machines.__get__ = Mock(return_value=['http://remotehost:2379'])
            sys.argv = ['patroni.py', 'postgres0.yml']
+            os.environ['PATRONI_POSTGRESQL_DATA_DIR'] = 'data/test0'
            self.p = Patroni()

+    def tearDown(self):
+        logging.getLogger().handlers[:] = self._handlers
+
    @patch('patroni.dcs.AbstractDCS.get_cluster', Mock(side_effect=[None, DCSError('foo'), None]))
    def test_load_dynamic_configuration(self):
        self.p.config._dynamic_configuration = {}
@@ -55,6 +69,7 @@ class TestPatroni(unittest.TestCase):
    @patch('time.sleep', Mock(side_effect=SleepException))
    @patch.object(etcd.Client, 'delete', Mock())
    @patch.object(Client, 'machines')
+    @patch.object(Thread, 'join', Mock())
    def test_patroni_patroni_main(self, mock_machines):
        with patch('subprocess.call', Mock(return_value=1)):
            sys.argv = ['patroni.py', 'postgres0.yml']
@@ -67,16 +82,12 @@ class TestPatroni(unittest.TestCase):
                    patroni_main()

    @patch('os.getpid')
-    @patch('subprocess.Popen', )
+    @patch('multiprocessing.Process')
    @patch('patroni.patroni_main', Mock())
-    def test_patroni_main(self, mock_popen, mock_getpid):
+    def test_patroni_main(self, mock_process, mock_getpid):
        mock_getpid.return_value = 2
        _main()

-        with patch('sys.frozen', Mock(return_value=True), create=True), patch('os.setsid', Mock()):
-            sys.argv = ['/patroni', 'pg_ctl_start', 'postgres', '-D', '/data', '--max_connections=100']
-            _main()
-
        mock_getpid.return_value = 1

        def mock_signal(signo, handler):
@@ -91,13 +102,13 @@ class TestPatroni(unittest.TestCase):
        ref = {'passtochild': lambda signo, stack_frame: 0}

        def mock_sighup(signo, handler):
-            if signo == signal.SIGHUP:
+            if hasattr(signal, 'SIGHUP') and signo == signal.SIGHUP:
                ref['passtochild'] = handler

-        def mock_wait():
+        def mock_join():
            ref['passtochild'](0, None)

-        mock_popen.return_value.wait = mock_wait
+        mock_process.return_value.join = mock_join
        with patch('signal.signal', mock_sighup), patch('os.kill', Mock()):
            self.assertIsNone(_main())

@@ -122,6 +133,7 @@ class TestPatroni(unittest.TestCase):
        self.assertRaises(SystemExit, self.p.sigterm_handler)

    def test_schedule_next_run(self):
+        self.p.ha.cluster = Mock()
        self.p.ha.dcs.watch = Mock(return_value=True)
        self.p.schedule_next_run()
        self.p.next_run = time.time() - self.p.dcs.loop_wait - 1
@@ -156,3 +168,9 @@ class TestPatroni(unittest.TestCase):
    def test_shutdown(self):
        self.p.api.shutdown = Mock(side_effect=Exception)
        self.p.shutdown()
+
+    def test_check_psycopg2(self):
+        with patch.object(builtins, '__import__', Mock(side_effect=ImportError)):
+            self.assertRaises(SystemExit, check_psycopg2)
+        with patch('psycopg2.__version__', '2.5.3.dev1 a b c'):
+            self.assertRaises(SystemExit, check_psycopg2)
@@ -1,113 +1,32 @@
-import datetime
 import mock  # for the mock.call method, importing it without a namespace breaks python3
 import os
 import psycopg2
-import shutil
 import subprocess
-import unittest
+import time

 from mock import Mock, MagicMock, PropertyMock, patch, mock_open
 from patroni.async_executor import CriticalTask
-from patroni.dcs import Cluster, ClusterConfig, Leader, Member, RemoteMember, SyncState
-from patroni.exceptions import PostgresConnectionException, PostgresException
+from patroni.dcs import Cluster, ClusterConfig, Member, RemoteMember, SyncState
+from patroni.exceptions import PostgresConnectionException
 from patroni.postgresql import Postgresql, STATE_REJECT, STATE_NO_RESPONSE
-from patroni.postmaster import PostmasterProcess
+from patroni.postgresql.postmaster import PostmasterProcess
+from patroni.postgresql.slots import SlotsHandler
 from patroni.utils import RetryFailedError
 from six.moves import builtins
 from threading import Thread, current_thread

-
-class MockCursor(object):
-
-    def __init__(self, connection):
-        self.connection = connection
-        self.closed = False
-        self.rowcount = 0
-        self.results = []
-
-    def execute(self, sql, *params):
-        if sql.startswith('blabla'):
-            raise psycopg2.ProgrammingError()
-        elif sql == 'CHECKPOINT' or sql.startswith('SELECT pg_catalog.pg_create_'):
-            raise psycopg2.OperationalError()
-        elif sql.startswith('RetryFailedError'):
-            raise RetryFailedError('retry')
-        elif sql.startswith('SELECT slot_name'):
-            self.results = [('blabla', 'physical'), ('foobar', 'physical'), ('ls', 'logical', 'a', 'b')]
-        elif sql.startswith('SELECT CASE WHEN pg_catalog.pg_is_in_recovery()'):
-            self.results = [(1, 2)]
-        elif sql.startswith('SELECT pg_catalog.pg_is_in_recovery()'):
-            self.results = [(False, 2)]
-        elif sql.startswith('WITH replication_info AS ('):
-            replication_info = '[{"application_name":"walreceiver","client_addr":"1.2.3.4",' +\
-                               '"state":"streaming","sync_state":"async","sync_priority":0}]'
-            self.results = [('', 0, '', '', '', '', False, replication_info)]
-        elif sql.startswith('SELECT name, setting'):
-            self.results = [('wal_segment_size', '2048', '8kB', 'integer', 'internal'),
-                            ('search_path', 'public', None, 'string', 'user'),
-                            ('port', '5433', None, 'integer', 'postmaster'),
-                            ('listen_addresses', '*', None, 'string', 'postmaster'),
-                            ('autovacuum', 'on', None, 'bool', 'sighup'),
-                            ('unix_socket_directories', '/tmp', None, 'string', 'postmaster')]
-        elif sql.startswith('IDENTIFY_SYSTEM'):
-            self.results = [('1', 2, '0/402EEC0', '')]
-        elif sql.startswith('SELECT isdir, modification'):
-            self.results = [(False, datetime.datetime.now())]
-        elif sql.startswith('SELECT pg_catalog.pg_read_file'):
-            self.results = [('1\t0/40159C0\tno recovery target specified\n\n' +
-                             '2\t1/40159C0\tno recovery target specified\n',)]
-        elif sql.startswith('TIMELINE_HISTORY '):
-            self.results = [('', b'x\t0/40159C0\tno recovery target specified\n\n' +
-                                 b'1\t0/40159C0\tno recovery target specified\n\n' +
-                                 b'2\t0/402DD98\tno recovery target specified\n\n' +
-                                 b'3\t0/403DD98\tno recovery target specified\n')]
-        else:
-            self.results = [(None, None, None, None, None, None, None, None, None, None)]
-
-    def fetchone(self):
-        return self.results[0]
-
-    def fetchall(self):
-        return self.results
-
-    def __iter__(self):
-        for i in self.results:
-            yield i
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        pass
+from . import BaseTestPostgresql, MockCursor, MockPostmaster, psycopg2_connect


-class MockConnect(object):
-
-    server_version = 99999
-    autocommit = False
-    closed = 0
-
-    def cursor(self):
-        return MockCursor(self)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        pass
-
-    @staticmethod
-    def close():
-        pass
+mtime_ret = {}


-class MockPostmaster(object):
-    def __init__(self, is_running=True, is_single_master=False):
-        self.is_running = Mock(return_value=is_running)
-        self.is_single_master = Mock(return_value=is_single_master)
-        self.wait_for_user_backends_to_close = Mock()
-        self.signal_stop = Mock(return_value=None)
-        self.wait = Mock()
+def mock_mtime(filename):
+    if filename not in mtime_ret:
+        mtime_ret[filename] = time.time()
+    else:
+        mtime_ret[filename] += 1
+    return mtime_ret[filename]


 def pg_controldata_string(*args, **kwargs):
@@ -165,61 +84,18 @@ Data page checksum version:           0
 """


-def psycopg2_connect(*args, **kwargs):
-    return MockConnect()
-
-
@patch('subprocess.call', Mock(return_value=0))
@patch('psycopg2.connect', psycopg2_connect)
-class TestPostgresql(unittest.TestCase):
-    _PARAMETERS = {'wal_level': 'hot_standby', 'max_replication_slots': 5, 'f.oo': 'bar',
-                   'search_path': 'public', 'hot_standby': 'on', 'max_wal_senders': 5,
-                   'wal_keep_segments': 8, 'wal_log_hints': 'on', 'max_locks_per_transaction': 64,
-                   'max_worker_processes': 8, 'max_connections': 100, 'max_prepared_transactions': 0,
-                   'track_commit_timestamp': 'off', 'unix_socket_directories': '/tmp'}
+class TestPostgresql(BaseTestPostgresql):

    @patch('subprocess.call', Mock(return_value=0))
-    @patch('psycopg2.connect', psycopg2_connect)
    @patch('os.rename', Mock())
-    @patch.object(Postgresql, 'get_major_version', Mock(return_value=90600))
+    @patch.object(Postgresql, 'get_major_version', Mock(return_value=120000))
    @patch.object(Postgresql, 'is_running', Mock(return_value=True))
    def setUp(self):
-        self.data_dir = 'data/test0'
-        self.config_dir = self.data_dir
-        if not os.path.exists(self.data_dir):
-            os.makedirs(self.data_dir)
-        self.p = Postgresql({'name': 'test0', 'scope': 'batman', 'data_dir': self.data_dir,
-                             'config_dir': self.config_dir, 'retry_timeout': 10, 'pgpass': '/tmp/pgpass0',
-                             'listen': '127.0.0.2, 127.0.0.3:5432', 'connect_address': '127.0.0.2:5432',
-                             'authentication': {'superuser': {'username': 'test', 'password': 'test'},
-                                                'replication': {'username': 'replicator', 'password': 'rep-pass'}},
-                             'remove_data_directory_on_rewind_failure': True,
-                             'use_pg_rewind': True, 'pg_ctl_timeout': 'bla',
-                             'parameters': self._PARAMETERS,
-                             'recovery_conf': {'foo': 'bar'},
-                             'pg_hba': ['host all all 0.0.0.0/0 md5'],
-                             'callbacks': {'on_start': 'true', 'on_stop': 'true', 'on_reload': 'true',
-                                           'on_restart': 'true', 'on_role_change': 'true'}})
+        super(TestPostgresql, self).setUp()
+        self.p.config.write_postgresql_conf()
        self.p._callback_executor = Mock()
-        self.leadermem = Member(0, 'leader', 28, {'conn_url': 'postgres://replicator:[email protected]:5435/postgres'})
-        self.leader = Leader(-1, 28, self.leadermem)
-        self.other = Member(0, 'test-1', 28, {'conn_url': 'postgres://replicator:[email protected]:5433/postgres',
-                            'tags': {'replicatefrom': 'leader'}})
-        self.me = Member(0, 'test0', 28, {'conn_url': 'postgres://replicator:[email protected]:5434/postgres'})
-
-    def tearDown(self):
-        shutil.rmtree('data')
-
-    def test__initdb(self):
-        self.assertRaises(Exception, self.p.bootstrap, {'initdb': [{'pgdata': 'bar'}]})
-        self.assertRaises(Exception, self.p.bootstrap, {'initdb': [{'foo': 'bar', 1: 2}]})
-        self.assertRaises(Exception, self.p.bootstrap, {'initdb': [1]})
-        self.assertRaises(Exception, self.p.bootstrap, {'initdb': 1})
-
-    @patch('os.path.exists', Mock(return_value=True))
-    @patch('os.unlink', Mock())
-    def test_delete_trigger_file(self):
-        self.p.delete_trigger_file()

    @patch('subprocess.Popen')
    @patch.object(Postgresql, 'wait_for_startup')
@@ -235,7 +111,7 @@ class TestPostgresql(unittest.TestCase):

        mock_postmaster = MockPostmaster()
        with patch.object(PostmasterProcess, 'start', return_value=mock_postmaster):
-            pg_conf = os.path.join(self.data_dir, 'postgresql.conf')
+            pg_conf = os.path.join(self.p.data_dir, 'postgresql.conf')
            open(pg_conf, 'w').close()
            self.assertFalse(self.p.start(task=CriticalTask()))

@@ -253,7 +129,7 @@ class TestPostgresql(unittest.TestCase):
            task.cancel()
            self.assertFalse(self.p.start(task=task))

-        self.p.cancel()
+        self.p.cancellable.cancel()
        self.assertFalse(self.p.start())

    @patch.object(Postgresql, 'pg_isready')
@@ -275,7 +151,7 @@ class TestPostgresql(unittest.TestCase):
        self.assertTrue(self.p.wait_for_port_open(mock_postmaster, 1))

        # cancelled
-        self.p.cancel()
+        self.p.cancellable.cancel()
        self.assertFalse(self.p.wait_for_port_open(mock_postmaster, 1))

    @patch('time.sleep', Mock())
@@ -322,183 +198,66 @@ class TestPostgresql(unittest.TestCase):
            self.assertIsNone(self.p.checkpoint())
        self.assertEqual(self.p.checkpoint(), 'not accessible or not healty')

-    @patch.object(Postgresql, 'cancellable_subprocess_call')
-    @patch('patroni.postgresql.Postgresql.write_pgpass', MagicMock(return_value=dict()))
-    def test_pg_rewind(self, mock_cancellable_subprocess_call):
-        r = {'user': '', 'host': '', 'port': '', 'database': '', 'password': ''}
-        mock_cancellable_subprocess_call.return_value = 0
-        self.assertTrue(self.p.pg_rewind(r))
-        mock_cancellable_subprocess_call.side_effect = OSError
-        self.assertFalse(self.p.pg_rewind(r))
-
+    @patch('patroni.postgresql.config.mtime', mock_mtime)
+    @patch.object(MockCursor, 'fetchone', Mock(side_effect=[('foo=bar',), ('',), ('',), ('a=b',)]))
    def test_check_recovery_conf(self):
-        self.p.write_recovery_conf({'primary_conninfo': 'foo'})
-        self.assertFalse(self.p.check_recovery_conf(None))
-        self.p.write_recovery_conf({})
-        self.assertTrue(self.p.check_recovery_conf(None))
+        for version in (120000, 100000):
+            with patch.object(Postgresql, 'major_version', PropertyMock(return_value=version)):
+                self.p.config.write_recovery_conf({'standby_mode': 'on', 'primary_conninfo': 'foo'})
+                self.assertFalse(self.p.config.check_recovery_conf(None))
+                self.p.config.write_recovery_conf({'primary_conninfo': 'foo'})
+                self.p.config.write_postgresql_conf()
+                self.assertFalse(self.p.config.check_recovery_conf(None))
+                self.p.config.write_recovery_conf({'standby_mode': 'on'})
+                self.assertTrue(self.p.config.check_recovery_conf(None))
+                with patch('patroni.postgresql.config.ConfigHandler.primary_conninfo_params',
+                           Mock(return_value={'a': 'b'})):
+                    self.assertFalse(self.p.config.check_recovery_conf(None))
+                    self.p.config.write_recovery_conf({'standby_mode': 'on', 'primary_conninfo': 'a=b'})
+                    self.assertTrue(self.p.config.check_recovery_conf(None))

-    @patch.object(Postgresql, 'start', Mock())
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(return_value=True))
-    def test__get_local_timeline_lsn(self):
-        self.p.trigger_check_diverged_lsn()
-        with patch.object(Postgresql, 'controldata',
-                          Mock(return_value={'Database cluster state': 'shut down in recovery',
-                                             'Minimum recovery ending location': '0/0',
-                                             "Min recovery ending loc's timeline": '0'})):
-            self.p.rewind_needed_and_possible(self.leader)
-        with patch.object(Postgresql, 'is_running', Mock(return_value=True)):
-            with patch.object(MockCursor, 'fetchone', Mock(side_effect=[(False, ), Exception])):
-                self.p.rewind_needed_and_possible(self.leader)
+    @patch.object(Postgresql, 'major_version', PropertyMock(return_value=120000))
+    @patch.object(Postgresql, 'is_running', MockPostmaster)
+    @patch.object(MockPostmaster, 'create_time', Mock(return_value=1234567), create=True)
+    @patch.object(MockCursor, 'fetchone', Mock(return_value=('',)))
+    def test__read_primary_conninfo(self):
+        self.p.config.write_recovery_conf({'standby_mode': 'on'})
+        self.p.config.write_postgresql_conf()
+        self.assertTrue(self.p.config.check_recovery_conf(None))
+        self.assertTrue(self.p.config.check_recovery_conf(None))
+        with patch.object(Postgresql, 'query', Mock(side_effect=Exception)),\
+                patch('patroni.postgresql.config.mtime', mock_mtime):
+            self.assertFalse(self.p.config.check_recovery_conf(None))

-    @patch.object(Postgresql, 'start', Mock())
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(return_value=True))
-    @patch.object(Postgresql, '_get_local_timeline_lsn', Mock(return_value=(2, '40159C1')))
-    @patch.object(Postgresql, 'check_leader_is_not_in_recovery')
-    def test__check_timeline_and_lsn(self, mock_check_leader_is_not_in_recovery):
-        mock_check_leader_is_not_in_recovery.return_value = False
-        self.p.trigger_check_diverged_lsn()
-        self.assertFalse(self.p.rewind_needed_and_possible(self.leader))
-        mock_check_leader_is_not_in_recovery.return_value = True
-        self.assertFalse(self.p.rewind_needed_and_possible(self.leader))
-        self.p.trigger_check_diverged_lsn()
-        with patch('psycopg2.connect', Mock(side_effect=Exception)):
-            self.assertFalse(self.p.rewind_needed_and_possible(self.leader))
-        self.p.trigger_check_diverged_lsn()
-        with patch.object(MockCursor, 'fetchone', Mock(side_effect=[('', 2, '0/0'), ('', b'3\t0/40159C0\tn\n')])):
-            self.assertFalse(self.p.rewind_needed_and_possible(self.leader))
-        self.p.trigger_check_diverged_lsn()
-        with patch.object(MockCursor, 'fetchone', Mock(return_value=('', 1, '0/0'))):
-            with patch.object(Postgresql, '_get_local_timeline_lsn', Mock(return_value=(1, '0/0'))):
-                self.assertFalse(self.p.rewind_needed_and_possible(self.leader))
-            self.p.trigger_check_diverged_lsn()
-            self.assertTrue(self.p.rewind_needed_and_possible(self.leader))
+    @patch.object(Postgresql, 'major_version', PropertyMock(return_value=100000))
+    def test__read_primary_conninfo_pre_v12(self):
+        self.p.config.write_recovery_conf({'standby_mode': 'on'})
+        self.assertTrue(self.p.config.check_recovery_conf(None))
+        self.assertTrue(self.p.config.check_recovery_conf(None))

-    @patch.object(MockCursor, 'fetchone', Mock(side_effect=[(True,), Exception]))
-    def test_check_leader_is_not_in_recovery(self):
-        self.p.check_leader_is_not_in_recovery()
-        self.p.check_leader_is_not_in_recovery()
+    def test_write_postgresql_and_sanitize_auto_conf(self):
+        read_data = 'primary_conninfo = foo\nfoo = bar\n'
+        with open(os.path.join(self.p.data_dir, 'postgresql.auto.conf'), 'w') as f:
+            f.write(read_data)

-    @patch.object(Postgresql, 'cancellable_subprocess_call', Mock(return_value=0))
-    @patch.object(Postgresql, 'checkpoint', side_effect=['', '1'])
-    @patch.object(Postgresql, 'stop', Mock(return_value=False))
-    @patch.object(Postgresql, 'start', Mock())
-    def test_rewind(self, mock_checkpoint):
-        self.p.rewind(self.leader)
-        with patch.object(Postgresql, 'pg_rewind', Mock(return_value=False)):
-            mock_checkpoint.side_effect = ['1', '', '', '']
-            self.p.rewind(self.leader)
-            self.p.rewind(self.leader)
-            with patch.object(Postgresql, 'check_leader_is_not_in_recovery', Mock(return_value=False)):
-                self.p.rewind(self.leader)
-            self.p.config['remove_data_directory_on_rewind_failure'] = False
-            self.p.trigger_check_diverged_lsn()
-            self.p.rewind(self.leader)
-        with patch.object(Postgresql, 'is_running', Mock(return_value=True)):
-            self.p.rewind(self.leader)
-            self.p.is_leader = Mock(return_value=False)
-            self.p.rewind(self.leader)
+        mock_read_auto = mock_open(read_data=read_data)
+        mock_read_auto.return_value.__iter__ = lambda o: iter(o.readline, '')
+        with patch.object(builtins, 'open', Mock(side_effect=[mock_open()(), mock_read_auto(), IOError])),\
+                patch('os.chmod', Mock()):
+            self.p.config.write_postgresql_conf()
+
+        with patch.object(builtins, 'open', Mock(side_effect=[mock_open()(), IOError])), patch('os.chmod', Mock()):
+            self.p.config.write_postgresql_conf()
+        self.p.config.write_recovery_conf({'foo': 'bar'})
+        self.p.config.write_postgresql_conf()

    @patch.object(Postgresql, 'is_running', Mock(return_value=False))
    @patch.object(Postgresql, 'start', Mock())
    def test_follow(self):
+        self.p.call_nowait('on_start')
        m = RemoteMember('1', {'restore_command': '2', 'recovery_min_apply_delay': 3, 'archive_cleanup_command': '4'})
        self.p.follow(m)

-    @patch('subprocess.check_output', Mock(return_value=0, side_effect=pg_controldata_string))
-    def test_can_rewind(self):
-        with patch('subprocess.call', MagicMock(return_value=1)):
-            self.assertFalse(self.p.can_rewind)
-        with patch('subprocess.call', side_effect=OSError):
-            self.assertFalse(self.p.can_rewind)
-        with patch.object(Postgresql, 'controldata', Mock(return_value={'wal_log_hints setting': 'on'})):
-            self.assertTrue(self.p.can_rewind)
-        self.p.config['use_pg_rewind'] = False
-        self.assertFalse(self.p.can_rewind)
-
-    @patch('time.sleep', Mock())
-    @patch.object(Postgresql, 'cancellable_subprocess_call')
-    @patch.object(Postgresql, 'remove_data_directory', Mock(return_value=True))
-    def test_create_replica(self, mock_cancellable_subprocess_call):
-        self.p.delete_trigger_file = Mock(side_effect=OSError)
-
-        self.p.config['create_replica_methods'] = ['pgBackRest']
-        self.p.config['pgBackRest'] = {'command': 'pgBackRest', 'keep_data': True, 'no_params': True}
-        mock_cancellable_subprocess_call.return_value = 0
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.config['create_replica_methods'] = ['wale', 'basebackup']
-        self.p.config['wale'] = {'command': 'foo'}
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-        del self.p.config['wale']
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.config['create_replica_methods'] = ['basebackup']
-        self.p.config['basebackup'] = [{'max_rate': '100M'}, 'no-sync']
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.config['basebackup'] = [{'max_rate': '100M', 'compress': '9'}]
-        with mock.patch('patroni.postgresql.logger.error', new_callable=Mock()) as mock_logger:
-            self.p.create_replica(self.leader)
-            mock_logger.assert_called_once()
-            self.assertTrue("only one key-value is allowed and value should be a string" in mock_logger.call_args[0][0],
-                            "not matching {0}".format(mock_logger.call_args[0][0]))
-
-        self.p.config['basebackup'] = [42]
-        with mock.patch('patroni.postgresql.logger.error', new_callable=Mock()) as mock_logger:
-            self.p.create_replica(self.leader)
-            mock_logger.assert_called_once()
-            self.assertTrue("value should be string value or a single key-value pair" in mock_logger.call_args[0][0],
-                            "not matching {0}".format(mock_logger.call_args[0][0]))
-
-        self.p.config['basebackup'] = {"foo": "bar"}
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.config['create_replica_methods'] = ['wale', 'basebackup']
-        del self.p.config['basebackup']
-        mock_cancellable_subprocess_call.return_value = 1
-        self.assertEqual(self.p.create_replica(self.leader), 1)
-
-        mock_cancellable_subprocess_call.side_effect = Exception('foo')
-        self.assertEqual(self.p.create_replica(self.leader), 1)
-
-        mock_cancellable_subprocess_call.side_effect = [1, 0]
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        mock_cancellable_subprocess_call.side_effect = [Exception(), 0]
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.cancel()
-        self.assertEqual(self.p.create_replica(self.leader), 1)
-
-    @patch('time.sleep', Mock())
-    @patch.object(Postgresql, 'cancellable_subprocess_call')
-    @patch.object(Postgresql, 'remove_data_directory', Mock(return_value=True))
-    def test_create_replica_old_format(self, mock_cancellable_subprocess_call):
-        """ The same test as before but with old 'create_replica_method'
-            to test backward compatibility
-        """
-        self.p.delete_trigger_file = Mock(side_effect=OSError)
-
-        self.p.config['create_replica_method'] = ['wale', 'basebackup']
-        self.p.config['wale'] = {'command': 'foo'}
-        mock_cancellable_subprocess_call.return_value = 0
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-        del self.p.config['wale']
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.config['create_replica_method'] = ['basebackup']
-        self.p.config['basebackup'] = [{'max_rate': '100M'}, 'no-sync']
-        self.assertEqual(self.p.create_replica(self.leader), 0)
-
-        self.p.config['create_replica_method'] = ['wale', 'basebackup']
-        del self.p.config['basebackup']
-        mock_cancellable_subprocess_call.return_value = 1
-        self.assertEqual(self.p.create_replica(self.leader), 1)
-
-    def test_basebackup(self):
-        self.p.cancel()
-        self.p.basebackup(None, None, {'foo': 'bar'})
-
    @patch.object(Postgresql, 'is_running', Mock(return_value=True))
    def test_sync_replication_slots(self):
        self.p.start()
@@ -506,17 +265,16 @@ class TestPostgresql(unittest.TestCase):
                                             'A': 0, 'test_3': 0, 'b': {'type': 'logical', 'plugin': '1'}}}, 1)
        cluster = Cluster(True, config, self.leader, 0, [self.me, self.other, self.leadermem], None, None, None)
        with mock.patch('patroni.postgresql.Postgresql._query', Mock(side_effect=psycopg2.OperationalError)):
-            self.p.sync_replication_slots(cluster)
-        self.p.sync_replication_slots(cluster)
+            self.p.slots_handler.sync_replication_slots(cluster)
+        self.p.slots_handler.sync_replication_slots(cluster)
        with mock.patch('patroni.postgresql.Postgresql.role', new_callable=PropertyMock(return_value='replica')):
-            self.p.sync_replication_slots(cluster)
-        with patch.object(Postgresql, 'drop_replication_slot', Mock(return_value=True)),\
+            self.p.slots_handler.sync_replication_slots(cluster)
+        with patch.object(SlotsHandler, 'drop_replication_slot', Mock(return_value=True)),\
                patch('patroni.dcs.logger.error', new_callable=Mock()) as errorlog_mock:
-            self.p.query = Mock()
            alias1 = Member(0, 'test-3', 28, {'conn_url': 'postgres://replicator:[email protected]:5436/postgres'})
            alias2 = Member(0, 'test.3', 28, {'conn_url': 'postgres://replicator:[email protected]:5436/postgres'})
            cluster.members.extend([alias1, alias2])
-            self.p.sync_replication_slots(cluster)
+            self.p.slots_handler.sync_replication_slots(cluster)
            self.assertEqual(errorlog_mock.call_count, 5)
            ca = errorlog_mock.call_args_list[0][0][1]
            self.assertTrue("test-3" in ca, "non matching {0}".format(ca))
@@ -599,125 +357,24 @@ class TestPostgresql(unittest.TestCase):
        with patch('os.rename', Mock(side_effect=OSError)):
            self.p.move_data_directory()

-    @patch.object(Postgresql, 'is_running', Mock(return_value=True))
-    def test_bootstrap(self):
-        with patch('subprocess.call', Mock(return_value=1)):
-            self.assertFalse(self.p.bootstrap({}))
-
-        config = {'users': {'replicator': {'password': 'rep-pass', 'options': ['replication']}}}
-
-        self.p.bootstrap(config)
-        with open(os.path.join(self.config_dir, 'pg_hba.conf')) as f:
-            lines = f.readlines()
-            self.assertTrue('host all all 0.0.0.0/0 md5\n' in lines)
-
-        self.p.config.pop('pg_hba')
-        config.update({'post_init': '/bin/false',
-                       'pg_hba': ['host replication replicator 127.0.0.1/32 md5',
-                                  'hostssl all all 0.0.0.0/0 md5',
-                                  'host all all 0.0.0.0/0 md5']})
-        self.p.bootstrap(config)
-        with open(os.path.join(self.data_dir, 'pg_hba.conf')) as f:
-            lines = f.readlines()
-            self.assertTrue('host replication replicator 127.0.0.1/32 md5\n' in lines)
-
-    @patch.object(Postgresql, 'cancellable_subprocess_call')
-    def test_custom_bootstrap(self, mock_cancellable_subprocess_call):
-        self.p.config.pop('pg_hba')
-        config = {'method': 'foo', 'foo': {'command': 'bar'}}
-
-        mock_cancellable_subprocess_call.return_value = 1
-        self.assertFalse(self.p.bootstrap(config))
-
-        mock_cancellable_subprocess_call.return_value = 0
-        with patch('subprocess.Popen', Mock(side_effect=Exception("42"))),\
-                patch('os.path.isfile', Mock(return_value=True)),\
-                patch('os.unlink', Mock()),\
-                patch.object(Postgresql, 'save_configuration_files', Mock()),\
-                patch.object(Postgresql, 'restore_configuration_files', Mock()),\
-                patch.object(Postgresql, 'write_recovery_conf', Mock()):
-            with self.assertRaises(Exception) as e:
-                self.p.bootstrap(config)
-            self.assertEqual(str(e.exception), '42')
-
-            config['foo']['recovery_conf'] = {'foo': 'bar'}
-
-            with self.assertRaises(Exception) as e:
-                self.p.bootstrap(config)
-            self.assertEqual(str(e.exception), '42')
-
-        mock_cancellable_subprocess_call.side_effect = Exception
-        self.assertFalse(self.p.bootstrap(config))
-
-    @patch('time.sleep', Mock())
-    @patch('os.unlink', Mock())
-    @patch.object(Postgresql, 'run_bootstrap_post_init', Mock(return_value=True))
-    @patch.object(Postgresql, '_custom_bootstrap', Mock(return_value=True))
-    @patch.object(Postgresql, 'start', Mock(return_value=True))
-    def test_post_bootstrap(self):
-        config = {'method': 'foo', 'foo': {'command': 'bar'}}
-        self.p.bootstrap(config)
-
-        task = CriticalTask()
-        with patch.object(Postgresql, 'create_or_update_role', Mock(side_effect=Exception)):
-            self.p.post_bootstrap({}, task)
-            self.assertFalse(task.result)
-
-        self.p.config.pop('pg_hba')
-        self.p.post_bootstrap({}, task)
-        self.assertTrue(task.result)
-
-        self.p.bootstrap(config)
-        with patch.object(Postgresql, 'pending_restart', PropertyMock(return_value=True)), \
-                patch.object(Postgresql, 'restart', Mock()) as mock_restart:
-            self.p.post_bootstrap({}, task)
-            mock_restart.assert_called_once()
-
-        self.p.bootstrap(config)
-        self.p.set_state('stopped')
-        self.p.reload_config({'authentication': {'superuser': {'username': 'p', 'password': 'p'},
-                                                 'replication': {'username': 'r', 'password': 'r'}},
-                              'listen': '*', 'retry_timeout': 10, 'parameters': {'hba_file': 'foo'}})
-        with patch.object(Postgresql, 'restart', Mock()) as mock_restart:
-            self.p.post_bootstrap({}, task)
-            mock_restart.assert_called_once()
-
-    @patch.object(Postgresql, 'cancellable_subprocess_call')
-    def test_run_bootstrap_post_init(self, mock_cancellable_subprocess_call):
-        mock_cancellable_subprocess_call.return_value = 1
-        self.assertFalse(self.p.run_bootstrap_post_init({'post_init': '/bin/false'}))
-
-        mock_cancellable_subprocess_call.return_value = 0
-        self.p._superuser.pop('username')
-        self.assertTrue(self.p.run_bootstrap_post_init({'post_init': '/bin/false'}))
-        mock_cancellable_subprocess_call.assert_called()
-        args, kwargs = mock_cancellable_subprocess_call.call_args
-        self.assertTrue('PGPASSFILE' in kwargs['env'])
-        self.assertEqual(args[0], ['/bin/false', 'postgres://127.0.0.2:5432/postgres'])
-
-        mock_cancellable_subprocess_call.reset_mock()
-        self.p._local_address.pop('host')
-        self.assertTrue(self.p.run_bootstrap_post_init({'post_init': '/bin/false'}))
-        mock_cancellable_subprocess_call.assert_called()
-        self.assertEqual(mock_cancellable_subprocess_call.call_args[0][0], ['/bin/false', 'postgres://:5432/postgres'])
-
-        mock_cancellable_subprocess_call.side_effect = OSError
-        self.assertFalse(self.p.run_bootstrap_post_init({'post_init': '/bin/false'}))
-
-    @patch('patroni.postgresql.Postgresql.create_replica', Mock(return_value=0))
-    def test_clone(self):
-        self.p.clone(self.leader)
-
    @patch('os.listdir', Mock(return_value=['recovery.conf']))
    @patch('os.path.exists', Mock(return_value=True))
    def test_get_postgres_role_from_data_directory(self):
        self.assertEqual(self.p.get_postgres_role_from_data_directory(), 'replica')

    def test_remove_data_directory(self):
+        def _symlink(src, dst):
+            try:
+                os.symlink(src, dst)
+            except OSError:
+                if os.name == 'nt':  # os.symlink under Windows needs admin rights skip it
+                    pass
+        os.makedirs(os.path.join(self.p.data_dir, 'foo'))
+        _symlink('foo', os.path.join(self.p.data_dir, 'pg_wal'))
        self.p.remove_data_directory()
-        open(self.data_dir, 'w').close()
+        open(self.p.data_dir, 'w').close()
        self.p.remove_data_directory()
-        os.symlink('unexisting', self.data_dir)
+        _symlink('unexisting', self.p.data_dir)
        with patch('os.unlink', Mock(side_effect=OSError)):
            self.p.remove_data_directory()
        self.p.remove_data_directory()
@@ -742,34 +399,34 @@ class TestPostgresql(unittest.TestCase):
    @patch('os.path.isfile', Mock(return_value=True))
    @patch('shutil.copy', Mock(side_effect=IOError))
    def test_save_configuration_files(self):
-        self.p.save_configuration_files()
+        self.p.config.save_configuration_files()

    @patch('os.path.isfile', Mock(side_effect=[False, True]))
    @patch('shutil.copy', Mock(side_effect=IOError))
    def test_restore_configuration_files(self):
-        self.p.restore_configuration_files()
+        self.p.config.restore_configuration_files()

    def test_can_create_replica_without_replication_connection(self):
-        self.p.config['create_replica_method'] = []
+        self.p.config._config['create_replica_method'] = []
        self.assertFalse(self.p.can_create_replica_without_replication_connection())
-        self.p.config['create_replica_method'] = ['wale', 'basebackup']
-        self.p.config['wale'] = {'command': 'foo', 'no_master': 1}
+        self.p.config._config['create_replica_method'] = ['wale', 'basebackup']
+        self.p.config._config['wale'] = {'command': 'foo', 'no_master': 1}
        self.assertTrue(self.p.can_create_replica_without_replication_connection())

    def test_replica_method_can_work_without_replication_connection(self):
        self.assertFalse(self.p.replica_method_can_work_without_replication_connection('basebackup'))
        self.assertFalse(self.p.replica_method_can_work_without_replication_connection('foobar'))
-        self.p.config['foo'] = {'command': 'bar', 'no_master': 1}
+        self.p.config._config['foo'] = {'command': 'bar', 'no_master': 1}
        self.assertTrue(self.p.replica_method_can_work_without_replication_connection('foo'))
-        self.p.config['foo'] = {'command': 'bar'}
+        self.p.config._config['foo'] = {'command': 'bar'}
        self.assertFalse(self.p.replica_method_can_work_without_replication_connection('foo'))

    @patch.object(Postgresql, 'is_running', Mock(return_value=True))
    def test_reload_config(self):
        parameters = self._PARAMETERS.copy()
        parameters.pop('f.oo')
-        config = {'pg_hba': [''], 'use_unix_socket': True, 'authentication': {},
-                  'retry_timeout': 10, 'listen': '*', 'parameters': parameters}
+        config = {'pg_hba': [''], 'pg_ident': [''], 'use_unix_socket': True, 'authentication': {},
+                  'retry_timeout': 10, 'listen': '*', 'krbsrvname': 'postgres', 'parameters': parameters}
        self.p.reload_config(config)
        parameters['b.ar'] = 'bar'
        self.p.reload_config(config)
@@ -781,7 +438,7 @@ class TestPostgresql(unittest.TestCase):
        self.p.reload_config(config)
        parameters['unix_socket_directories'] = '.'
        self.p.reload_config(config)
-        self.p.resolve_connection_addresses()
+        self.p.config.resolve_connection_addresses()

    @patch.object(Postgresql, '_version_file_exists', Mock(return_value=True))
    def test_get_major_version(self):
@@ -868,7 +525,7 @@ class TestPostgresql(unittest.TestCase):
                self.assertEqual(state['sleeps'], 3)

        with patch.object(Postgresql, 'check_startup_state_changed', Mock(return_value=False)):
-            self.p.cancel()
+            self.p.cancellable.cancel()
            self.p._state = 'starting'
            self.assertIsNone(self.p.wait_for_startup())

@@ -908,37 +565,37 @@ class TestPostgresql(unittest.TestCase):

    def test_set_sync_standby(self):
        def value_in_conf():
-            with open(os.path.join(self.data_dir, 'postgresql.conf')) as f:
+            with open(os.path.join(self.p.data_dir, 'postgresql.conf')) as f:
                for line in f:
                    if line.startswith('synchronous_standby_names'):
                        return line.strip()

        mock_reload = self.p.reload = Mock()
-        self.p.set_synchronous_standby('n1')
+        self.p.config.set_synchronous_standby('n1')
        self.assertEqual(value_in_conf(), "synchronous_standby_names = 'n1'")
        mock_reload.assert_called()

        mock_reload.reset_mock()
-        self.p.set_synchronous_standby('n1')
+        self.p.config.set_synchronous_standby('n1')
        mock_reload.assert_not_called()
        self.assertEqual(value_in_conf(), "synchronous_standby_names = 'n1'")

-        self.p.set_synchronous_standby('n2')
+        self.p.config.set_synchronous_standby('n2')
        mock_reload.assert_called()
        self.assertEqual(value_in_conf(), "synchronous_standby_names = 'n2'")

        mock_reload.reset_mock()
-        self.p.set_synchronous_standby(None)
+        self.p.config.set_synchronous_standby(None)
        mock_reload.assert_called()
        self.assertEqual(value_in_conf(), None)

    def test_get_server_parameters(self):
        config = {'synchronous_mode': True, 'parameters': {'wal_level': 'hot_standby'}, 'listen': '0'}
-        self.p.get_server_parameters(config)
+        self.p.config.get_server_parameters(config)
        config['synchronous_mode_strict'] = True
-        self.p.get_server_parameters(config)
-        self.p.set_synchronous_standby('foo')
-        self.p.get_server_parameters(config)
+        self.p.config.get_server_parameters(config)
+        self.p.config.set_synchronous_standby('foo')
+        self.p.config.get_server_parameters(config)

    @patch('time.sleep', Mock())
    def test__wait_for_connection_close(self):
@@ -987,7 +644,9 @@ class TestPostgresql(unittest.TestCase):
        self.p.cleanup_archive_status()

    @patch('os.unlink', Mock())
+    @patch('os.listdir', Mock(return_value=[]))
    @patch('os.path.isfile', Mock(return_value=True))
+    @patch.object(Postgresql, 'read_postmaster_opts', Mock(return_value={}))
    @patch.object(Postgresql, 'single_user_mode', Mock(return_value=0))
    def test_fix_cluster_state(self):
        self.assertTrue(self.p.fix_cluster_state())
@@ -998,25 +657,14 @@ class TestPostgresql(unittest.TestCase):
    def test_get_master_timeline(self):
        self.assertEqual(self.p.get_master_timeline(), 1)

-    def test_cancellable_subprocess_call(self):
-        self.p.cancel()
-        self.assertRaises(PostgresException, self.p.cancellable_subprocess_call, communicate_input=None)
-
-    @patch('patroni.postgresql.polling_loop', Mock(return_value=[0, 0]))
-    def test_cancel(self):
-        self.p._cancellable = Mock()
-        self.p._cancellable.returncode = None
-        self.p.cancel()
-        type(self.p._cancellable).returncode = PropertyMock(side_effect=[None, -15])
-        self.p.cancel()
-
    @patch.object(Postgresql, 'get_postgres_role_from_data_directory', Mock(return_value='replica'))
    def test__build_effective_configuration(self):
        with patch.object(Postgresql, 'controldata',
                          Mock(return_value={'max_connections setting': '200',
                                             'max_worker_processes setting': '20',
                                             'max_prepared_xacts setting': '100',
-                                             'max_locks_per_xact setting': '100'})):
-            self.p.cancel()
+                                             'max_locks_per_xact setting': '100',
+                                             'max_wal_senders setting': 10})):
+            self.p.cancellable.cancel()
            self.assertFalse(self.p.start())
            self.assertTrue(self.p.pending_restart)
@@ -2,10 +2,22 @@ import psutil
 import unittest

 from mock import Mock, patch, mock_open
-from patroni.postmaster import PostmasterProcess
+from patroni.postgresql.postmaster import PostmasterProcess
 from six.moves import builtins


+class MockProcess(object):
+    def __init__(self, target, args):
+        self.target = target
+        self.args = args
+
+    def start(self):
+        self.target(*self.args)
+
+    def join(self):
+        pass
+
+
 class TestPostmasterProcess(unittest.TestCase):
    @patch('psutil.Process.__init__', Mock())
    def test_init(self):
@@ -14,7 +26,7 @@ class TestPostmasterProcess(unittest.TestCase):

    @patch('psutil.Process.create_time')
    @patch('psutil.Process.__init__')
-    @patch('patroni.postmaster.PostmasterProcess._read_postmaster_pidfile')
+    @patch.object(PostmasterProcess, '_read_postmaster_pidfile')
    def test_from_pidfile(self, mock_read, mock_init, mock_create_time):
        mock_init.side_effect = psutil.NoSuchProcess(123)
        mock_read.return_value = {}
@@ -48,7 +60,7 @@ class TestPostmasterProcess(unittest.TestCase):
        mock_init.side_effect = psutil.NoSuchProcess(123)
        self.assertEqual(PostmasterProcess.from_pid(123), None)
        mock_init.side_effect = None
-        self.assertNotEquals(PostmasterProcess.from_pid(123), None)
+        self.assertNotEqual(PostmasterProcess.from_pid(123), None)

    @patch('psutil.Process.__init__', Mock())
    @patch('psutil.Process.send_signal')
@@ -67,7 +79,7 @@ class TestPostmasterProcess(unittest.TestCase):
    @patch('psutil.wait_procs')
    def test_wait_for_user_backends_to_close(self, mock_wait):
        c1 = Mock()
-        c1.cmdline = Mock(return_value=["postgres: startup process"])
+        c1.cmdline = Mock(return_value=["postgres: startup process   "])
        c2 = Mock()
        c2.cmdline = Mock(return_value=["postgres: postgres postgres [local] idle"])
        c3 = Mock()
@@ -77,24 +89,28 @@ class TestPostmasterProcess(unittest.TestCase):
            self.assertIsNone(proc.wait_for_user_backends_to_close())
            mock_wait.assert_called_with([c2])

-        c3.cmdline = Mock(side_effect=psutil.AccessDenied(123))
-        with patch('psutil.Process.children', Mock(return_value=[c3])):
+        with patch('psutil.Process.children', Mock(side_effect=psutil.NoSuchProcess(123))):
            proc = PostmasterProcess(123)
            self.assertIsNone(proc.wait_for_user_backends_to_close())

    @patch('subprocess.Popen')
+    @patch('os.setsid', Mock(), create=True)
+    @patch('multiprocessing.Process', MockProcess)
    @patch.object(PostmasterProcess, 'from_pid')
    @patch.object(PostmasterProcess, '_from_pidfile')
    def test_start(self, mock_frompidfile, mock_frompid, mock_popen):
        mock_frompidfile.return_value._is_postmaster_process.return_value = False
        mock_frompid.return_value = "proc 123"
-        mock_popen.return_value.stdout.readline.return_value = '123'
+        mock_popen.return_value.pid = 123
        self.assertEqual(PostmasterProcess.start('true', '/tmp', '/tmp/test.conf', []), "proc 123")
        mock_frompid.assert_called_with(123)

        mock_frompidfile.side_effect = psutil.NoSuchProcess(123)
        self.assertEqual(PostmasterProcess.start('true', '/tmp', '/tmp/test.conf', []), "proc 123")

+        mock_popen.side_effect = Exception
+        self.assertIsNone(PostmasterProcess.start('true', '/tmp', '/tmp/test.conf', []))
+
    @patch('psutil.Process.__init__', Mock(side_effect=psutil.NoSuchProcess(123)))
    def test_read_postmaster_pidfile(self):
        with patch.object(builtins, 'open', Mock(side_effect=IOError)):
@@ -0,0 +1,107 @@
+from mock import Mock, PropertyMock, patch
+
+from patroni.postgresql import Postgresql
+from patroni.postgresql.cancellable import CancellableSubprocess
+from patroni.postgresql.rewind import Rewind
+
+from . import BaseTestPostgresql, MockCursor, psycopg2_connect
+
+
+@patch('subprocess.call', Mock(return_value=0))
+@patch('psycopg2.connect', psycopg2_connect)
+class TestRewind(BaseTestPostgresql):
+
+    def setUp(self):
+        super(TestRewind, self).setUp()
+        self.r = Rewind(self.p)
+
+    def test_can_rewind(self):
+        with patch.object(Postgresql, 'controldata', Mock(return_value={'wal_log_hints setting': 'on'})):
+            self.assertTrue(self.r.can_rewind)
+        with patch('subprocess.call', Mock(return_value=1)):
+            self.assertFalse(self.r.can_rewind)
+        with patch('subprocess.call', side_effect=OSError):
+            self.assertFalse(self.r.can_rewind)
+        self.p.config._config['use_pg_rewind'] = False
+        self.assertFalse(self.r.can_rewind)
+
+    @patch.object(CancellableSubprocess, 'call')
+    def test_pg_rewind(self, mock_cancellable_subprocess_call):
+        r = {'user': '', 'host': '', 'port': '', 'database': '', 'password': ''}
+        mock_cancellable_subprocess_call.return_value = 0
+        self.assertTrue(self.r.pg_rewind(r))
+        mock_cancellable_subprocess_call.side_effect = OSError
+        self.assertFalse(self.r.pg_rewind(r))
+
+    @patch.object(Rewind, 'can_rewind', PropertyMock(return_value=True))
+    def test__get_local_timeline_lsn(self):
+        self.r.trigger_check_diverged_lsn()
+        with patch.object(Postgresql, 'controldata',
+                          Mock(return_value={'Database cluster state': 'shut down in recovery',
+                                             'Minimum recovery ending location': '0/0',
+                                             "Min recovery ending loc's timeline": '0'})):
+            self.r.rewind_or_reinitialize_needed_and_possible(self.leader)
+
+        with patch.object(Postgresql, 'is_running', Mock(return_value=True)):
+            with patch.object(MockCursor, 'fetchone', Mock(side_effect=[(False, ), Exception])):
+                self.r.rewind_or_reinitialize_needed_and_possible(self.leader)
+
+    @patch.object(CancellableSubprocess, 'call', Mock(return_value=0))
+    @patch.object(Postgresql, 'checkpoint', side_effect=['', '1'],)
+    @patch.object(Postgresql, 'stop', Mock(return_value=False))
+    @patch.object(Postgresql, 'start', Mock())
+    def test_execute(self, mock_checkpoint):
+        self.r.execute(self.leader)
+        with patch.object(Rewind, 'pg_rewind', Mock(return_value=False)):
+            mock_checkpoint.side_effect = ['1', '', '', '']
+            self.r.execute(self.leader)
+            self.r.execute(self.leader)
+            with patch.object(Rewind, 'check_leader_is_not_in_recovery', Mock(return_value=False)):
+                self.r.execute(self.leader)
+            self.p.config._config['remove_data_directory_on_rewind_failure'] = False
+            self.r.trigger_check_diverged_lsn()
+            self.r.execute(self.leader)
+
+        self.leader.member.data.update(version='1.5.7', checkpoint_after_promote=False, role='master')
+        self.assertIsNone(self.r.execute(self.leader))
+
+        del self.leader.member.data['checkpoint_after_promote']
+        with patch.object(Rewind, 'check_leader_is_not_in_recovery', Mock(return_value=False)):
+            self.assertIsNone(self.r.execute(self.leader))
+
+        with patch.object(Postgresql, 'is_running', Mock(return_value=True)):
+            self.r.execute(self.leader)
+
+    @patch.object(Postgresql, 'start', Mock())
+    @patch.object(Rewind, 'can_rewind', PropertyMock(return_value=True))
+    @patch.object(Rewind, '_get_local_timeline_lsn', Mock(return_value=(2, '40159C1')))
+    @patch.object(Rewind, 'check_leader_is_not_in_recovery')
+    def test__check_timeline_and_lsn(self, mock_check_leader_is_not_in_recovery):
+        mock_check_leader_is_not_in_recovery.return_value = False
+        self.r.trigger_check_diverged_lsn()
+        self.assertFalse(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+        self.leader = self.leader.member
+        self.assertFalse(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+        mock_check_leader_is_not_in_recovery.return_value = True
+        self.assertFalse(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+        self.r.trigger_check_diverged_lsn()
+        with patch('psycopg2.connect', Mock(side_effect=Exception)):
+            self.assertFalse(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+        self.r.trigger_check_diverged_lsn()
+        with patch.object(MockCursor, 'fetchone', Mock(side_effect=[('', 2, '0/0'), ('', b'3\t0/40159C0\tn\n')])):
+            self.assertFalse(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+        self.r.trigger_check_diverged_lsn()
+        with patch.object(MockCursor, 'fetchone', Mock(return_value=('', 1, '0/0'))):
+            with patch.object(Rewind, '_get_local_timeline_lsn', Mock(return_value=(1, '0/0'))):
+                self.assertFalse(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+            self.r.trigger_check_diverged_lsn()
+            self.assertTrue(self.r.rewind_or_reinitialize_needed_and_possible(self.leader))
+
+    @patch.object(MockCursor, 'fetchone', Mock(side_effect=[(True,), Exception]))
+    def test_check_leader_is_not_in_recovery(self):
+        self.r.check_leader_is_not_in_recovery()
+        self.r.check_leader_is_not_in_recovery()
+
+    @patch.object(Postgresql, 'controldata', Mock(return_value={"Latest checkpoint's TimeLineID": 1}))
+    def test_check_for_checkpoint_after_promote(self):
+        self.r.check_for_checkpoint_after_promote()
@@ -6,9 +6,9 @@ from mock import Mock, PropertyMock, patch, mock_open
 from patroni.scripts import wale_restore
 from patroni.scripts.wale_restore import WALERestore, main as _main, get_major_version
 from six.moves import builtins
-from test_postgresql import MockConnect, psycopg2_connect
 from threading import current_thread

+from . import MockConnect, psycopg2_connect

 wale_output_header = (
    b'name\tlast_modified\t'
@@ -2,6 +2,7 @@ import ctypes
 import patroni.watchdog.linux as linuxwd
 import sys
 import unittest
+import os

 from mock import patch, Mock, PropertyMock
 from patroni.watchdog import Watchdog, WatchdogError
@@ -61,6 +62,7 @@ def mock_close(fd):
    mock_devices[fd].open = False


+@unittest.skipIf(os.name == 'nt', "Windows not supported")
@patch('os.open', mock_open)
@patch('os.write', mock_write)
@patch('os.close', mock_close)
@@ -174,6 +176,7 @@ class TestNullWatchdog(unittest.TestCase):
        self.assertIsInstance(NullWatchdog.from_config({}), NullWatchdog)


+@unittest.skipIf(os.name == 'nt', "Windows not supported")
 class TestLinuxWatchdogDevice(unittest.TestCase):

    def setUp(self):
@@ -1,3 +1,4 @@
+import select
 import six
 import unittest

@@ -16,6 +17,7 @@ class MockKazooClient(Mock):

    def __init__(self, *args, **kwargs):
        super(MockKazooClient, self).__init__()
+        self._session_timeout = 30

    @property
    def client_id(self):
@@ -23,7 +25,7 @@ class MockKazooClient(Mock):

    @staticmethod
    def retry(func, *args, **kwargs):
-        func(*args, **kwargs)
+        return func(*args, **kwargs)

    def get(self, path, watch=None):
        if not isinstance(path, six.string_types):
@@ -113,6 +115,11 @@ class TestPatroniSequentialThreadingHandler(unittest.TestCase):
    def test_create_connection(self):
        self.assertIsNotNone(self.handler.create_connection(()))
        self.assertIsNotNone(self.handler.create_connection((), 40))
+        self.assertIsNotNone(self.handler.create_connection(timeout=40))
+
+    @patch.object(SequentialThreadingHandler, 'select', Mock(side_effect=ValueError))
+    def test_select(self):
+        self.assertRaises(select.error, self.handler.select)


 class TestZooKeeper(unittest.TestCase):