first commit

Close #772, #1128

.gitignore

@@ -54,3 +54,6 @@ docs/source/_templates/
 
 # Pycharm IDE
 .idea/
+
+#VSCode IDE
+.vscode/

.travis.yml

@@ -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,11 +135,11 @@ 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/*_failed/*postgres?.*
                 exit 1

Dockerfile

@@ -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
+ARG PG_MAJOR=10
-MAINTAINER Alexander Kukushkin <[email protected]>
+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 the patroni package. We will install all required dependencies
-    # postgres:10 is based on debian, which has patroni package. We will install all required dependencies
+    && apt-cache depends patroni | sed -n -e 's/.*Depends: \(python3-.\+\)$/\1/p' \
-    && apt-get install -s patroni | sed -n -e '/^Inst patroni /d' -e 's/^Inst \([^ ]\+\) .*$/\1/p' \
+            | grep -Ev '^python3-(sphinx|etcd|consul|kazoo|kubernetes)' \
-            | xargs apt-get install -y curl jq haproxy locales python3-etcd python3-kazoo \
+            | xargs apt-get install -y vim curl less jq locales haproxy sudo \
-
+                            python3-etcd python3-kazoo python3-pip busybox \
-    ## Make sure we have a en_US.UTF-8 locale available
+    && 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 \
+    # haproxy dummy config
-    && chown postgres:postgres /home/postgres \
+    && echo 'global\n        stats socket /run/haproxy/admin.sock mode 660 level admin' > /etc/haproxy/haproxy.cfg \
-
+\
-    # Clean up
+    # vim config
-    && apt-get purge -y libpython2.7-stdlib libpython2.7-minimal \
+    && 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
+# perform compression if it is necessary
-RUN curl -L https://github.com/coreos/etcd/releases/download/v${ETCDVERSION}/etcd-v${ETCDVERSION}-linux-amd64.tar.gz \
+ARG COMPRESS
-    | tar xz -C /usr/local/bin --strip=1 --wildcards --no-anchored etcd etcdctl
+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
+FROM scratch
-RUN curl -L https://github.com/kelseyhightower/confd/releases/download/v${CONFDVERSION}/confd-${CONFDVERSION}-linux-amd64 > /usr/local/bin/confd \
+COPY --from=builder / /
-    && chmod +x /usr/local/bin/confd
 
-ADD patronictl.py patroni.py docker/entrypoint.sh /
+LABEL maintainer="Alexander Kukushkin <[email protected]>"
-ADD patroni /patroni/
-ADD extras/confd /etc/confd
 
-RUN sed -i 's/env python/&3/' patroni*.py && ln -s /patronictl.py /usr/local/bin/patronictl && mkdir /data/ /run/haproxy \
+ARG PG_MAJOR
-    && touch /pgpass /patroni.yml && chown postgres:postgres -R /patroni/ /data/ /pgpass /patroni.yml /etc/haproxy /var/run/ /var/lib/ /var/log/
+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"]

README.rst

@@ -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:

docker-compose.yml

@@ -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:
+networks:
-    container_name: patroni_etcd
+    demo:
-    image: patroni
-    command: --etcd
 
-dbnode1:
+services:
+    etcd1:
         image: patroni
-    hostname: dbnode1
+        networks: [ demo ]
-    links:
+        env_file: docker/etcd.env
-        - patroni_etcd:patroni_etcd
+        container_name: demo-etcd1
-    volumes:
+        hostname: etcd1
-        - ./patroni:/patroni
+        command: etcd -name etcd1 -initial-advertise-peer-urls http://etcd1:2380
-    env_file: docker/patroni-secrets.env
+
+    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
+
+    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
+
+    patroni1:
+        image: patroni
+        networks: [ demo ]
+        env_file: docker/patroni.env
+        hostname: patroni1
+        container_name: demo-patroni1
         environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
+            PATRONI_NAME: patroni1
-        PATRONI_NAME: dbnode1
-        PATRONI_SCOPE: testcluster
 
-dbnode2:
+    patroni2:
         image: patroni
-    hostname: dbnode2
+        networks: [ demo ]
-    links:
+        env_file: docker/patroni.env
-        - patroni_etcd:patroni_etcd
+        hostname: patroni2
-    volumes:
+        container_name: demo-patroni2
-        - ./patroni:/patroni
-    env_file: docker/patroni-secrets.env
         environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
+            PATRONI_NAME: patroni2
-        PATRONI_NAME: dbnode2
-        PATRONI_SCOPE: testcluster
 
-dbnode3:
+    patroni3:
         image: patroni
-    hostname: dbnode3
+        networks: [ demo ]
-    links:
+        env_file: docker/patroni.env
-        - patroni_etcd:patroni_etcd
+        hostname: patroni3
-    volumes:
+        container_name: demo-patroni3
-        - ./patroni:/patroni
-    env_file: docker/patroni-secrets.env
         environment:
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
+            PATRONI_NAME: patroni3
-        PATRONI_NAME: dbnode3
-        PATRONI_SCOPE: testcluster
 
-haproxy:
+    haproxy:
         image: patroni
-    links:
+        networks: [ demo ]
-        - patroni_etcd:patroni_etcd
+        env_file: docker/patroni.env
+        hostname: haproxy
+        container_name: demo-haproxy
         ports:
             - "5000:5000"
             - "5001:5001"
-    environment:
+        command: haproxy
-        PATRONI_ETCD_URL: http://patroni_etcd:2379
-        PATRONI_SCOPE: testcluster
-    command: --confd

docker/README.md

@@ -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
+You can run Patroni in a docker container using this Dockerfile
-
-    https://registry.opensource.zalan.do/v1/repositories/acid/patroni/tags
 
 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
+## Three-node Patroni cluster with three-node etcd cluster and one haproxy container using docker-compose
-
-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
 
 Example session:
 
-    $ ./dev_patroni_cluster.sh --image registry.opensource.zalan.do/acid/patroni:1.0-SNAPSHOT --members=2 --name=bravo
+    $ docker-compose up -d
-    The etcd container is 6be871a11cb373406ca5ea1c6b39e1.0-SNAPSHOTfdde9fb1d6177212d6ad0c0d1bd9b563, ip=172.17.1.24
+    Creating demo-haproxy ...
-    Started Patroni container 67e611f2eca7c40f9e6e0e24a4a8f2cba7e3e56d22a420e15ab9240a37a9d7a4, ip=172.17.1.25
+    Creating demo-patroni2 ...
-    Started Patroni container 47dd12ae635ab83b039f5889e250048b606ed5e48e3650b69e365e7e1d4acbcf, ip=172.17.1.26
+    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
+    5b7a90b4cfbf        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 27 seconds                                          demo-etcd2
-    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
+    e30eea5222f2        patroni             "/bin/sh /entrypoint…"   29 seconds ago      Up 27 seconds                                          demo-etcd1
-    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
+    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 |
+    +---------+----------+------------+--------+---------+----+-----------+
+    |   demo  | patroni1 | 172.22.0.3 | Leader | running |  1 |         0 |
+    |   demo  | patroni2 | 172.22.0.7 |        | running |  1 |         0 |
+    |   demo  | patroni3 | 172.22.0.4 |        | running |  1 |         0 |
+    +---------+----------+------------+--------+---------+----+-----------+
+
+    postgres@patroni1:~$ etcdctl ls --recursive --sort -p /service/demo
+    /service/demo/config
+    /service/demo/initialize
+    /service/demo/leader
+    /service/demo/members/
+    /service/demo/members/patroni1
+    /service/demo/members/patroni2
+    /service/demo/members/patroni3
+    /service/demo/optime/
+    /service/demo/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)

docker/dev_patroni_cluster.sh

@@ -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

docker/entrypoint.sh

@@ -1,115 +1,60 @@
-#!/bin/bash
+#!/bin/sh
 
-function usage()
+if [ -f /a.tar.xz ]; then
-{
+    echo "decompressing image..."
-    cat <<__EOF__
+    sudo tar xpJf /a.tar.xz -C / > /dev/null 2>&1
-Usage: $0
+    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
+case "$1" in
-    --confd     Do not run Patroni, run a standalone confd
+    haproxy)
-    --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"
+        CONFD="confd -prefix=$PATRONI_NAMESPACE/$PATRONI_SCOPE -interval=10 -backend"
-                    if [ ! -z ${PATRONI_ZOOKEEPER_HOSTS} ]; then
+        if [ ! -z "$PATRONI_ZOOKEEPER_HOSTS" ]; then
-                        while ! /usr/share/zookeeper/bin/zkCli.sh -server ${PATRONI_ZOOKEEPER_HOSTS} ls /; do
+            while ! /usr/share/zookeeper/bin/zkCli.sh -server $PATRONI_ZOOKEEPER_HOSTS ls /; do
                 sleep 1
             done
-                        exec $CONFD zookeeper -node ${PATRONI_ZOOKEEPER_HOSTS}
+            exec dumb-init $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
+            while ! etcdctl cluster-health 2> /dev/null; do
                 sleep 1
             done
-                        exec $CONFD etcd -node $PATRONI_ETCD_URL
+            exec dumb-init $CONFD etcd -node $(echo $ETCDCTL_ENDPOINTS | sed 's/,/ -node /g')
         fi
         ;;
     etcd)
-                    exec etcd $ETCD_ARGS
+        exec "$@" -advertise-client-urls http://$DOCKER_IP:2379
         ;;
     zookeeper)
         exec /usr/share/zookeeper/bin/zkServer.sh start-foreground
         ;;
-                cheat)
+esac
-                    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
 
 ## We start an etcd
-if [[ -z ${PATRONI_ETCD_URL} && -z ${PATRONI_ZOOKEEPER_HOSTS} ]]; then
+if [ -z "$PATRONI_ETCD_HOSTS" ] && [ -z "$PATRONI_ZOOKEEPER_HOSTS" ]; then
-    etcd $ETCD_ARGS > /var/log/etcd.log 2> /var/log/etcd.err &
     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_NAMESPACE
-export PATRONI_RESTAPI_CONNECT_ADDRESS="${DOCKER_IP}:8008"
+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__
+exec python3 /patroni.py postgres0.yml
-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

docker/etcd.env

@@ -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

docker/patroni.env

@@ -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

docs/ENVIRONMENT.rst

@@ -14,10 +14,13 @@ Global/Universal
 -  **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}"``
+-  **PATRONI\_DEBUG\_MODE**: When set to a non-empty value, makes Patroni run in the special debug mode that enables stepping with a debugger through some execution paths within Patroni `
+Example ``PATRONI_DEBUG_MODE="on"``
 
 Bootstrap configuration
 -----------------------
@@ -40,6 +43,7 @@ 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
@@ -50,6 +54,7 @@ Etcd
 -  **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.
@@ -88,6 +93,8 @@ 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
 --------

docs/README.rst

@@ -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:

docs/SETTINGS.rst

@@ -15,6 +15,7 @@ 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.
@@ -50,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.
+            -  **database**: the database name where logical slots should be created.
-               **plugin**: the plugin name for the logical slot.
+            -  **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``
@@ -87,6 +88,7 @@ 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
@@ -97,6 +99,7 @@ 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.
@@ -136,12 +139,15 @@ 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\_restart**: run this script when the postgres restarts (without changing role).
-        -  **on\_role\_change**: run this script when the cluster is being promoted or demoted.
+        -  **on\_role\_change**: run this script when the postgres is being promoted or demoted.
-        -  **on\_start**: run this script when the cluster starts.
+        -  **on\_start**: run this script when the postgres starts.
-        -  **on\_stop**: run this script when the cluster stops.
+        -  **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
@@ -150,7 +156,7 @@ PostgreSQL
 -  **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.
@@ -158,10 +164,13 @@ 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 postgres data directory and recreate 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**.
+-  **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

docs/existing_data.rst

@@ -12,24 +12,25 @@ 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:
 
-#. Manually start PostgreSQL daemon
+1. Manually start PostgreSQL daemon
-#. 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:
+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';
 
-#. 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.
+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.
-#. Ask Patroni to restart the node with ``patronictl restart cluster-name node-name``.
+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.
+- 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.
+  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``
+- 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.
+  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.

docs/releases.rst

@@ -3,6 +3,161 @@
 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
 -------------
 

features/environment.py

@@ -111,9 +111,9 @@ 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
@@ -298,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])
 
 
@@ -637,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'},
@@ -653,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)
                     }
                 }
             },

features/patroni_api.feature

@@ -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

features/standby_cluster.feature

@@ -2,19 +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 2 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 2 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
+    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
@@ -24,6 +25,12 @@ Feature: standby cluster
     Then postgres1 is a leader of batman1 after 10 seconds
     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
@@ -31,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

features/steps/cascading_replication.py

@@ -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')
+@then('There is a {label} with "{content}" in {name:w} data directory')
-def check_label(context, content, name):
+def check_label(context, label, content, name):
-    label = context.pctl.read_label(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)
 
 

features/steps/standby_cluster.py

@@ -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,12 +26,18 @@ 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):
+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
     os.unlink(os.path.join(context.pctl._processes[name]._data_dir, 'patroni.dynamic.json'))
     port = context.pctl._processes[name2]._connkwargs.get('port')
@@ -37,12 +45,19 @@ def start_patroni_stanby_cluster(context, name, cluster_name, name2):
         "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)
@@ -60,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)
-
+    else:
-    return False
+        assert False, "{0} is not replicating from {1} after {2} seconds".format(pg_name1, pg_name2, timeout)

kubernetes/patroni_k8s.yaml

@@ -159,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:
@@ -173,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:

patroni.py

@@ -1,6 +1,14 @@
 #!/usr/bin/env python
 from patroni import main
 
+import os
 
 if __name__ == '__main__':
+
+    if os.getenv("PATRONI_DEBUG_MODE"):
+        # XXX Visual Code specific https://github.com/microsoft/ptvsd/issues/1443
+        # create processes by spawning new Python interpreters instead of forking the current one 
+        import multiprocessing
+        multiprocessing.set_start_method('spawn', True)
+
     main()

patroni/__init__.py

@@ -32,6 +32,7 @@ class Patroni(object):
         self.postgresql = Postgresql(self.config['postgresql'])
         self.api = RestApiServer(self, self.config['restapi'])
         self.ha = Ha(self)
+        self.is_in_debug_mode = bool(os.getenv("PATRONI_DEBUG_MODE"))
 
         self.tags = self.get_tags()
         self.next_run = time.time()
@@ -85,6 +86,7 @@ class Patroni(object):
         self._received_sighup = True
 
     def sigterm_handler(self, *args):
+        with self._sigterm_lock:
             if not self._received_sigterm:
                 self._received_sigterm = True
                 sys.exit()
@@ -101,16 +103,22 @@ class Patroni(object):
             self.next_run = current_time
             # Release the GIL so we don't starve anyone waiting on async_executor lock
             time.sleep(0.001)
-            # Warn user that Patroni is not keeping up
+            # Warn user that Patroni is not keeping up or runs in debug
-            logger.warning("Loop time exceeded, rescheduling immediately.")
+            msg = "Patroni runs in the debug mode: keys' TTL is infinite, loop wait disabled" if self.is_in_debug_mode else "Loop time exceeded, rescheduling immediately."
+            logger.warning(msg)
         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():
@@ -128,18 +136,24 @@ 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():
@@ -150,37 +164,40 @@ def patroni_main():
         pass
     finally:
         patroni.shutdown()
-        logging.shutdown()
 
 
-def pg_ctl_start(args):
+def fatal(string, *args):
-    import subprocess
+    sys.stderr.write('FATAL: ' + string.format(*args) + '\n')
-    if os.name != 'nt':
+    sys.exit(1)
-        os.setsid()
-    postmaster = subprocess.Popen(args)
-    print(postmaster.pid)
 
 
-def call_self(args, **kwargs):
+def check_psycopg2():
-    """This function executes Patroni once again with provided arguments.
+    min_psycopg2 = (2, 5, 4)
+    min_psycopg2_str = '.'.join(map(str, min_psycopg2))
 
-    :args: list of arguments to call Patroni with.
+    def parse_version(version):
-    :returns: `Popen` object"""
+        for e in version.split('.'):
+            try:
+                yield int(e)
+            except ValueError:
+                break
 
-    exe = [sys.executable]
+    try:
-    if not getattr(sys, 'frozen', False):  # Binary distribution?
+        import psycopg2
-        exe.append(sys.argv[0])
+        version_str = psycopg2.__version__.split(' ')[0]
-
+        version = tuple(parse_version(version_str))
-    import subprocess
+        if version < min_psycopg2:
-    return subprocess.Popen(exe + args, **kwargs)
+            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 +216,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.SIGINT, passtochild)
         signal.signal(signal.SIGUSR1, passtochild)
         signal.signal(signal.SIGUSR2, passtochild)
+    signal.signal(signal.SIGINT, 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()

patroni/api.py

@@ -7,10 +7,12 @@ 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
@@ -74,30 +76,45 @@ 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
 
-        replica_status_code = 200 if not patroni.noloadbalance and response.get('role') == 'replica' else 503
+        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' and response.get('state') == 'running' 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:
+        elif 'master' in path or 'leader' in path or 'primary' in path or 'read-write' in path:
-            # Round-robing across all masters in pause mode if DCS is not accessible
+            status_code = primary_status_code
-            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 '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
@@ -112,6 +129,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)
 
@@ -229,7 +250,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
@@ -446,6 +467,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:
@@ -510,8 +534,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,
+        self.connection_string = uri(self.__protocol, config.get('connect_address') or self.__listen, 'patroni')
-                                                            config.get('connect_address') or self.__listen)
+
+    @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:
@@ -526,7 +576,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)
 
@@ -536,7 +586,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
 

patroni/async_executor.py

@@ -52,8 +52,8 @@ class CriticalTask(object):
 
 class AsyncExecutor(object):
 
-    def __init__(self, state_handler, ha_wakeup):
+    def __init__(self, cancellable, ha_wakeup):
-        self.state_handler = state_handler
+        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:

patroni/config.py

@@ -9,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
 
@@ -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 = {}
+        return {name: value for name, value in (parameters or {}).items()
-        for name, value in (parameters or {}).items():
+                if name not in ConfigHandler.CMDLINE_OPTIONS or
-            if name not in Postgresql.CMDLINE_OPTIONS or not is_local and Postgresql.CMDLINE_OPTIONS[name][1](value):
+                not is_local and ConfigHandler.CMDLINE_OPTIONS[name][1](value)}
-                ret[name] = value
-        return ret
 
     def _safe_copy_dynamic_configuration(self, dynamic_configuration):
         config = deepcopy(self.__DEFAULT_CONFIG)
@@ -233,8 +231,9 @@ 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', 'dir', 'file_size', 'file_num', 'loggers'])
+        _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('{'):
@@ -264,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
@@ -285,10 +284,10 @@ class Config(object):
             if param.startswith(Config.PATRONI_ENV_PREFIX):
                 # PATRONI_(ETCD|CONSUL|ZOOKEEPER|EXHIBITOR|...)_(HOSTS?|PORT|..)
                 name, suffix = (param[8:].split('_', 1) + [''])[:2]
-                if suffix in ('HOST', 'HOSTS', 'PORT', 'PROTOCOL', 'SRV', 'URL', 'PROXY', 'CACERT', 'CERT', 'KEY',
+                if suffix in ('HOST', 'HOSTS', 'PORT', 'USE_PROXIES', 'PROTOCOL', 'SRV', 'URL', 'PROXY',
-                              'VERIFY', 'TOKEN', 'CHECKS', 'DC', 'REGISTER_SERVICE', 'SERVICE_CHECK_INTERVAL',
+                              'CACERT', 'CERT', 'KEY', 'VERIFY', 'TOKEN', 'CHECKS', 'DC', 'CONSISTENCY',
-                              'NAMESPACE', 'CONTEXT', 'USE_ENDPOINTS', 'SCOPE_LABEL', 'ROLE_LABEL', 'POD_IP',
+                              'REGISTER_SERVICE', 'SERVICE_CHECK_INTERVAL', 'NAMESPACE', 'CONTEXT',
-                              'PORTS', 'LABELS') and name:
+                              '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)
@@ -296,7 +295,7 @@ class Config(object):
                         value = value and _parse_list(value)
                     elif suffix == 'LABELS':
                         value = _parse_dict(value)
-                    elif suffix == 'REGISTER_SERVICE':
+                    elif suffix in ('USE_PROXIES', 'REGISTER_SERVICE'):
                         value = parse_bool(value)
                     if value:
                         ret[name.lower()][suffix.lower()] = value
@@ -334,6 +333,11 @@ class Config(object):
             elif name not in config or name in ['watchdog']:
                 config[name] = deepcopy(value) if value else {}
         
+        if os.getenv("PATRONI_DEBUG_MODE"):
+            config['ttl'] = 24 * 60 * 60 # practical infinity for a debugging session
+            config['loop_wait'] = -1
+
+
         # restapi server expects to get restapi.auth = 'username:password'
         if 'authentication' in config['restapi']:
             config['restapi']['auth'] = '{username}:{password}'.format(**config['restapi']['authentication'])

patroni/ctl.py

@@ -14,7 +14,6 @@ import io
 import json
 import logging
 import os
-import psycopg2
 import random
 import requests
 import subprocess
@@ -30,6 +29,7 @@ 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,11 +63,14 @@ def parse_dcs(dcs):
     elif scheme not in DCS_DEFAULTS:
         raise PatroniCtlException('Unknown dcs scheme: {}'.format(scheme))
 
-    dcs_info = DCS_DEFAULTS[scheme]
+    default = DCS_DEFAULTS[scheme]
-    return yaml.load(dcs_info['template'].format(host=parsed.hostname or 'localhost', port=port or dcs_info['port']))
+    return yaml.safe_load(default['template'].format(host=parsed.hostname or 'localhost', port=port or default['port']))
 
 
 def load_config(path, dcs):
+    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)
@@ -107,12 +110,16 @@ option_insecure = click.option('-k', '--insecure', is_flag=True, help='Allow con
 
 
 @click.group()
-@click.option('--config-file', '-c', help='Configuration file', default=CONFIG_FILE_PATH)
+@click.option('--config-file', '-c', help='Configuration file',
+              envvar='PATRONICTL_CONFIG_FILE', default=CONFIG_FILE_PATH)
 @click.option('--dcs', '-d', help='Use this DCS', envvar='DCS')
 @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
@@ -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,8 +294,16 @@ 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 scheduled_at:
         if not force:
-        confirm = click.confirm('Are you sure you want to {0} members {1}?'.format(action, ', '.join(member_names)))
+            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))
 
@@ -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,8 +669,13 @@ 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 scheduled_at_str:
-        if not click.confirm('Are you sure you want to {0} cluster {1}{2}?'.format(action, cluster_name, demote_msg)):
+            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
@@ -1079,15 +1106,40 @@ def apply_yaml_file(data, filename):
     return format_config_for_editing(changed_data), changed_data
 
 
+def find_executable(executable, path=None):
+    _, ext = os.path.splitext(executable)
+
+    if (sys.platform == 'win32') and (ext != '.exe'):
+        executable = executable + '.exe'
+
+    if os.path.isfile(executable):
+        return executable
+
+    if path is None:
+        path = os.environ.get('PATH', os.defpath)
+
+    for p in path.split(os.pathsep):
+        f = os.path.join(p, executable)
+        if os.path.isfile(f):
+            return f
+
+
 def invoke_editor(before_editing, cluster_name):
     """Starts editor command to edit configuration in human readable format
 
     :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',

patroni/dcs/__init__.py

@@ -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(
+            conn_url = uri('postgresql', (conn_kwargs.get('host'), conn_kwargs.get('port', 5432)))
-                host=conn_kwargs.get('host'),
-                port=conn_kwargs.get('port'),
-            )
             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')):
 
@@ -529,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()
@@ -576,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"""
@@ -603,22 +620,26 @@ class AbstractDCS(object):
            instance would be demoted."""
 
     def get_cluster(self):
-        with self._cluster_thread_lock:
         try:
-                self._load_cluster()
+            cluster = self._load_cluster()
         except Exception:
-                self._cluster = None
+            self.reset_cluster()
             raise
-            return self._cluster
+
+        with self._cluster_thread_lock:
+            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):
@@ -684,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.

patroni/dcs/consul.py

@@ -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
@@ -40,7 +40,7 @@ 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):
@@ -122,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):
@@ -131,10 +131,15 @@ class ConsulClient(base.Consul):
             kwargs['cert'] = self._cert
         if self._ca_cert:
             kwargs['ca_cert'] = self._ca_cert
-        if self._token:
+        if self.token:
-            kwargs['token'] = 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):
@@ -197,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')
@@ -232,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)
@@ -299,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)
@@ -342,15 +355,15 @@ 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')
 
     @catch_consul_errors
-    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)
         create_member = not permanent and self.refresh_session()
@@ -503,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
@@ -521,5 +535,4 @@ class Consul(AbstractDCS):
         try:
             return super(Consul, self).watch(None, timeout)
         finally:
-            self._last_session_refresh = 0
             self.event.clear()

patroni/dcs/etcd.py

@@ -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:
+        elif not self._use_proxies and time.time() - self._machines_cache_updated > self._machines_cache_ttl:
-            self._machines_cache = self.machines
+            self._refresh_machines_cache()
-            if self._base_uri in self._machines_cache:
-                self._machines_cache.remove(self._base_uri)
             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:
+            if some_request_failed:
-                self._machines_cache = self.machines
+                self._refresh_machines_cache()
-                if self._base_uri in self._machines_cache:
-                    self._machines_cache.remove(self._base_uri)
         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 = []
+            ret = map(lambda res: uri(self.protocol, res[-1][:2]), self._dns_resolver.resolve(host, port))
-            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))
             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 = self._get_machines_cache_from_config()
-            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'])
 
         # 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
+        self._refresh_machines_cache()
-
-        if self._base_uri in self._machines_cache:
-            self._machines_cache.remove(self._base_uri)
 
         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):

patroni/dcs/exhibitor.py

@@ -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

patroni/dcs/kubernetes.py

@@ -107,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):
@@ -124,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)
@@ -146,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
@@ -201,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')
@@ -280,7 +286,10 @@ class Kubernetes(AbstractDCS):
         if self.__subsets and not patch and not resource_version:
             self._should_create_config_service = True
             self._create_config_service()
-        return self.patch_or_create(self.config_path, annotations, resource_version, patch, retry)
+        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)
@@ -349,11 +358,10 @@ 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_config({self._CONFIG: value}, index, bool(self._config_resource_version), False)
-        return self.patch_or_create_config({self._CONFIG: value}, index, patch, 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 = 'promoted' if data['role'] in ('replica', 'promoted') else 'master'
@@ -386,15 +394,14 @@ class Kubernetes(AbstractDCS):
             self.reset_cluster()
 
     def cancel_initialization(self):
-        self.patch_or_create_config({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_config({self._HISTORY: value}, None, bool(self._config_resource_version), False)
-        return self.patch_or_create_config({self._HISTORY: value}, None, patch, False)
 
     def set_sync_state_value(self, value, index=None):
         """Unused"""

patroni/dcs/zookeeper.py

@@ -126,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
@@ -206,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:
@@ -264,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:

patroni/ha.py

@@ -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
@@ -59,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
@@ -71,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
@@ -112,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:
@@ -130,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
@@ -154,8 +157,9 @@ 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
+        if info:
             logger.info('Lock owner: %s; I am %s', lock_owner, self.state_handler.name)
         return lock_owner == self.state_handler.name
 
@@ -173,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
@@ -206,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)
@@ -237,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
@@ -267,12 +280,12 @@ class Ha(object):
 
     def _handle_rewind_or_reinitialize(self):
         leader = self.get_remote_master() if self.is_standby_cluster() else self.cluster.leader
-        if not self.state_handler.rewind_or_reinitialize_needed_and_possible(leader):
+        if not self._rewind.rewind_or_reinitialize_needed_and_possible(leader):
             return None
 
-        if self.state_handler.can_rewind:
+        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
@@ -301,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 \
+        logger.info('pg_controldata:\n%s\n', '\n'.join('  {0}: {1}'.format(k, v) for k, v in data.items()))
-                not self._crash_recovery_executed and (self.cluster.is_unlocked() or self.state_handler.can_rewind):
+        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)
@@ -310,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:
+            if not self._rewind.executed:
-                self.state_handler.trigger_check_diverged_lsn()
+                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"
@@ -332,15 +349,13 @@ 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 (self.cluster.is_unlocked() or self.has_lock(False)):
-
-        if self.is_standby_cluster() and (is_leader or self.cluster.is_unlocked()):
             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)
@@ -358,7 +373,7 @@ 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_reinitialize_allowed)\
+            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:
@@ -372,9 +387,17 @@ class Ha(object):
         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
 
@@ -409,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:
+                    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
@@ -427,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 \
@@ -489,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):
@@ -521,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
@@ -585,7 +614,11 @@ class Ha(object):
                         return False
                     if my_wal_position < st.wal_position:
                         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):
@@ -693,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):
@@ -717,13 +754,14 @@ 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']:
+            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']:
@@ -740,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)
+                self.state_handler.config.set_synchronous_standby(None)
-            if self.state_handler.rewind_or_reinitialize_needed_and_possible(leader):
+            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)
 
@@ -843,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(
@@ -857,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:
@@ -872,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._delete_leader()
-                self.dcs.reset_cluster()
                 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)
 
@@ -886,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(
@@ -909,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)
 
@@ -945,8 +990,7 @@ class Ha(object):
         if role and role != self.state_handler.role:
             reason_to_cancel = "host role mismatch"
 
-        if (postgres_version and
+        if postgres_version and postgres_version_to_int(postgres_version) <= int(self.state_handler.server_version):
-           self.state_handler.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:
@@ -1040,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:
@@ -1086,8 +1130,7 @@ class Ha(object):
             self.watchdog.disable()
             if self.has_lock():
                 self.state_handler.set_role('demoted')
-                self.dcs.delete_leader()
+                self._delete_leader()
-                self.dcs.reset_cluster()
                 return 'removed leader key after trying and failing to start postgres'
             return 'failed to start postgres'
         self._crash_recovery_executed = False
@@ -1111,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'
 
@@ -1120,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)
@@ -1209,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()
@@ -1253,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._delete_leader()
-                        self.dcs.reset_cluster()
                         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 \
+                    elif self._rewind.failed or not self._rewind.executed and not \
-                            or not self.state_handler.can_rewind_or_reinitialize_allowed:
+                            (self._rewind.is_needed and self._rewind.can_rewind_or_reinitialize_allowed):
                         return 'postgres is not running'
 
                 # try to start dead postgres
@@ -1279,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
@@ -1325,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 \
+        if self._async_executor.busy or self.cluster.is_unlocked() or self.has_lock(False):
-                and cluster.leader.name != self.state_handler.name:
-            leader_index = cluster.leader.index
-        else:
             leader_index = None
+        else:
+            leader_index = self.cluster.leader.index
 
         return self.dcs.watch(leader_index, timeout)
 
@@ -1341,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
@@ -1349,12 +1389,16 @@ class Ha(object):
         cluster_params = self.get_standby_cluster_config()
 
         if cluster_params:
-            unique_name = 'remote_master:{}'.format(uuid.uuid1())
+            name = member.name if member else 'remote_master:{}'.format(uuid.uuid1())
 
             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 = {k: cluster_params[k] for k in ('host', 'port') if k 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(unique_name, data)
+            return RemoteMember(name, data)
+
+    def get_remote_master(self):
+        return self.get_remote_member()

patroni/log.py

@@ -1,66 +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 PatroniLogger(object):
+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):
-        self.root_logger = logging.getLogger()
+        super(PatroniLogger, self).__init__()
-        self.config = None
+        self.daemon = True
-        self.handler = None
+        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 {})
+        loggers = deepcopy(self._config.get('loggers') or {})
-        for name, logger in self.root_logger.manager.loggerDict.items():
+        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 = 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):
+        if self._config is None or not deep_compare(self._config, config):
-            self.root_logger.setLevel(config.get('level', PatroniLogger.DEFAULT_LEVEL))
+            with self._queue_handler.queue.mutex:
+                self._queue_handler.queue.maxsize = config.get('max_queue_size', self.DEFAULT_MAX_QUEUE_SIZE)
 
-            add_handler = None
+            self._root_logger.setLevel(config.get('level', PatroniLogger.DEFAULT_LEVEL))
+
+            new_handler = None
             if 'dir' in config:
-                if not isinstance(self.handler, RotatingFileHandler):
+                if not isinstance(self._log_handler, RotatingFileHandler):
-                    add_handler = RotatingFileHandler(os.path.join(config['dir'], __name__))
+                    new_handler = RotatingFileHandler(os.path.join(config['dir'], __name__))
-                handler = add_handler or self.handler
+                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.handler is None or isinstance(self.handler, RotatingFileHandler):
+                if self._log_handler is None or isinstance(self._log_handler, RotatingFileHandler):
-                    add_handler = logging.StreamHandler()
+                    new_handler = logging.StreamHandler()
-                handler = add_handler or self.handler
+                handler = new_handler or self._log_handler
 
-            oldlogformat = (self.config or {}).get('format', PatroniLogger.DEFAULT_FORMAT)
+            oldlogformat = (self._config or {}).get('format', PatroniLogger.DEFAULT_FORMAT)
             logformat = config.get('format', PatroniLogger.DEFAULT_FORMAT)
 
-            olddateformat = (self.config or {}).get('dateformat') or None
+            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 add_handler:
+            if oldlogformat != logformat or olddateformat != dateformat or new_handler:
                 handler.setFormatter(logging.Formatter(logformat, dateformat))
 
-            if add_handler:
+            if new_handler:
-                self.root_logger.addHandler(add_handler)
+                with self._log_handler_lock:
+                    if self._log_handler:
+                        self._old_handlers.append(self._log_handler)
+                    self._log_handler = new_handler
 
-                if self.handler is not None:
+            self._config = config.copy()
-                    self.root_logger.removeHandler(self.handler)
-                    self.handler.close()
-
-                self.handler = add_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

patroni/postgresql/__init__.py

@@ -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

patroni/postgresql/bootstrap.py

@@ -0,0 +1,385 @@
+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)'):
+                        sql = """DO $$
+BEGIN
+    SET local synchronous_commit = 'local';
+    GRANT EXECUTE ON function pg_catalog.{0} TO "{1}";
+END;$$""".format(f, rewind['username'])
+                        postgresql.query(sql)
+
+                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

patroni/postgresql/callback_executor.py

@@ -19,8 +19,11 @@ class CallbackExecutor(Thread):
     def call(self, cmd):
         with self._lock:
             if self._process and self._process.poll() is None:
+                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()
 

patroni/postgresql/cancellable.py

@@ -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()

patroni/postgresql/config.py

@@ -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) >= 25, 90100),
+        'max_wal_senders': (10, lambda v: int(v) >= 3, 90100),
+        'wal_keep_segments': (8, lambda v: int(v) >= 1, 90100),
+        'max_prepared_transactions': (0, lambda v: int(v) >= 0, 90100),
+        'max_locks_per_transaction': (64, lambda v: int(v) >= 32, 90100),
+        'track_commit_timestamp': ('off', lambda v: parse_bool(v) is not None, 90500),
+        'max_replication_slots': (10, lambda v: int(v) >= 4, 90400),
+        'max_worker_processes': (8, lambda v: int(v) >= 2, 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)

patroni/postgresql/connection.py

@@ -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

patroni/postgresql/misc.py

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

patroni/postgresql/postmaster.py

@@ -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):
@@ -159,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'),
+        parent_conn, child_conn = multiprocessing.Pipe(False)
-                         stdout=subprocess.PIPE, env=env)
+        proc = multiprocessing.Process(target=pg_ctl_start, args=(child_conn, cmdline, env))
-        pid = int(proc.stdout.readline().strip())
+        proc.start()
-        proc.wait()
+        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

patroni/postgresql/rewind.py

@@ -0,0 +1,217 @@
+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)
+        env['PGOPTIONS'] = '-c statement_timeout=0'
+        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

patroni/postgresql/slots.py

@@ -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

patroni/utils.py

@@ -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)
+    for regex, base in ((HEX_RE, 16), (OCT_RE, 8), (DEC_RE, 10)):
-    i = 0
+        match = regex.match(value)
-    # skip sign:
+        if match:
-    if i < ln and value[i] in ('-', '+'):
+            end = match.end()
-        i += 1
+            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
+def strtod(value):
-        while i <= ln:
+    """As most as possible close equivalent of strtod(3) function used by postgres to parse parameter values.
-            try:  # try to find maximally long number
+    >>> strtod(' A ') == (None, 'A')
-                i += 1  # by giving to `int` longer and longer strings
+    True
-                ret = int(value[:i], base)
+    """
-            except ValueError:  # until we will not get an exception or end of the string
+    value = str(value).strip()
-                i -= 1
+    match = DBL_RE.match(value)
-                break
+    if match:
-        if ret is not None:  # yay! there is a number in the beginning of the string
+        end = match.end()
-            return ret, value[i:].strip()  # return the number and the "rest"
+        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 = {
+    val, unit = strtol(value)
-        'kB': {'kB': 1, 'MB': 1024, 'GB': 1024 * 1024, 'TB': 1024 * 1024 * 1024},
+    if val is None and unit.startswith('.') or unit and unit[0] in ('.', 'e', 'E'):
-        'ms': {'ms': 1, 's': 1000, 'min': 1000 * 60, 'h': 1000 * 60 * 60, 'd': 1000 * 60 * 60 * 24},
+        val, unit = strtod(value)
-        '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}
-    }
 
-    value, unit = strtol(value)
+    if val is not None:
-    if value is not None:
+        unit = unit.strip()
         if not unit:
-            return value
+            return int(rint(val))
 
-        if base_unit and base_unit not in convert:
+        val = convert_to_base_unit(val, unit, base_unit)
-            base_value, base_unit = strtol(base_unit, False)
+        if val is not None:
-        else:
+            return int(rint(val))
-            base_value = 1
+
-        if base_unit in convert and unit in convert[base_unit]:
+
-            multiplier = convert[base_unit][unit]
+def parse_real(value, base_unit=None):
-            if multiplier < 0:
+    """
-                value /= -multiplier
+    >>> parse_real(' +0.0005 ') == 0.0005
-            else:
+    True
-                value *= multiplier
+    >>> parse_real('0.0005ms', 'ms') == 0.0
-            return int(value/base_value)
+    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
+    converters = {
-    if vartype == 'bool':
+        'bool': lambda v1, v2: parse_bool(v1),
-        old_value = parse_bool(old_value)
+        'integer': parse_int,
-        new_value = parse_bool(new_value)
+        'real': parse_real,
-    elif vartype == 'integer':
+        'enum': lambda v1, v2: str(v1).lower(),
-        old_value = parse_int(old_value)
+        'string': lambda v1, v2: str(v1)
-        new_value = parse_int(new_value, unit)
+    }
-    elif vartype == 'enum':
+
-        return str(old_value).lower() == str(new_value).lower()
+    convert = converters.get(vartype) or converters['string']
-    else:  # ('string', 'real')
+    old_value = convert(old_value, None)
-        return str(old_value) == str(new_value)
+    new_value = convert(new_value, unit)
+
     return old_value is not None and new_value is not None and old_value == new_value
 
 
@@ -252,16 +311,18 @@ 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:
+                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)

patroni/version.py

@@ -1 +1 @@
-__version__ = '1.5.5'
+__version__ = '1.6.0'

patroni/watchdog/linux.py

@@ -1,6 +1,5 @@
 import collections
 import ctypes
-import fcntl
 import os
 import platform
 from patroni.watchdog.base import WatchdogBase, WatchdogError
@@ -162,6 +161,8 @@ class LinuxWatchdogDevice(WatchdogBase):
         Raises OSError or IOError (Python 2) when the ioctl fails."""
         if self._fd is None:
             raise WatchdogError("Watchdog device is closed")
+        if os.name != 'nt':
+            import fcntl
             fcntl.ioctl(self._fd, func, arg, True)
 
     def get_support(self):

postgres0.yml

@@ -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:

postgres1.yml

@@ -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

postgres2.yml

@@ -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

requirements.txt

@@ -1,6 +1,5 @@
 urllib3>=1.19.1,!=1.21
 boto
-psycopg2>=2.5.4
 PyYAML
 requests
 six >= 1.7

setup.py

@@ -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')
+    fatal('patroni needs to be run with Python 2.7+')
-    sys.exit(1)
+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,

tests/__init__.py

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

tests/test_api.py

@@ -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
@@ -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,7 +414,8 @@ 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:

tests/test_bootstrap.py

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

tests/test_callback_executor.py

@@ -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])

tests/test_cancellable.py

@@ -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()

tests/test_config.py

@@ -52,7 +52,7 @@ class TestConfig(unittest.TestCase):
             'PATRONI_ETCD_KEY': '/key',
             'PATRONI_CONSUL_HOST': '127.0.0.1:8500',
             'PATRONI_CONSUL_REGISTER_SERVICE': 'on',
-            'PATRONI_KUBERNETES_LABELS': 'a:b:c',
+            'PATRONI_KUBERNETES_LABELS': 'a: b: c',
             'PATRONI_KUBERNETES_SCOPE_LABEL': 'a',
             'PATRONI_KUBERNETES_PORTS': '[{"name": "postgresql"}]',
             'PATRONI_ZOOKEEPER_HOSTS': "'host1:2181','host2:2181'",

tests/test_consul.py

@@ -5,7 +5,7 @@ from consul import ConsulException, NotFound
 from mock import Mock, patch
 from patroni.dcs.consul import AbstractDCS, Cluster, Consul, ConsulInternalError, \
                                 ConsulError, HTTPClient, InvalidSessionTTL, InvalidSession
-from test_etcd import SleepException
+from . import SleepException
 
 
 def kv_get(self, key, **kwargs):
@@ -83,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))
@@ -197,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})

tests/test_ctl.py

@@ -9,14 +9,15 @@ from datetime import datetime, timedelta
 from mock import patch, Mock
 from patroni.ctl import ctl, store_config, load_config, output_members, request_patroni, get_dcs, parse_dcs, \
     get_all_members, get_any_member, get_cursor, query_member, configure, PatroniCtlException, apply_config_changes, \
-    format_config_for_editing, show_diff, invoke_editor, format_pg_version
+    format_config_for_editing, show_diff, invoke_editor, format_pg_version, find_executable
 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
 
@@ -533,9 +543,11 @@ 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):
+    @patch('subprocess.call', return_value=1)
-        for e in ('', 'false'):
+    def test_invoke_editor(self, mock_subprocess_call):
-            os.environ['EDITOR'] = e
+        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')
@@ -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')
@@ -574,3 +587,12 @@ class TestCtl(unittest.TestCase):
     def test_format_pg_version(self):
         self.assertEqual(format_pg_version(100001), '10.1')
         self.assertEqual(format_pg_version(90605), '9.6.5')
+
+    @patch('sys.platform', 'win32')
+    def test_find_executable(self):
+        with patch('os.path.isfile', Mock(return_value=True)):
+            self.assertEqual(find_executable('vim'), 'vim.exe')
+        with patch('os.path.isfile', Mock(return_value=False)):
+            self.assertIsNone(find_executable('vim'))
+        with patch('os.path.isfile', Mock(side_effect=[False, True])):
+            self.assertEqual(find_executable('vim', '/'), '/vim.exe')

tests/test_etcd.py

@@ -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
 
-
+from . import SleepException, MockResponse, requests_get
-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
 
 
 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)
-    if url == 'http://localhost:2379/v2/machines':
     ret = MockResponse()
+    if url == 'http://localhost:2379/v2/machines':
         ret.content = 'http://localhost:2379,http://localhost:4001'
-        return ret
+    elif url == 'http://localhost:4001/v2/machines':
-    if url == 'http://localhost:2379/':
+        ret.content = ''
-        return MockResponse()
+    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})
+            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()

tests/test_exhibitor.py

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

tests/test_ha.py

@@ -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 patroni.watchdog import Watchdog
-from test_postgresql import psycopg2_connect, MockPostmaster
+
+from . import PostgresInit, MockPostmaster, psycopg2_connect, requests_get
+from .test_etcd import socket_getaddrinfo, etcd_read, etcd_write
 
 SYSID = '12345678901'
 
@@ -119,6 +124,7 @@ zookeeper:
 
         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()
@@ -144,14 +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(SlotsHandler, 'sync_replication_slots', Mock())
-@patch.object(Postgresql, 'write_pg_hba', 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_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))
@@ -160,21 +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,
-                                 '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))
@@ -203,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'})))
+                  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))
+                                                          '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()
@@ -241,15 +250,15 @@ 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_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(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(Postgresql, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
-    @patch.object(Postgresql, 'create_replica', Mock(return_value=1))
+    @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()
@@ -321,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')
@@ -353,11 +362,11 @@ class TestHa(unittest.TestCase):
         self.p.is_leader = false
         self.assertEqual(self.ha.run_cycle(), 'PAUSE: no action')
 
-    @patch.object(Postgresql, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(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')
 
@@ -468,7 +477,7 @@ 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_or_reinitialize_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')
@@ -576,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
@@ -585,6 +596,9 @@ 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):
@@ -649,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))
@@ -670,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.p.config.check_recovery_conf = true
-        self.assertEqual(self.ha.run_cycle(), msg)
+        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(), 'no action.  i am a secondary and i am following a standby leader')
-        self.assertEqual(self.ha.run_cycle(), msg)
+        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'
@@ -687,11 +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(), 'promoted self to a standby leader by acquiring session lock')
-        self.assertEqual(self.ha.run_cycle(), msg)
 
-    @patch.object(Postgresql, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
+    @patch.object(Rewind, 'rewind_or_reinitialize_needed_and_possible', Mock(return_value=True))
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(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'
@@ -802,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
@@ -859,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()
@@ -875,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
@@ -998,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
+        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

tests/test_kubernetes.py

@@ -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()
 
-    @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):
+        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()
+
         with patch.object(k8s_client.CoreV1Api, 'list_namespaced_pod', Mock(side_effect=Exception)):
             self.assertRaises(KubernetesError, self.k.get_cluster)
 

tests/test_log.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import sys
 import unittest
@@ -6,14 +7,23 @@ 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,
@@ -29,8 +39,20 @@ class TestPatroniLogger(unittest.TestCase):
         patroni_config = Config()
         logger.reload_config(patroni_config['log'])
 
-        self.assertEqual(logger.handler.maxBytes, config['log']['file_size'])
+        with patch.object(logging.Handler, 'format', Mock(side_effect=Exception)):
-        self.assertEqual(logger.handler.backupCount, config['log']['file_num'])
+            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)

tests/test_patroni.py

@@ -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 patroni.postgresql import Postgresql
-from six.moves import BaseHTTPServer
+from patroni.postgresql.config import ConfigHandler
-from test_etcd import SleepException, etcd_read, etcd_write
+from patroni import Patroni, main as _main, patroni_main, check_psycopg2
-from test_postgresql import Postgresql, psycopg2_connect, MockPostmaster
+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(ConfigHandler, 'append_pg_hba', Mock())
-@patch.object(Postgresql, '_write_postgresql_conf', Mock())
+@patch.object(ConfigHandler, 'write_postgresql_conf', Mock())
-@patch.object(Postgresql, 'write_recovery_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)

tests/test_postgresql.py

@@ -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.dcs import Cluster, ClusterConfig, Member, RemoteMember, SyncState
-from patroni.exceptions import PostgresConnectionException, PostgresException
+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
 
+from . import BaseTestPostgresql, MockCursor, MockPostmaster, psycopg2_connect
 
-class MockCursor(object):
 
-    def __init__(self, connection):
+mtime_ret = {}
-        self.connection = connection
-        self.closed = False
-        self.rowcount = 0
-        self.results = []
 
-    def execute(self, sql, *params):
+
-        if sql.startswith('blabla'):
+def mock_mtime(filename):
-            raise psycopg2.ProgrammingError()
+    if filename not in mtime_ret:
-        elif sql == 'CHECKPOINT' or sql.startswith('SELECT pg_catalog.pg_create_'):
+        mtime_ret[filename] = time.time()
-            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)]
+        mtime_ret[filename] += 1
-
+    return mtime_ret[filename]
-    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
-
-
-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 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):
+class TestPostgresql(BaseTestPostgresql):
-    _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'}
 
     @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'
+        super(TestPostgresql, self).setUp()
-        self.config_dir = self.data_dir
+        self.p.config.write_postgresql_conf()
-        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'}})
         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,185 +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.config.mtime', mock_mtime)
-    @patch('patroni.postgresql.Postgresql.write_pgpass', MagicMock(return_value=dict()))
+    @patch.object(MockCursor, 'fetchone', Mock(side_effect=[('foo=bar',), ('',), ('',), ('a=b',)]))
-    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))
-
     def test_check_recovery_conf(self):
-        self.p.write_recovery_conf({'primary_conninfo': 'foo'})
+        for version in (120000, 100000):
-        self.assertFalse(self.p.check_recovery_conf(None))
+            with patch.object(Postgresql, 'major_version', PropertyMock(return_value=version)):
-        self.p.write_recovery_conf({})
+                self.p.config.write_recovery_conf({'standby_mode': 'on', 'primary_conninfo': 'foo'})
-        self.assertTrue(self.p.check_recovery_conf(None))
+                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, 'major_version', PropertyMock(return_value=120000))
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(return_value=True))
+    @patch.object(Postgresql, 'is_running', MockPostmaster)
-    def test__get_local_timeline_lsn(self):
+    @patch.object(MockPostmaster, 'create_time', Mock(return_value=1234567), create=True)
-        self.p.trigger_check_diverged_lsn()
+    @patch.object(MockCursor, 'fetchone', Mock(return_value=('',)))
-        with patch.object(Postgresql, 'controldata',
+    def test__read_primary_conninfo(self):
-                          Mock(return_value={'Database cluster state': 'shut down in recovery',
+        self.p.config.write_recovery_conf({'standby_mode': 'on'})
-                                             'Minimum recovery ending location': '0/0',
+        self.p.config.write_postgresql_conf()
-                                             "Min recovery ending loc's timeline": '0'})):
+        self.assertTrue(self.p.config.check_recovery_conf(None))
-            self.p.rewind_or_reinitialize_needed_and_possible(self.leader)
+        self.assertTrue(self.p.config.check_recovery_conf(None))
-        with patch.object(Postgresql, 'is_running', Mock(return_value=True)):
+        with patch.object(Postgresql, 'query', Mock(side_effect=Exception)),\
-            with patch.object(MockCursor, 'fetchone', Mock(side_effect=[(False, ), Exception])):
+                patch('patroni.postgresql.config.mtime', mock_mtime):
-                self.p.rewind_or_reinitialize_needed_and_possible(self.leader)
+            self.assertFalse(self.p.config.check_recovery_conf(None))
 
-    @patch.object(Postgresql, 'start', Mock())
+    @patch.object(Postgresql, 'major_version', PropertyMock(return_value=100000))
-    @patch.object(Postgresql, 'can_rewind', PropertyMock(return_value=True))
+    def test__read_primary_conninfo_pre_v12(self):
-    @patch.object(Postgresql, '_get_local_timeline_lsn', Mock(return_value=(2, '40159C1')))
+        self.p.config.write_recovery_conf({'standby_mode': 'on'})
-    @patch.object(Postgresql, 'check_leader_is_not_in_recovery')
+        self.assertTrue(self.p.config.check_recovery_conf(None))
-    def test__check_timeline_and_lsn(self, mock_check_leader_is_not_in_recovery):
+        self.assertTrue(self.p.config.check_recovery_conf(None))
-        mock_check_leader_is_not_in_recovery.return_value = False
-        self.p.trigger_check_diverged_lsn()
-        self.assertFalse(self.p.rewind_or_reinitialize_needed_and_possible(self.leader))
-        self.leader = self.leader.member
-        self.assertFalse(self.p.rewind_or_reinitialize_needed_and_possible(self.leader))
-        mock_check_leader_is_not_in_recovery.return_value = True
-        self.assertFalse(self.p.rewind_or_reinitialize_needed_and_possible(self.leader))
-        self.p.trigger_check_diverged_lsn()
-        with patch('psycopg2.connect', Mock(side_effect=Exception)):
-            self.assertFalse(self.p.rewind_or_reinitialize_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_or_reinitialize_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_or_reinitialize_needed_and_possible(self.leader))
-            self.p.trigger_check_diverged_lsn()
-            self.assertTrue(self.p.rewind_or_reinitialize_needed_and_possible(self.leader))
 
-    @patch.object(MockCursor, 'fetchone', Mock(side_effect=[(True,), Exception]))
+    def test_write_postgresql_and_sanitize_auto_conf(self):
-    def test_check_leader_is_not_in_recovery(self):
+        read_data = 'primary_conninfo = foo\nfoo = bar\n'
-        self.p.check_leader_is_not_in_recovery()
+        with open(os.path.join(self.p.data_dir, 'postgresql.auto.conf'), 'w') as f:
-        self.p.check_leader_is_not_in_recovery()
+            f.write(read_data)
 
-    @patch.object(Postgresql, 'cancellable_subprocess_call', Mock(return_value=0))
+        mock_read_auto = mock_open(read_data=read_data)
-    @patch.object(Postgresql, 'checkpoint', side_effect=['', '1'])
+        mock_read_auto.return_value.__iter__ = lambda o: iter(o.readline, '')
-    @patch.object(Postgresql, 'stop', Mock(return_value=False))
+        with patch.object(builtins, 'open', Mock(side_effect=[mock_open()(), mock_read_auto(), IOError])),\
-    @patch.object(Postgresql, 'start', Mock())
+                patch('os.chmod', Mock()):
-    def test_rewind(self, mock_checkpoint):
+            self.p.config.write_postgresql_conf()
-        self.p.rewind(self.leader)
+
-        with patch.object(Postgresql, 'pg_rewind', Mock(return_value=False)):
+        with patch.object(builtins, 'open', Mock(side_effect=[mock_open()(), IOError])), patch('os.chmod', Mock()):
-            mock_checkpoint.side_effect = ['1', '', '', '']
+            self.p.config.write_postgresql_conf()
-            self.p.rewind(self.leader)
+        self.p.config.write_recovery_conf({'foo': 'bar'})
-            self.p.rewind(self.leader)
+        self.p.config.write_postgresql_conf()
-            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)
 
     @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()
@@ -508,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.slots_handler.sync_replication_slots(cluster)
-        self.p.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)
+            self.p.slots_handler.sync_replication_slots(cluster)
-        with patch.object(Postgresql, 'drop_replication_slot', Mock(return_value=True)),\
+        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))
@@ -601,126 +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('os.path.isfile', Mock(return_value=True))
-    @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()
@@ -745,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._config['create_replica_method'] = ['wale', 'basebackup']
-        self.p.config['wale'] = {'command': 'foo', 'no_master': 1}
+        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': {},
+        config = {'pg_hba': [''], 'pg_ident': [''], 'use_unix_socket': True, 'authentication': {},
-                  'retry_timeout': 10, 'listen': '*', 'parameters': parameters}
+                  'retry_timeout': 10, 'listen': '*', 'krbsrvname': 'postgres', 'parameters': parameters}
         self.p.reload_config(config)
         parameters['b.ar'] = 'bar'
         self.p.reload_config(config)
@@ -784,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):
@@ -871,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())
 
@@ -911,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.config.get_server_parameters(config)
-        self.p.set_synchronous_standby('foo')
+        self.p.config.set_synchronous_standby('foo')
-        self.p.get_server_parameters(config)
+        self.p.config.get_server_parameters(config)
 
     @patch('time.sleep', Mock())
     def test__wait_for_connection_close(self):
@@ -990,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())
@@ -1001,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'})):
+                                             'max_locks_per_xact setting': '100',
-            self.p.cancel()
+                                             'max_wal_senders setting': 10})):
+            self.p.cancellable.cancel()
             self.assertFalse(self.p.start())
             self.assertTrue(self.p.pending_restart)

tests/test_postmaster.py

@@ -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 = {}
@@ -82,18 +94,23 @@ class TestPostmasterProcess(unittest.TestCase):
             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)):

tests/test_rewind.py

@@ -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()

tests/test_wale_restore.py

@@ -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'

tests/test_watchdog.py

@@ -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):

tests/test_zookeeper.py

@@ -17,6 +17,7 @@ class MockKazooClient(Mock):
 
     def __init__(self, *args, **kwargs):
         super(MockKazooClient, self).__init__()
+        self._session_timeout = 30
 
     @property
     def client_id(self):
@@ -24,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):