WIP

WIP: extract logic for WaitForTrigger, Trigger, Reset, Poll into a reusable abstraction
forgotten client/reset.go
2021-04-16 10:10:16 +02:00 · 2021-03-24 00:20:47 +01:00 · 2021-03-23 00:00:03 +01:00 · 2021-03-21 23:47:37 +01:00 · 2021-03-21 21:57:26 +01:00 · 2021-03-21 19:57:33 +01:00
199 changed files with 5403 additions and 10483 deletions
@@ -1,8 +1,5 @@
 version: 2.1
-orbs:
-  # NB: 1.7.2 is not the Go version, but the Orb version
-  # https://circleci.com/developer/orbs/orb/circleci/go#usage-go-modules-cache
-  go: circleci/go@1.7.2
+
 commands:
  setup-home-local-bin:
    steps:
@@ -27,12 +24,18 @@ commands:

  apt-update-and-install-common-deps:
    steps:
-      - run: sudo apt-get update
-      - run: sudo apt-get install -y gawk make
-      # CircleCI doesn't update its cimg/go images.
-      # So, need to update manually to get up-to-date trust chains.
-      # The need for this was required for cimg/go:1.12, but let's future proof this here and now.
-      - run: sudo apt-get install -y git ca-certificates
+      - run: sudo apt update && sudo apt install gawk make
+
+  restore-cache-gomod:
+    steps:
+      - restore_cache:
+          key: go-mod-v4-{{ checksum "go.sum" }}
+  save-cache-gomod:
+    steps:
+      - save_cache:
+          key: go-mod-v4-{{ checksum "go.sum" }}
+          paths:
+            - "/go/pkg/mod"

  install-godep:
    steps:
@@ -47,48 +50,94 @@ commands:
      - invoke-lazy-sh:
          subcommand: docdep

-  docs-publish-sh:
-    parameters:
-      push:
-        type: boolean
+  download-and-install-minio-client:
    steps:
-      - checkout
+      - setup-home-local-bin
+      - restore_cache:
+          key: minio-client-v2
      - run:
+          shell: /bin/bash -eo pipefail
          command: |
-            git config --global user.email "zreplbot@cschwarz.com"
-            git config --global user.name "zrepl-github-io-ci"
+            if which mc; then exit 0; fi
+            sudo curl -sSL https://dl.min.io/client/mc/release/linux-amd64/archive/mc.RELEASE.2020-08-20T00-23-01Z \
+              -o "$HOME/.local/bin/mc"
+            sudo chmod +x "$HOME/.local/bin/mc"
+      - save_cache:
+          key: minio-client-v2
+          paths:
+            - "$HOME/.local/bin/mc"

-      # if we're pushing, we need to add the deploy key
-      # which is stored as "Additional SSH Keys" in the CircleCI project settings.
-      # We can't use the CircleCI-manage deploy key because we're pushing
-      # to a different repo than the one we're building.
-      - when:
-          condition: << parameters.push >>
-          steps:
-            # https://circleci.com/docs/2.0/add-ssh-key/#adding-multiple-keys-with-blank-hostnames
-            - run: ssh-add -D
-            # the default circleci ssh config only additional ssh keys for Host !github.com
-            - run:
-                command: |
-                  cat > ~/.ssh/config \<<EOF
-                  Host *
-                    IdentityFile /home/circleci/.ssh/id_rsa_458e62c517f6c480e40452126ce47421
-                  EOF
-            - add_ssh_keys:
-                fingerprints:
-                  # deploy key for zrepl.github.io
-                  - "45:8e:62:c5:17:f6:c4:80:e4:04:52:12:6c:e4:74:21"
+  upload-minio:
+    parameters:
+      src:
+        type: string
+      dst:
+        type: string
+    steps:
+      - run:
+          shell: /bin/bash -eo pipefail
+          when: always
+          command: |
+            if [ -n "$CIRCLE_PR_NUMBER" ]; then # CIRCLE_PR_NUMBER is guaranteed to be only present in forked PRs (external)
+              echo "Forked PR detected. Sry, can't trust you with credentials to external artifact store, use CircleCI's instead."
+              exit 0
+            fi
+            set -u # from now on

-      # caller must install-docdep
-      - when:
-          condition: << parameters.push >>
-          steps:
-            - run: bash -x docs/publish.sh -c -a -P
-      - when:
-          condition:
-            not: << parameters.push >>
-          steps:
-            - run: bash -x docs/publish.sh -c -a
+            mc config host add --api s3v4 zrepl-minio https://minio.cschwarz.com ${MINIO_ACCESS_KEY} ${MINIO_SECRET_KEY}
+
+            # keep in sync with set-github-minio-status
+            jobprefix=zrepl-ci-artifacts/${CIRCLE_SHA1}-pipeline-<<pipeline.number>>/${CIRCLE_JOB}
+
+            # Upload artifacts
+            mkdir -p ./artifacts
+            mc cp -r <<parameters.src>> "zrepl-minio/$jobprefix/<<parameters.dst>>"
+
+  set-github-minio-status:
+    parameters:
+      context:
+        type: string
+      description:
+        type: string
+      minio-dst:
+        type: string
+    steps:
+      - run:
+          shell: /bin/bash -eo pipefail
+          command: |
+            if [ -n "$CIRCLE_PR_NUMBER" ]; then # CIRCLE_PR_NUMBER is guaranteed to be only present in forked PRs (external)
+              echo "Forked PR detected. Sry, can't trust you with credentials to external artifact store, use CircleCI's instead."
+              exit 0
+            fi
+            set -u # from now on
+
+            # keep in sync with with upload-minio command
+            jobprefix=zrepl-ci-artifacts/${CIRCLE_SHA1}-pipeline-<<pipeline.number>>/${CIRCLE_JOB}
+            # Push Artifact Link to GitHub
+            REPO="zrepl/zrepl"
+            COMMIT="${CIRCLE_SHA1}"
+            JOB_NAME="${CIRCLE_JOB}"
+            CONTEXT="<<parameters.context>>"
+            DESCRIPTION="<<parameters.description>>"
+            TARGETURL=https://minio.cschwarz.com/minio/"$jobprefix"/"<<parameters.minio-dst>>"
+            curl "https://api.github.com/repos/$REPO/statuses/$COMMIT" \
+              -H "Content-Type: application/json" \
+              -H "Authorization: token $GITHUB_COMMIT_STATUS_TOKEN" \
+              -X POST \
+              -d '{"context":"'"$CONTEXT"'", "state": "success", "description":"'"$DESCRIPTION"'", "target_url":"'"$TARGETURL"'"}'
+
+
+  trigger-pipeline:
+    parameters:
+      body_no_shell_subst:
+        type: string
+    steps:
+      - run: |
+          curl -X POST https://circleci.com/api/v2/project/github/zrepl/zrepl/pipeline \
+            -H 'Content-Type: application/json' \
+            -H 'Accept: application/json' \
+            -H "Circle-Token: $ZREPL_BOT_CIRCLE_TOKEN" \
+            --data '<<parameters.body_no_shell_subst>>'

 parameters:
  do_ci:
@@ -101,7 +150,7 @@ parameters:

  release_docker_baseimage_tag:
    type: string
-    default: "1.21"
+    default: "1.16"

 workflows:
  version: 2
@@ -111,19 +160,19 @@ workflows:
    jobs:
      - quickcheck-docs
      - quickcheck-go: &quickcheck-go-smoketest
-          name: quickcheck-go-amd64-linux-1.21
-          goversion: &latest-go-release "1.21"
+          name: quickcheck-go-amd64-linux-1.16
+          goversion: &latest-go-release "1.16"
          goos: linux
          goarch: amd64
      - test-go-on-latest-go-release:
          goversion: *latest-go-release
      - quickcheck-go:
          requires:
-            - quickcheck-go-amd64-linux-1.21 #quickcheck-go-smoketest.name
+            - quickcheck-go-amd64-linux-1.16 #quickcheck-go-smoketest.name
          matrix: &quickcheck-go-matrix
            alias: quickcheck-go-matrix
            parameters:
-              goversion: [*latest-go-release, "1.20"]
+              goversion: [*latest-go-release, "1.12"]
              goos: ["linux", "freebsd"]
              goarch: ["amd64", "arm64"]
            exclude:
@@ -131,14 +180,10 @@ workflows:
              - goversion: *latest-go-release
                goos: linux
                goarch: amd64
-      - platformtest:
-          matrix:
-            parameters:
-              goversion: [*latest-go-release]
-              goos: ["linux"]
-              goarch: ["amd64"]
-          requires:
-            - quickcheck-go-<< matrix.goarch >>-<< matrix.goos >>-<< matrix.goversion >>
+              # not supported by Go 1.12
+              - goversion: "1.12"
+                goos: freebsd
+                goarch: arm64

  release:
    when: << pipeline.parameters.do_release >>
@@ -156,7 +201,20 @@ workflows:
            - release-deb
            - release-rpm

-  publish-zrepl.github.io:
+  periodic:
+    triggers:
+      - schedule:
+          cron: "00 17 * * *"
+          filters:
+            branches:
+              only:
+                - master
+                - stable
+                - problame/circleci-build
+    jobs:
+      - periodic-full-pipeline-run
+
+  zrepl.github.io:
    jobs:
      - publish-zrepl-github-io:
          filters:
@@ -167,15 +225,22 @@ workflows:
 jobs:
  quickcheck-docs:
    docker:
-      - image: cimg/base:2023.09
+      - image: cimg/base:2020.08
    steps:
      - checkout
      - install-docdep
-      # do the current docs build
      - run: make docs
-      # does the publish.sh script still work?
-      - docs-publish-sh:
-          push: false
+
+      - store_artifacts:
+          path: artifacts
+      - download-and-install-minio-client
+      - upload-minio:
+          src: artifacts
+          dst: ""
+      - set-github-minio-status:
+          context: artifacts/${CIRCLE_JOB}
+          description: artifacts of CI job ${CIRCLE_JOB}
+          minio-dst: ""

  quickcheck-go:
    parameters:
@@ -186,7 +251,7 @@ jobs:
      goarch:
        type: string
    docker:
-      - image: cimg/go:<<parameters.goversion>>
+      - image: circleci/golang:<<parameters.goversion>>
    environment:
      GOOS: <<parameters.goos>>
      GOARCH: <<parameters.goarch>>
@@ -194,66 +259,44 @@ jobs:
    steps:
      - checkout

-      - go/load-cache:
-          key: quickcheck-<<parameters.goversion>>
-      - install-godep
+      - restore-cache-gomod
      - run: go mod download
      - run: cd build && go mod download
-      - go/save-cache:
-          key: quickcheck-<<parameters.goversion>>
+      - save-cache-gomod

+      - install-godep
      - run: make formatcheck
      - run: make generate-platform-test-list
      - run: make zrepl-bin test-platform-bin
      - run: make vet
      - run: make lint

+      - download-and-install-minio-client
      - run: rm -f artifacts/generate-platform-test-list
      - store_artifacts:
          path: artifacts
-      - persist_to_workspace:
-          root: .
-          paths: [.]
-
-  platformtest:
-    parameters:
-      goversion:
-        type: string
-      goos:
-        type: string
-      goarch:
-        type: string
-    machine:
-      image: ubuntu-2204:current
-    resource_class: medium
-    environment:
-      GOOS: <<parameters.goos>>
-      GOARCH: <<parameters.goarch>>
-    steps:
-      - attach_workspace:
-          at: .
-      - run: sudo apt-get update
-      - run: sudo apt-get install -y zfsutils-linux
-      - run: sudo zfs version
-      - run: sudo make test-platform GOOS="$GOOS" GOARCH="$GOARCH"
+      - upload-minio:
+          src: artifacts
+          dst: ""
+      - set-github-minio-status:
+          context: artifacts/${CIRCLE_JOB}
+          description: artifacts of CI job ${CIRCLE_JOB}
+          minio-dst: ""

  test-go-on-latest-go-release:
    parameters:
      goversion:
        type: string
    docker:
-      - image: cimg/go:<<parameters.goversion>>
+      - image: circleci/golang:<<parameters.goversion>>
    steps:
      - checkout
-      - go/load-cache:
-          key: make-test-go
+      - restore-cache-gomod
      - run: make test-go
-      - go/save-cache:
-          key: make-test-go
+      # don't save-cache-gomod here, test-go doesn't pull all the dependencies

  release-build:
-    machine:
-      image: ubuntu-2004:202201-02
+    machine: true
    steps:
      - checkout
      - run: make release-docker RELEASE_DOCKER_BASEIMAGE_TAG=<<pipeline.parameters.release_docker_baseimage_tag>>
@@ -261,8 +304,7 @@ jobs:
          root: .
          paths: [.]
  release-deb:
-    machine:
-      image: ubuntu-2004:202201-02
+    machine: true
    steps:
      - attach_workspace:
          at: .
@@ -273,8 +315,7 @@ jobs:
            - "artifacts/*.deb"

  release-rpm:
-    machine:
-      image: ubuntu-2004:202201-02
+    machine: true
    steps:
      - attach_workspace:
          at: .
@@ -290,15 +331,48 @@ jobs:
    steps:
      - attach_workspace:
          at: .
-      - run: make wrapup-and-checksum
      - store_artifacts:
          path: artifacts
+      - download-and-install-minio-client
+      - upload-minio:
+          src: artifacts
+          dst: ""
+      - set-github-minio-status:
+          context: artifacts/release
+          description: CI-generated release artifacts
+          minio-dst: ""
+
+  periodic-full-pipeline-run:
+    docker:
+      - image: cimg/base:2020.08
+    steps:
+      - trigger-pipeline:
+          body_no_shell_subst: '{"branch":"<<pipeline.git.branch>>", "parameters": { "do_ci": true, "do_release": true }}'

  publish-zrepl-github-io:
    docker:
-      - image: cimg/base:2023.09
+      - image: cimg/python:3.7
    steps:
      - checkout
-      - install-docdep
-      - docs-publish-sh:
-          push: true
+      - invoke-lazy-sh:
+          subcommand: docdep
+      - run:
+          command: |
+            git config --global user.email "me@cschwarz.com"
+            git config --global user.name "zrepl-github-io-ci"
+
+      # https://circleci.com/docs/2.0/add-ssh-key/#adding-multiple-keys-with-blank-hostnames
+      - run: ssh-add -D
+      # the default circleci ssh config only additional ssh keys for Host !github.com
+      - run:
+          command: |
+            cat > ~/.ssh/config \<<EOF
+            Host *
+              IdentityFile /home/circleci/.ssh/id_rsa_458e62c517f6c480e40452126ce47421
+            EOF
+      - add_ssh_keys:
+          fingerprints:
+            # deploy key for zrepl.github.io
+            - "45:8e:62:c5:17:f6:c4:80:e4:04:52:12:6c:e4:74:21"
+
+      - run: bash -x docs/publish.sh -c -a
@@ -1,84 +0,0 @@
-import argparse
-from pathlib import Path
-import re
-
-import requests
-
-import time
-
-import os
-import argparse
-from pathlib import Path
-
-
-circle_token = os.environ.get('CIRCLE_TOKEN')
-if not circle_token:
-    raise ValueError('CIRCLE_TOKEN environment variable not set')
-
-parser = argparse.ArgumentParser(description='Download artifacts from CircleCI')
-parser.add_argument('build_num', type=str, help='Build number')
-parser.add_argument('dst', type=Path, help='Destination directory')
-parser.add_argument('--prefix', type=str, default='', help='Filter for prefix')
-parser.add_argument('--match', type=str, default='.*', help='Only include paths matching the given regex')
-
-args = parser.parse_args()
-
-res = requests.get(
-    f"https://circleci.com/api/v1.1/project/github/zrepl/zrepl/{args.build_num}/artifacts",
-    headers={
-        "Circle-Token": circle_token,
-    },
-)
-res.raise_for_status()
-
-# https://circleci.com/docs/api/v1/index.html#artifacts-of-a-job
-# [ {
-#   "path" : "raw-test-output/go-test-report.xml",
-#   "pretty_path" : "raw-test-output/go-test-report.xml",
-#   "node_index" : 0,
-#   "url" : "https://24-88881093-gh.circle-artifacts.com/0/raw-test-output/go-test-report.xml"
-# }, {
-#   "path" : "raw-test-output/go-test.out",
-#   "pretty_path" : "raw-test-output/go-test.out",
-#   "node_index" : 0,
-#   "url" : "https://24-88881093-gh.circle-artifacts.com/0/raw-test-output/go-test.out"
-# } ]
-res = res.json()
-
-for artifact in res:
-    if not artifact["pretty_path"].startswith(args.prefix):
-        continue
-    if not re.match(args.match, artifact["pretty_path"]):
-        continue
-    stripped = artifact["pretty_path"][len(args.prefix):]
-    print(f"Downloading {artifact['pretty_path']} to {args.dst / stripped}")
-    artifact_rel = Path(stripped)
-    artifact_dst = args.dst / artifact_rel
-    artifact_dst.parent.mkdir(parents=True, exist_ok=True)
-
-    res = requests.get(
-        artifact["url"],
-        headers={
-            "Circle-Token": circle_token,
-        },
-        stream=True,
-    )
-    res.raise_for_status()
-
-    total_size = int(res.headers.get("Content-Length", 0))
-    block_size = 128 * 1024
-    with open(artifact_dst, "wb") as f:
-        progress = 0
-        start_time = time.time()
-        for chunk in res.iter_content(chunk_size=block_size):
-            f.write(chunk)
-            progress += len(chunk)
-            percent = progress / total_size * 100
-            elapsed_time = time.time() - start_time
-            if elapsed_time >= 5:
-                print(f"Downloaded {progress}/{total_size} bytes ({percent:.2f}%)", end="\r")
-                start_time = time.time()
-        print(f"Downloaded {progress}/{total_size} bytes ({percent:.2f}%)")
-    print("Download complete!")
-
-print("All files downloaded")
@@ -7,10 +7,4 @@ issues:
    - path: _test\.go
      linters:
        - errcheck
-    # Disable staticcheck 'Empty body in an if or else branch' as it's useful
-    # to put a comment into an empty else-clause that explains why whatever
-    # is done in the if-caluse is not necessary if the condition is false.
-    - linters:
-        - staticcheck
-      text: "SA9003:"

@@ -1,5 +1,5 @@
 .PHONY: generate build test vet cover release docs docs-clean clean format lint platformtest
-.PHONY: release release-noarch
+.PHONY: release bins-all release-noarch
 .DEFAULT_GOAL := zrepl-bin

 ARTIFACTDIR := artifacts
@@ -14,15 +14,13 @@ ifndef _ZREPL_VERSION
    endif
 endif

-ZREPL_PACKAGE_RELEASE := 1
-
 GO := go
 GOOS ?= $(shell bash -c 'source <($(GO) env) && echo "$$GOOS"')
 GOARCH ?= $(shell bash -c 'source <($(GO) env) && echo "$$GOARCH"')
 GOARM ?= $(shell bash -c 'source <($(GO) env) && echo "$$GOARM"')
 GOHOSTOS ?= $(shell bash -c 'source <($(GO) env) && echo "$$GOHOSTOS"')
 GOHOSTARCH ?= $(shell bash -c 'source <($(GO) env) && echo "$$GOHOSTARCH"')
-GO_ENV_VARS := GO111MODULE=on CGO_ENABLED=0
+GO_ENV_VARS := GO111MODULE=on
 GO_LDFLAGS := "-X github.com/zrepl/zrepl/version.zreplVersion=$(_ZREPL_VERSION)"
 GO_MOD_READONLY := -mod=readonly
 GO_EXTRA_BUILDFLAGS :=
@@ -30,7 +28,7 @@ GO_BUILDFLAGS := $(GO_MOD_READONLY) $(GO_EXTRA_BUILDFLAGS)
 GO_BUILD := $(GO_ENV_VARS) $(GO) build $(GO_BUILDFLAGS) -ldflags $(GO_LDFLAGS)
 GOLANGCI_LINT := golangci-lint
 GOCOVMERGE := gocovmerge
-RELEASE_DOCKER_BASEIMAGE_TAG ?= 1.21
+RELEASE_DOCKER_BASEIMAGE_TAG ?= 1.16
 RELEASE_DOCKER_BASEIMAGE ?= golang:$(RELEASE_DOCKER_BASEIMAGE_TAG)

 ifneq ($(GOARM),)
@@ -52,20 +50,21 @@ printvars:
 release: clean
 	# no cross-platform support for target test
 	$(MAKE) test-go
-	$(MAKE) _run_make_foreach_target_tuple RUN_MAKE_FOREACH_TARGET_TUPLE_ARG="vet"
-	$(MAKE) _run_make_foreach_target_tuple RUN_MAKE_FOREACH_TARGET_TUPLE_ARG="lint"
-	$(MAKE) _run_make_foreach_target_tuple RUN_MAKE_FOREACH_TARGET_TUPLE_ARG="zrepl-bin"
-	$(MAKE) _run_make_foreach_target_tuple RUN_MAKE_FOREACH_TARGET_TUPLE_ARG="test-platform-bin"
+	$(MAKE) bins-all
 	$(MAKE) noarch
+	$(MAKE) wrapup-and-checksum
+	$(MAKE) check-git-clean
+ifeq (SIGN, 1)
+	$(make) sign
+endif
+	@echo "ZREPL RELEASE ARTIFACTS AVAILABLE IN artifacts/release"

 release-docker: $(ARTIFACTDIR)
 	sed 's/FROM.*!SUBSTITUTED_BY_MAKEFILE/FROM $(RELEASE_DOCKER_BASEIMAGE)/' build.Dockerfile > artifacts/release-docker.Dockerfile
 	docker build -t zrepl_release --pull -f artifacts/release-docker.Dockerfile .
 	docker run --rm -i -v $(CURDIR):/src -u $$(id -u):$$(id -g) \
 		zrepl_release \
-		make release \
-			GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
-			ZREPL_VERSION=$(ZREPL_VERSION) ZREPL_PACKAGE_RELEASE=$(ZREPL_PACKAGE_RELEASE)
+		make release GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM)

 debs-docker:
 	$(MAKE) _debs_or_rpms_docker _DEB_OR_RPM=deb
@@ -82,14 +81,9 @@ rpm: $(ARTIFACTDIR) # artifacts/_zrepl.zsh_completion artifacts/bash_completion
 	$(eval _ZREPL_RPM_TOPDIR_ABS := $(CURDIR)/$(ARTIFACTDIR)/rpmbuild)
 	rm -rf "$(_ZREPL_RPM_TOPDIR_ABS)"
 	mkdir "$(_ZREPL_RPM_TOPDIR_ABS)"
-	for d in BUILD BUILDROOT RPMS SOURCES SPECS SRPMS; do \
-		mkdir -p "$(_ZREPL_RPM_TOPDIR_ABS)/$$d"; \
-	done
-	sed \
-		-e "s/^Version:.*/Version:          $(_ZREPL_RPM_VERSION)/g" \
-		-e "s/^Release:.*/Release:          $(ZREPL_PACKAGE_RELEASE)/g" \
-	    packaging/rpm/zrepl.spec \
-		>  $(_ZREPL_RPM_TOPDIR_ABS)/SPECS/zrepl.spec
+	mkdir -p "$(_ZREPL_RPM_TOPDIR_ABS)"/{SPECS,RPMS,BUILD,BUILDROOT}
+	sed "s/^Version:.*/Version:          $(_ZREPL_RPM_VERSION)/g" \
+	    packaging/rpm/zrepl.spec >  $(_ZREPL_RPM_TOPDIR_ABS)/SPECS/zrepl.spec

 	# see /usr/lib/rpm/platform
 ifeq ($(GOARCH),amd64)
@@ -116,16 +110,13 @@ rpm-docker:
 	docker build -t zrepl_rpm_pkg --pull -f packaging/rpm/Dockerfile .
 	docker run --rm -i -v $(CURDIR):/build/src -u $$(id -u):$$(id -g) \
 		zrepl_rpm_pkg \
-		make rpm \
-			GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
-			ZREPL_VERSION=$(ZREPL_VERSION) ZREPL_PACKAGE_RELEASE=$(ZREPL_PACKAGE_RELEASE)
-
+		make rpm GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM)

 deb: $(ARTIFACTDIR) # artifacts/_zrepl.zsh_completion artifacts/bash_completion docs zrepl-bin

 	cp packaging/deb/debian/changelog.template packaging/deb/debian/changelog
 	sed -i 's/DATE_DASH_R_OUTPUT/$(shell date -R)/' packaging/deb/debian/changelog
-	VERSION="$(subst -,.,$(_ZREPL_VERSION))-$(ZREPL_PACKAGE_RELEASE)"; \
+	VERSION="$(subst -,.,$(_ZREPL_VERSION))"; \
 		export VERSION="$${VERSION#v}"; \
 		sed -i 's/VERSION/'"$$VERSION"'/' packaging/deb/debian/changelog

@@ -143,19 +134,11 @@ endif

 deb-docker:
 	docker build -t zrepl_debian_pkg --pull -f packaging/deb/Dockerfile .
-	# Use a small open file limit to make fakeroot work. If we don't
-	# specify it, docker daemon will use its file limit. I don't know
-	# what changed (Docker, its systemd service, its Go version). But I
-	# observed fakeroot iterating close(i) up to i > 1000000, which costs
-	# a good amount of CPU time and makes the build slow.
 	docker run --rm -i -v $(CURDIR):/build/src -u $$(id -u):$$(id -g) \
-		--ulimit nofile=1024:1024 \
 		zrepl_debian_pkg \
-		make deb \
-			GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
-			ZREPL_VERSION=$(ZREPL_VERSION) ZREPL_PACKAGE_RELEASE=$(ZREPL_PACKAGE_RELEASE)
+		make deb GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM)

-# expects `release`, `deb` & `rpm` targets to have run before
+# expects `release` target to have run before
 NOARCH_TARBALL := $(ARTIFACTDIR)/zrepl-noarch.tar
 wrapup-and-checksum:
 	rm -f $(NOARCH_TARBALL)
@@ -172,7 +155,7 @@ wrapup-and-checksum:
 		config/samples
 	rm -rf "$(ARTIFACTDIR)/release"
 	mkdir -p "$(ARTIFACTDIR)/release"
-	cp -l $(ARTIFACTDIR)/zrepl* \
+	cp -l $(ARTIFACTDIR)/zrepl-* \
 		$(ARTIFACTDIR)/platformtest-* \
 		"$(ARTIFACTDIR)/release"
 	cd "$(ARTIFACTDIR)/release" && sha512sum $$(ls | sort) > sha512sum.txt
@@ -190,44 +173,35 @@ check-git-clean:
 		fi; \
 	fi;

-tag-release:
-	test -n "$(ZREPL_TAG_VERSION)" || exit 1
-	git tag -u '328A6627FA98061D!' -m "$(ZREPL_TAG_VERSION)" "$(ZREPL_TAG_VERSION)"
-
 sign:
-	gpg -u '328A6627FA98061D!' \
+	gpg -u "89BC 5D89 C845 568B F578  B306 CDBD 8EC8 E27C A5FC" \
 		--armor \
 		--detach-sign $(ARTIFACTDIR)/release/sha512sum.txt

 clean: docs-clean
 	rm -rf "$(ARTIFACTDIR)"

-download-circleci-release:
-	rm -rf "$(ARTIFACTDIR)"
-	mkdir -p "$(ARTIFACTDIR)/release"
-	python3 .circleci/download_artifacts.py --prefix 'artifacts/release/' "$(BUILD_NUM)" "$(ARTIFACTDIR)/release"
+##################### BINARIES #####################
+.PHONY: bins-all lint test-go test-platform cover-merge cover-html vet zrepl-bin test-platform-bin generate-platform-test-list

-##################### MULTI-ARCH HELPERS #####################
-
-_run_make_foreach_target_tuple:
-	if [ "$(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG)" = "" ]; then \
-		echo "RUN_MAKE_FOREACH_TARGET_TUPLE_ARG must be set"; \
-		exit 1; \
-	fi
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=386
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=arm	  GOARM=7
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=arm64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=arm64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=arm     GOARM=7
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=386
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=darwin    GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=solaris   GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=illumos   GOARCH=amd64
-
-##################### REGULAR TARGETS #####################
-.PHONY: lint test-go test-platform cover-merge cover-html vet zrepl-bin test-platform-bin generate-platform-test-list
+BINS_ALL_TARGETS := zrepl-bin test-platform-bin vet lint
+GO_SUPPORTS_ILLUMOS := $(shell $(GO) version | gawk -F '.' '/^go version /{split($$0, comps, " "); split(comps[3], v, "."); if (v[1] == "go1" && v[2] >= 13) { print "illumos"; } else { print "noillumos"; }}')
+bins-all:
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=freebsd   GOARCH=amd64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=freebsd   GOARCH=386
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=amd64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=arm64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=arm     GOARM=7
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=386
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=darwin    GOARCH=amd64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=solaris   GOARCH=amd64
+ifeq ($(GO_SUPPORTS_ILLUMOS), illumos)
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=illumos   GOARCH=amd64
+else ifeq ($(GO_SUPPORTS_ILLUMOS), noillumos)
+	@echo "SKIPPING ILLUMOS BUILD BECAUSE GO VERSION DOESN'T SUPPORT IT"
+else
+	@echo "CANNOT DETERMINE WHETHER GO VERSION SUPPORTS GOOS=illumos"; exit 1
+endif

 lint:
 	$(GO_ENV_VARS) $(GOLANGCI_LINT) run ./...
@@ -353,12 +327,12 @@ $(ARTIFACTDIR)/go_env.txt:

 docs: $(ARTIFACTDIR)/docs
 	# https://www.sphinx-doc.org/en/master/man/sphinx-build.html
-	$(MAKE) -C docs \
+	make -C docs \
 		html \
 		BUILDDIR=../artifacts/docs \
 		SPHINXOPTS="-W --keep-going -n"

 docs-clean:
-	$(MAKE) -C docs \
+	make -C docs \
 		clean \
 		BUILDDIR=../artifacts/docs
@@ -1,12 +1,11 @@
 [![GitHub license](https://img.shields.io/github/license/zrepl/zrepl.svg)](https://github.com/zrepl/zrepl/blob/master/LICENSE)
-[![Language: Go](https://img.shields.io/badge/lang-Go-6ad7e5.svg)](https://golang.org/)
+[![Language: Go](https://img.shields.io/badge/language-Go-6ad7e5.svg)](https://golang.org/)
 [![User Docs](https://img.shields.io/badge/docs-web-blue.svg)](https://zrepl.github.io)
-[![Support me on Patreon](https://img.shields.io/badge/dynamic/json?color=yellow&label=Patreon&query=data.attributes.patron_count&url=https%3A%2F%2Fwww.patreon.com%2Fapi%2Fcampaigns%2F3095079)](https://patreon.com/zrepl)
+[![Support me on Patreon](https://img.shields.io/badge/dynamic/json?color=yellow&label=Patreon&query=data.attributes.patron_count&suffix=%20patrons&url=https%3A%2F%2Fwww.patreon.com%2Fapi%2Fcampaigns%2F3095079)](https://patreon.com/zrepl)
 [![Donate via GitHub Sponsors](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=yellow)](https://github.com/sponsors/problame)
 [![Donate via Liberapay](https://img.shields.io/liberapay/patrons/zrepl.svg?logo=liberapay)](https://liberapay.com/zrepl/donate)
 [![Donate via PayPal](https://img.shields.io/badge/donate-paypal-yellow.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=R5QSXJVYHGX96)
 [![Twitter](https://img.shields.io/twitter/url/https/github.com/zrepl/zrepl.svg?style=social)](https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fzrepl%2Fzrepl)
-[![Chat](https://img.shields.io/badge/chat-matrix-blue.svg)](https://matrix.to/#/#zrepl:matrix.org)

 # zrepl
 zrepl is a one-stop ZFS backup & replication solution.
@@ -96,7 +95,7 @@ Downstream packagers can read the changelog to determine whether they want to pu

 ### Additional Notes to Distro Package Maintainers

-* Run the platform tests (Docs -> Usage -> Platform Tests) **on a test system** to validate that zrepl's abstractions on top of ZFS work with the system ZFS.
+* Use `sudo make test-platform-bin && sudo make test-platform` **on a test system** to validate that zrepl's abstractions on top of ZFS work with the system ZFS.
 * Ship a default config that adheres to your distro's `hier` and logging system.
 * Ship a service manager file and _please_ try to upstream it to this repository.
  * `dist/systemd` contains a Systemd unit template.
@@ -2,18 +2,12 @@ FROM !SUBSTITUTED_BY_MAKEFILE

 RUN apt-get update && apt-get install -y \
    python3-pip \
-    python3-venv \
    unzip \
    gawk

 ADD build.installprotoc.bash ./
 RUN bash build.installprotoc.bash

-# setup venv
-ENV VIRTUAL_ENV=/opt/venv
-RUN python3 -m venv $VIRTUAL_ENV
-ENV PATH="$VIRTUAL_ENV/bin:$PATH"
-
 ADD lazy.sh /tmp/lazy.sh
 ADD docs/requirements.txt /tmp/requirements.txt
 ENV ZREPL_LAZY_DOCS_REQPATH=/tmp/requirements.txt
@@ -4,37 +4,13 @@ go 1.12

 require (
 	github.com/alvaroloes/enumer v1.1.1
-	github.com/breml/bidichk v0.2.6 // indirect
-	github.com/breml/errchkjson v0.3.5 // indirect
-	github.com/chavacava/garif v0.1.0 // indirect
-	github.com/daixiang0/gci v0.11.1 // indirect
-	github.com/golangci/golangci-lint v1.54.2
-	github.com/golangci/revgrep v0.5.0 // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/jgautheron/goconst v1.6.0 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
-	github.com/mgechev/revive v1.3.3 // indirect
-	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
-	github.com/polyfloyd/go-errorlint v1.4.5 // indirect
-	github.com/prometheus/client_golang v1.16.0 // indirect
-	github.com/prometheus/common v0.44.0 // indirect
-	github.com/prometheus/procfs v0.11.1 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
-	github.com/ryanrolds/sqlclosecheck v0.5.1 // indirect
-	github.com/spf13/viper v1.16.0 // indirect
-	github.com/stretchr/objx v0.5.1 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
-	github.com/tetafro/godot v1.4.15 // indirect
+	github.com/golangci/golangci-lint v1.35.2
+	github.com/golangci/misspell v0.3.4 // indirect
+	github.com/golangci/revgrep v0.0.0-20180812185044-276a5c0a1039 // indirect
+	github.com/spf13/afero v1.2.2 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/wadey/gocovmerge v0.0.0-20160331181800-b5bfa59ec0ad
-	github.com/xen0n/gosmopolitan v1.2.2 // indirect
-	gitlab.com/bosi/decorder v0.4.1 // indirect
-	go.uber.org/multierr v1.11.0 // indirect
-	go.uber.org/zap v1.25.0 // indirect
-	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
-	golang.org/x/exp/typeparams v0.0.0-20230905200255-921286631fa9 // indirect
-	golang.org/x/tools v0.13.0
-	google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0
-	google.golang.org/protobuf v1.31.0
-	mvdan.cc/unparam v0.0.0-20230815095028-f7c6fb1088f0 // indirect
+	golang.org/x/tools v0.0.0-20210105210202-9ed45478a130
+	google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0 // indirect
+	google.golang.org/protobuf v1.25.0
 )
@@ -1,4 +1,3 @@
-//go:build tools
 // +build tools

 package main
@@ -19,9 +19,8 @@ import (
 )

 var configcheckArgs struct {
-	format        string
-	what          string
-	skipCertCheck bool
+	format string
+	what   string
 }

 var ConfigcheckCmd = &cli.Subcommand{
@@ -30,7 +29,6 @@ var ConfigcheckCmd = &cli.Subcommand{
 	SetupFlags: func(f *pflag.FlagSet) {
 		f.StringVar(&configcheckArgs.format, "format", "", "dump parsed config object [pretty|yaml|json]")
 		f.StringVar(&configcheckArgs.what, "what", "all", "what to print [all|config|jobs|logging]")
-		f.BoolVar(&configcheckArgs.skipCertCheck, "skip-cert-check", false, "skip checking cert files")
 	},
 	Run: func(ctx context.Context, subcommand *cli.Subcommand, args []string) error {
 		formatMap := map[string]func(interface{}){
@@ -58,16 +56,8 @@ var ConfigcheckCmd = &cli.Subcommand{
 		}

 		var hadErr bool
-
-		parseFlags := config.ParseFlagsNone
-
-		if configcheckArgs.skipCertCheck {
-			parseFlags |= config.ParseFlagsNoCertCheck
-		}
-
 		// further: try to build jobs
-		confJobs, err := job.JobsFromConfig(subcommand.Config(), parseFlags)
-
+		confJobs, err := job.JobsFromConfig(subcommand.Config())
 		if err != nil {
 			err := errors.Wrap(err, "cannot build jobs from config")
 			if configcheckArgs.what == "jobs" {
@@ -129,7 +129,7 @@ func doMigrateReplicationCursor(ctx context.Context, sc *cli.Subcommand, args []
 	}

 	cfg := sc.Config()
-	jobs, err := job.JobsFromConfig(cfg, config.ParseFlagsNone)
+	jobs, err := job.JobsFromConfig(cfg)
 	if err != nil {
 		fmt.Printf("cannot parse config:\n%s\n\n", err)
 		fmt.Printf("NOTE: this migration was released together with a change in job name requirements.\n")
@@ -0,0 +1,88 @@
+package client
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"github.com/kr/pretty"
+	"github.com/pkg/errors"
+	"github.com/spf13/pflag"
+
+	"github.com/zrepl/zrepl/cli"
+	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/daemon"
+	"github.com/zrepl/zrepl/daemon/job"
+)
+
+var resetCmdArgs struct {
+	verbose  bool
+	interval time.Duration
+	token    string
+}
+
+var ResetCmd = &cli.Subcommand{
+	Use:   "reset [-t TOKEN | JOB INVOCATION [replication|snapshotting|prune_sender|prune_receiver]]",
+	Short: "",
+	Run: func(ctx context.Context, subcommand *cli.Subcommand, args []string) error {
+		return runResetCmd(subcommand.Config(), args)
+	},
+	SetupFlags: func(f *pflag.FlagSet) {
+		f.BoolVarP(&resetCmdArgs.verbose, "verbose", "v", false, "verbose output")
+		f.DurationVarP(&resetCmdArgs.interval, "poll-interval", "i", 100*time.Millisecond, "poll interval")
+		f.StringVarP(&resetCmdArgs.token, "token", "t", "", "token produced by 'signal' subcommand")
+	},
+}
+
+func runResetCmd(config *config.Config, args []string) error {
+
+	httpc, err := controlHttpClient(config.Global.Control.SockPath)
+	if err != nil {
+		return err
+	}
+
+	var req daemon.ControlJobEndpointResetActiveRequest
+	if resetCmdArgs.token != "" {
+		var token TriggerToken
+		err := token.Decode(resetCmdArgs.token)
+		if err != nil {
+			return errors.Wrap(err, "cannot decode token")
+		}
+		req = token.ToReset()
+	} else {
+		jobName := args[0]
+
+		invocationId, err := strconv.ParseUint(args[1], 10, 64)
+		if err != nil {
+			return errors.Wrap(err, "parse invocation id")
+		}
+
+		// what := args[2]
+
+		// updated by subsequent requests
+		req = daemon.ControlJobEndpointResetActiveRequest{
+			Job: jobName,
+			ActiveSideResetRequest: job.ActiveSideResetRequest{
+				InvocationId: invocationId,
+			},
+		}
+	}
+
+	var res job.ActiveSideResetResponse
+	if resetCmdArgs.verbose {
+		pretty.Println("making request", req)
+	}
+	err = jsonRequestResponse(httpc, daemon.ControlJobEndpointResetActive,
+		req,
+		&res,
+	)
+	if err != nil {
+		return err
+	}
+
+	if resetCmdArgs.verbose {
+		pretty.Println("got response", res)
+	}
+
+	return nil
+}
@@ -1,42 +0,0 @@
-package client
-
-import (
-	"context"
-
-	"github.com/pkg/errors"
-
-	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon"
-)
-
-var SignalCmd = &cli.Subcommand{
-	Use:   "signal [wakeup|reset] JOB",
-	Short: "wake up a job from wait state or abort its current invocation",
-	Run: func(ctx context.Context, subcommand *cli.Subcommand, args []string) error {
-		return runSignalCmd(subcommand.Config(), args)
-	},
-}
-
-func runSignalCmd(config *config.Config, args []string) error {
-	if len(args) != 2 {
-		return errors.Errorf("Expected 2 arguments: [wakeup|reset] JOB")
-	}
-
-	httpc, err := controlHttpClient(config.Global.Control.SockPath)
-	if err != nil {
-		return err
-	}
-
-	err = jsonRequestResponse(httpc, daemon.ControlJobEndpointSignal,
-		struct {
-			Name string
-			Op   string
-		}{
-			Name: args[1],
-			Op:   args[0],
-		},
-		struct{}{},
-	)
-	return err
-}
@@ -11,14 +11,15 @@ import (
 	"github.com/pkg/errors"

 	"github.com/zrepl/zrepl/daemon"
+	"github.com/zrepl/zrepl/daemon/job"
 )

 type Client struct {
-	h *http.Client
+	h http.Client
 }

 func New(network, addr string) (*Client, error) {
-	httpc, err := makeControlHttpClient(func(_ context.Context) (net.Conn, error) { return net.Dial(network, addr) })
+	httpc, err := controlHttpClient(func(_ context.Context) (net.Conn, error) { return net.Dial(network, addr) })
 	if err != nil {
 		return nil, err
 	}
@@ -42,29 +43,35 @@ func (c *Client) StatusRaw() ([]byte, error) {
 	return r, nil
 }

-func (c *Client) signal(job, sig string) error {
-	return jsonRequestResponse(c.h, daemon.ControlJobEndpointSignal,
+func (c *Client) signal(jobName, sig string) error {
+	return jsonRequestResponse(c.h, daemon.ControlJobEndpointTriggerActive,
 		struct {
-			Name string
-			Op   string
+			Job string
+			job.ActiveSideTriggerRequest
 		}{
-			Name: job,
-			Op:   sig,
+			Job: jobName,
+			ActiveSideTriggerRequest: job.ActiveSideTriggerRequest{
+				What: sig,
+			},
 		},
 		struct{}{},
 	)
 }

-func (c *Client) SignalWakeup(job string) error {
-	return c.signal(job, "wakeup")
+func (c *Client) SignalReplication(job string) error {
+	return c.signal(job, "replication")
+}
+
+func (c *Client) SignalSnapshot(job string) error {
+	return c.signal(job, "snapshot")
 }

 func (c *Client) SignalReset(job string) error {
 	return c.signal(job, "reset")
 }

-func makeControlHttpClient(dialfunc func(context.Context) (net.Conn, error)) (client *http.Client, err error) {
-	return &http.Client{
+func controlHttpClient(dialfunc func(context.Context) (net.Conn, error)) (client http.Client, err error) {
+	return http.Client{
 		Transport: &http.Transport{
 			DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
 				return dialfunc(ctx)
@@ -73,24 +80,14 @@ func makeControlHttpClient(dialfunc func(context.Context) (net.Conn, error)) (cl
 	}, nil
 }

-func jsonRequestResponse(c *http.Client, endpoint string, req interface{}, res interface{}) error {
+func jsonRequestResponse(c http.Client, endpoint string, req interface{}, res interface{}) error {
 	var buf bytes.Buffer
 	encodeErr := json.NewEncoder(&buf).Encode(req)
 	if encodeErr != nil {
 		return encodeErr
 	}

-	hreq, err := http.NewRequest("POST", "http://unix"+endpoint, &buf)
-	if err != nil {
-		return err
-	}
-	hreq.Header.Set("Content-Type", "application/json")
-	// Prevent EOF errors when client request frequency and server keepalive close are at the same time.
-	// Found this by watching http.Server.ConnState changes, then found
-	// https://stackoverflow.com/questions/17714494/golang-http-request-results-in-eof-errors-when-making-multiple-requests-successi
-	// Note: The issue seems even more prounounced with local TCP sockets than unix domain sockets. So, I used that for debugging.
-	hreq.Close = true
-	resp, err := c.Do(hreq)
+	resp, err := c.Post("http://unix"+endpoint, "application/json", &buf)
 	if err != nil {
 		return err
 	}
@@ -19,7 +19,8 @@ import (
 type Client interface {
 	Status() (daemon.Status, error)
 	StatusRaw() ([]byte, error)
-	SignalWakeup(job string) error
+	SignalReplication(job string) error
+	SignalSnapshot(job string) error
 	SignalReset(job string) error
 }

@@ -70,16 +71,12 @@ func runStatusV2Command(ctx context.Context, config *config.Config, args []strin

 	mode := statusv2Flags.Mode.Value().(statusv2Mode)

-	if !isatty.IsTerminal(os.Stdout.Fd()) && mode != StatusV2ModeDump && mode != StatusV2ModeRaw {
-		dumpmode, err := statusv2Flags.Mode.InputForChoice(StatusV2ModeDump)
+	if !isatty.IsTerminal(os.Stdout.Fd()) && mode != StatusV2ModeDump {
+		usemode, err := statusv2Flags.Mode.InputForChoice(StatusV2ModeDump)
 		if err != nil {
 			panic(err)
 		}
-		rawmode, err := statusv2Flags.Mode.InputForChoice(StatusV2ModeRaw)
-		if err != nil {
-			panic(err)
-		}
-		return errors.Errorf("error: stdout is not a tty, please use --mode %s or --mode %s", dumpmode, rawmode)
+		return errors.Errorf("error: stdout is not a tty, please use --mode %s", usemode)
 	}

 	switch mode {
@@ -129,7 +129,7 @@ func interactive(c Client, flag statusFlags) error {
 		FSFilter:                func(_ string) bool { return true },
 		DetailViewWidth:         100,
 		DetailViewWrap:          false,
-		ShortKeybindingOverview: "[::b]Q[::-] quit  [::b]<TAB>[::-] switch panes [::b]W[::-] wrap lines  [::b]Shift+M[::-] toggle navbar  [::b]Shift+S[::-] signal job [::b]</>[::-] filter filesystems",
+		ShortKeybindingOverview: "[::b]Q[::-] quit  [::b]<TAB>[::-] switch panes  [::b]Shift+M[::-] toggle navbar  [::b]Shift+S[::-] signal job [::b]</>[::-] filter filesystems",
 	}
 	paramsMtx := &sync.Mutex{}
 	var redraw func()
@@ -281,8 +281,8 @@ func interactive(c Client, flag statusFlags) error {
 			if !ok {
 				return nil
 			}
-			signals := []string{"wakeup", "reset"}
-			clientFuncs := []func(job string) error{c.SignalWakeup, c.SignalReset}
+			signals := []string{"replication", "snapshot", "reset"}
+			clientFuncs := []func(job string) error{c.SignalReplication, c.SignalSnapshot, c.SignalReset}
 			sigMod := tview.NewModal()
 			sigMod.SetBackgroundColor(tcell.ColorDefault)
 			sigMod.SetBorder(true)
@@ -2,22 +2,14 @@ package viewmodel

 import (
 	"fmt"
-	"math"
 )

-func ByteCountBinaryUint(b uint64) string {
-	if b > math.MaxInt64 {
-		panic(b)
-	}
-	return ByteCountBinary(int64(b))
-}
-
 func ByteCountBinary(b int64) string {
 	const unit = 1024
 	if b < unit {
 		return fmt.Sprintf("%d B", b)
 	}
-	div, exp := unit, 0
+	div, exp := int64(unit), 0
 	for n := b / unit; n >= unit; n /= unit {
 		div *= unit
 		exp++
@@ -4,16 +4,17 @@ import "time"

 type byteProgressMeasurement struct {
 	time time.Time
-	val  uint64
+	val  int64
 }

 type bytesProgressHistory struct {
 	last        *byteProgressMeasurement // pointer as poor man's optional
 	changeCount int
 	lastChange  time.Time
+	bpsAvg      float64
 }

-func (p *bytesProgressHistory) Update(currentVal uint64) (bytesPerSecondAvg int64, changeCount int) {
+func (p *bytesProgressHistory) Update(currentVal int64) (bytesPerSecondAvg int64, changeCount int) {

 	if p.last == nil {
 		p.last = &byteProgressMeasurement{
@@ -33,17 +34,15 @@ func (p *bytesProgressHistory) Update(currentVal uint64) (bytesPerSecondAvg int6
 		return 0, 0
 	}

-	var deltaV int64
-	if currentVal >= p.last.val {
-		deltaV = int64(currentVal - p.last.val)
-	} else {
-		deltaV = -int64(p.last.val - currentVal)
-	}
+	deltaV := currentVal - p.last.val
 	deltaT := time.Since(p.last.time)
 	rate := float64(deltaV) / deltaT.Seconds()

+	factor := 0.3
+	p.bpsAvg = (1-factor)*p.bpsAvg + factor*rate
+
 	p.last.time = time.Now()
 	p.last.val = currentVal

-	return int64(rate), p.changeCount
+	return int64(p.bpsAvg), p.changeCount
 }
@@ -216,7 +216,7 @@ func drawJob(t *stringbuilder.B, name string, v *job.Status, history *bytesProgr
 	}
 }

-func printFilesystemStatus(t *stringbuilder.B, rep *report.FilesystemReport, maxFS int) {
+func printFilesystemStatus(t *stringbuilder.B, rep *report.FilesystemReport, active bool, maxFS int) {

 	expected, replicated, containsInvalidSizeEstimates := rep.BytesSum()
 	sizeEstimationImpreciseNotice := ""
@@ -227,28 +227,15 @@ func printFilesystemStatus(t *stringbuilder.B, rep *report.FilesystemReport, max
 		sizeEstimationImpreciseNotice = " (step lacks size estimation)"
 	}

-	userVisisbleCurrentStep, userVisibleTotalSteps := rep.CurrentStep, len(rep.Steps)
-	// `.CurrentStep` is == len(rep.Steps) if all steps are done.
-	// Until then, it's an index into .Steps that starts at 0.
-	// For the user, we want it to start at 1.
-	if rep.CurrentStep >= len(rep.Steps) {
-		// rep.CurrentStep is what we want to show.
-		// We check for >= and not == for robustness.
-	} else {
-		// We're not done yet, so, make step count start at 1
-		// (The `.State` is included in the output, indicating we're not done yet)
-		userVisisbleCurrentStep = rep.CurrentStep + 1
-	}
 	status := fmt.Sprintf("%s (step %d/%d, %s/%s)%s",
 		strings.ToUpper(string(rep.State)),
-		userVisisbleCurrentStep, userVisibleTotalSteps,
-		ByteCountBinaryUint(replicated), ByteCountBinaryUint(expected),
+		rep.CurrentStep, len(rep.Steps),
+		ByteCountBinary(replicated), ByteCountBinary(expected),
 		sizeEstimationImpreciseNotice,
 	)

 	activeIndicator := " "
-	if rep.BlockedOn == report.FsBlockedOnNothing &&
-		(rep.State == report.FilesystemPlanning || rep.State == report.FilesystemStepping) {
+	if active {
 		activeIndicator = "*"
 	}
 	t.AddIndent(1)
@@ -273,9 +260,9 @@ func printFilesystemStatus(t *stringbuilder.B, rep *report.FilesystemReport, max
 				attribs = append(attribs, "resumed")
 			}

-			if len(attribs) > 0 {
-				next += fmt.Sprintf(" (%s)", strings.Join(attribs, ", "))
-			}
+			attribs = append(attribs, fmt.Sprintf("encrypted=%s", nextStep.Info.Encrypted))
+
+			next += fmt.Sprintf(" (%s)", strings.Join(attribs, ", "))
 		} else {
 			next = "" // individual FSes may still be in planning state
 		}
@@ -369,20 +356,10 @@ func renderReplicationReport(t *stringbuilder.B, rep *report.Report, history *by
 		// Progress: [---------------]
 		expected, replicated, containsInvalidSizeEstimates := latest.BytesSum()
 		rate, changeCount := history.Update(replicated)
-		eta := time.Duration(0)
-		if rate > 0 {
-			eta = time.Duration((float64(expected)-float64(replicated))/float64(rate)) * time.Second
-		}
-
-		if !latest.State.IsTerminal() {
-			t.Write("Progress: ")
-			t.DrawBar(50, replicated, expected, changeCount)
-			t.Write(fmt.Sprintf(" %s / %s @ %s/s", ByteCountBinaryUint(replicated), ByteCountBinaryUint(expected), ByteCountBinary(rate)))
-			if eta != 0 {
-				t.Write(fmt.Sprintf(" (%s remaining)", humanizeDuration(eta)))
-			}
-			t.Newline()
-		}
+		t.Write("Progress: ")
+		t.DrawBar(50, replicated, expected, changeCount)
+		t.Write(fmt.Sprintf(" %s / %s @ %s/s", ByteCountBinary(replicated), ByteCountBinary(expected), ByteCountBinary(rate)))
+		t.Newline()
 		if containsInvalidSizeEstimates {
 			t.Write("NOTE: not all steps could be size-estimated, total estimate is likely imprecise!")
 			t.Newline()
@@ -400,36 +377,12 @@ func renderReplicationReport(t *stringbuilder.B, rep *report.Report, history *by
 			}
 		}
 		for _, fs := range latest.Filesystems {
-			printFilesystemStatus(t, fs, maxFSLen)
+			printFilesystemStatus(t, fs, false, maxFSLen) // FIXME bring 'active' flag back
 		}

 	}
 }

-func humanizeDuration(duration time.Duration) string {
-	days := int64(duration.Hours() / 24)
-	hours := int64(math.Mod(duration.Hours(), 24))
-	minutes := int64(math.Mod(duration.Minutes(), 60))
-	seconds := int64(math.Mod(duration.Seconds(), 60))
-
-	var parts []string
-
-	force := false
-	chunks := []int64{days, hours, minutes, seconds}
-	for i, chunk := range chunks {
-		if force || chunk > 0 {
-			padding := 0
-			if force {
-				padding = 2
-			}
-			parts = append(parts, fmt.Sprintf("%*d%c", padding, chunk, "dhms"[i]))
-			force = true
-		}
-	}
-
-	return strings.Join(parts, " ")
-}
-
 func renderPrunerReport(t *stringbuilder.B, r *pruner.Report, fsfilter FilterFunc) {
 	if r == nil {
 		t.Printf("...\n")
@@ -495,17 +448,15 @@ func renderPrunerReport(t *stringbuilder.B, r *pruner.Report, fsfilter FilterFun
 	}

 	// global progress bar
-	if !state.IsTerminal() {
-		progress := int(math.Round(80 * float64(completedDestroyCount) / float64(totalDestroyCount)))
-		t.Write("Progress: ")
-		t.Write("[")
-		t.Write(stringbuilder.Times("=", progress))
-		t.Write(">")
-		t.Write(stringbuilder.Times("-", 80-progress))
-		t.Write("]")
-		t.Printf(" %d/%d snapshots", completedDestroyCount, totalDestroyCount)
-		t.Newline()
-	}
+	progress := int(math.Round(80 * float64(completedDestroyCount) / float64(totalDestroyCount)))
+	t.Write("Progress: ")
+	t.Write("[")
+	t.Write(stringbuilder.Times("=", progress))
+	t.Write(">")
+	t.Write(stringbuilder.Times("-", 80-progress))
+	t.Write("]")
+	t.Printf(" %d/%d snapshots", completedDestroyCount, totalDestroyCount)
+	t.Newline()

 	sort.SliceStable(all, func(i, j int) bool {
 		return strings.Compare(all[i].Filesystem, all[j].Filesystem) == -1
@@ -551,20 +502,10 @@ func renderPrunerReport(t *stringbuilder.B, r *pruner.Report, fsfilter FilterFun

 func renderSnapperReport(t *stringbuilder.B, r *snapper.Report, fsfilter FilterFunc) {
 	if r == nil {
-		t.Printf("<no snapshotting report available>\n")
+		t.Printf("<snapshot type does not have a report>\n")
 		return
 	}
-	t.Printf("Type: %s\n", r.Type)
-	if r.Periodic != nil {
-		renderSnapperReportPeriodic(t, r.Periodic, fsfilter)
-	} else if r.Cron != nil {
-		renderSnapperReportCron(t, r.Cron, fsfilter)
-	} else {
-		t.Printf("<no details available>")
-	}
-}

-func renderSnapperReportPeriodic(t *stringbuilder.B, r *snapper.PeriodicReport, fsfilter FilterFunc) {
 	t.Printf("Status: %s", r.State)
 	t.Newline()

@@ -575,25 +516,8 @@ func renderSnapperReportPeriodic(t *stringbuilder.B, r *snapper.PeriodicReport,
 		t.Printf("Sleep until: %s\n", r.SleepUntil)
 	}

-	renderSnapperPlanReportFilesystem(t, r.Progress, fsfilter)
-}
-
-func renderSnapperReportCron(t *stringbuilder.B, r *snapper.CronReport, fsfilter FilterFunc) {
-	t.Printf("State: %s\n", r.State)
-
-	now := time.Now()
-	if r.WakeupTime.After(now) {
-		t.Printf("Sleep until: %s (%s remaining)\n", r.WakeupTime, r.WakeupTime.Sub(now).Round(time.Second))
-	} else {
-		t.Printf("Started: %s (lasting %s)\n", r.WakeupTime, now.Sub(r.WakeupTime).Round(time.Second))
-	}
-
-	renderSnapperPlanReportFilesystem(t, r.Progress, fsfilter)
-}
-
-func renderSnapperPlanReportFilesystem(t *stringbuilder.B, fss []*snapper.ReportFilesystem, fsfilter FilterFunc) {
-	sort.Slice(fss, func(i, j int) bool {
-		return strings.Compare(fss[i].Path, fss[j].Path) == -1
+	sort.Slice(r.Progress, func(i, j int) bool {
+		return strings.Compare(r.Progress[i].Path, r.Progress[j].Path) == -1
 	})

 	dur := func(d time.Duration) string {
@@ -606,8 +530,8 @@ func renderSnapperPlanReportFilesystem(t *stringbuilder.B, fss []*snapper.Report
 	var widths struct {
 		path, state, duration int
 	}
-	rows := make([]*row, 0, len(fss))
-	for _, fs := range fss {
+	rows := make([]*row, 0, len(r.Progress))
+	for _, fs := range r.Progress {
 		if !fsfilter(fs.Path) {
 			continue
 		}
@@ -650,11 +574,9 @@ func renderSnapperPlanReportFilesystem(t *stringbuilder.B, fss []*snapper.Report
 		t.Printf("%s %s %s", path, state, duration)
 		t.PrintfDrawIndentedAndWrappedIfMultiline(" %s", r.remainder)
 		if r.hookReport != "" {
-			t.AddIndent(1)
-			t.Newline()
-			t.Printf("%s", r.hookReport)
-			t.AddIndent(-1)
+			t.PrintfDrawIndentedAndWrappedIfMultiline("%s", r.hookReport)
 		}
 		t.Newline()
 	}
+
 }
@@ -99,11 +99,11 @@ func RightPad(str string, length int, pad string) string {
 }

 // changeCount = 0 indicates stall / no progress
-func (w *B) DrawBar(length int, bytes, totalBytes uint64, changeCount int) {
+func (w *B) DrawBar(length int, bytes, totalBytes int64, changeCount int) {
 	const arrowPositions = `>\|/`
 	var completedLength int
 	if totalBytes > 0 {
-		completedLength = int(uint64(length) * bytes / totalBytes)
+		completedLength = int(int64(length) * bytes / totalBytes)
 		if completedLength > length {
 			completedLength = length
 		}
@@ -139,11 +139,9 @@ var testPlaceholder = &cli.Subcommand{
 func runTestPlaceholder(ctx context.Context, subcommand *cli.Subcommand, args []string) error {

 	var checkDPs []*zfs.DatasetPath
-	var datasetWasExplicitArgument bool

 	// all actions first
 	if testPlaceholderArgs.all {
-		datasetWasExplicitArgument = false
 		out, err := zfs.ZFSList(ctx, []string{"name"})
 		if err != nil {
 			return errors.Wrap(err, "could not list ZFS filesystems")
@@ -156,7 +154,6 @@ func runTestPlaceholder(ctx context.Context, subcommand *cli.Subcommand, args []
 			checkDPs = append(checkDPs, dp)
 		}
 	} else {
-		datasetWasExplicitArgument = true
 		dp, err := zfs.NewDatasetPath(testPlaceholderArgs.ds)
 		if err != nil {
 			return err
@@ -174,12 +171,7 @@ func runTestPlaceholder(ctx context.Context, subcommand *cli.Subcommand, args []
 			return errors.Wrap(err, "cannot get placeholder state")
 		}
 		if !ph.FSExists {
-			if datasetWasExplicitArgument {
-				return errors.Errorf("filesystem %q does not exist", ph.FS)
-			} else {
-				// got deleted between ZFSList and ZFSGetFilesystemPlaceholderState
-				continue
-			}
+			panic("placeholder state inconsistent: filesystem " + ph.FS + " must exist in this context")
 		}
 		is := "yes"
 		if !ph.IsPlaceholder {
@@ -0,0 +1,94 @@
+package client
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/pkg/errors"
+
+	"github.com/zrepl/zrepl/cli"
+	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/daemon"
+	"github.com/zrepl/zrepl/daemon/job"
+)
+
+var TriggerCmd = &cli.Subcommand{
+	Use:   "trigger JOB [replication|snapshot]",
+	Short: "",
+	Run: func(ctx context.Context, subcommand *cli.Subcommand, args []string) error {
+		return runTriggerCmd(subcommand.Config(), args)
+	},
+}
+
+type TriggerToken struct {
+	// TODO version, daemon invocation id, etc.
+	Job          string
+	InvocationId uint64
+}
+
+func (t TriggerToken) Encode() string {
+	j, err := json.Marshal(t)
+	if err != nil {
+		panic(err)
+	}
+	return string(j)
+}
+
+func (t *TriggerToken) Decode(s string) error {
+	return json.Unmarshal([]byte(s), t)
+}
+
+func (t TriggerToken) ToReset() daemon.ControlJobEndpointResetActiveRequest {
+	return daemon.ControlJobEndpointResetActiveRequest{
+		Job: t.Job,
+		ActiveSideResetRequest: job.ActiveSideResetRequest{
+			InvocationId: t.InvocationId,
+		},
+	}
+}
+
+func (t TriggerToken) ToWait() daemon.ControlJobEndpointWaitActiveRequest {
+	return daemon.ControlJobEndpointWaitActiveRequest{
+		Job: t.Job,
+		ActiveSidePollRequest: job.ActiveSidePollRequest{
+			InvocationId: t.InvocationId,
+		},
+	}
+}
+
+func runTriggerCmd(config *config.Config, args []string) error {
+	if len(args) != 2 {
+		return errors.Errorf("Expected 2 arguments: [replication|reset|snapshot] JOB")
+	}
+
+	httpc, err := controlHttpClient(config.Global.Control.SockPath)
+	if err != nil {
+		return err
+	}
+
+	jobName := args[0]
+	what := args[1]
+
+	var res job.ActiveSideSignalResponse
+	err = jsonRequestResponse(httpc, daemon.ControlJobEndpointTriggerActive,
+		struct {
+			Job string
+			job.ActiveSideTriggerRequest
+		}{
+			Job: jobName,
+			ActiveSideTriggerRequest: job.ActiveSideTriggerRequest{
+				What: what,
+			},
+		},
+		&res,
+	)
+
+	token := TriggerToken{
+		Job:          jobName,
+		InvocationId: res.InvocationId,
+	}
+
+	fmt.Println(token.Encode())
+	return err
+}
@@ -0,0 +1,110 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/kr/pretty"
+	"github.com/pkg/errors"
+	"github.com/spf13/pflag"
+
+	"github.com/zrepl/zrepl/cli"
+	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/daemon"
+	"github.com/zrepl/zrepl/daemon/job"
+)
+
+var waitCmdArgs struct {
+	verbose  bool
+	interval time.Duration
+	token    string
+}
+
+var WaitCmd = &cli.Subcommand{
+	Use:   "wait [-t TOKEN | JOB INVOCATION [replication|snapshotting|prune_sender|prune_receiver]]",
+	Short: "",
+	Run: func(ctx context.Context, subcommand *cli.Subcommand, args []string) error {
+		return runWaitCmd(subcommand.Config(), args)
+	},
+	SetupFlags: func(f *pflag.FlagSet) {
+		f.BoolVarP(&waitCmdArgs.verbose, "verbose", "v", false, "verbose output")
+		f.DurationVarP(&waitCmdArgs.interval, "poll-interval", "i", 100*time.Millisecond, "poll interval")
+		f.StringVarP(&waitCmdArgs.token, "token", "t", "", "token produced by 'signal' subcommand")
+	},
+}
+
+func runWaitCmd(config *config.Config, args []string) error {
+
+	httpc, err := controlHttpClient(config.Global.Control.SockPath)
+	if err != nil {
+		return err
+	}
+
+	var req daemon.ControlJobEndpointWaitActiveRequest
+	if waitCmdArgs.token != "" {
+		var token TriggerToken
+		err := token.Decode(resetCmdArgs.token)
+		if err != nil {
+			return errors.Wrap(err, "cannot decode token")
+		}
+		req = token.ToWait()
+	} else {
+
+		jobName := args[0]
+
+		invocationId, err := strconv.ParseUint(args[1], 10, 64)
+		if err != nil {
+			return errors.Wrap(err, "parse invocation id")
+		}
+
+		// updated by subsequent requests
+		req = daemon.ControlJobEndpointWaitActiveRequest{
+			Job: jobName,
+			ActiveSidePollRequest: job.ActiveSidePollRequest{
+				InvocationId: invocationId,
+			},
+		}
+	}
+
+	doneErr := fmt.Errorf("done")
+
+	pollOnce := func() error {
+		var res job.ActiveSidePollResponse
+		if waitCmdArgs.verbose {
+			pretty.Println("making poll request", req)
+		}
+		err = jsonRequestResponse(httpc, daemon.ControlJobEndpointPollActive,
+			req,
+			&res,
+		)
+		if err != nil {
+			return err
+		}
+
+		if waitCmdArgs.verbose {
+			pretty.Println("got poll response", res)
+		}
+
+		if res.Done {
+			return doneErr
+		}
+
+		req.InvocationId = res.InvocationId
+
+		return nil
+	}
+
+	t := time.NewTicker(waitCmdArgs.interval)
+	for range t.C {
+		err := pollOnce()
+		if err == doneErr {
+			return nil
+		} else if err != nil {
+			return err
+		}
+	}
+
+	return err
+}
@@ -57,7 +57,7 @@ func (f *zabsFilterFlags) registerZabsFilterFlags(s *pflag.FlagSet, verb string)
 	for v := range endpoint.AbstractionTypesAll {
 		variants = append(variants, string(v))
 	}
-	sort.Strings(variants)
+	variants = sort.StringSlice(variants)
 	variantsJoined := strings.Join(variants, "|")
 	s.Var(&f.Types, "type", fmt.Sprintf("only %s holds of the specified type [default: all] [comma-separated list of %s]", verb, variantsJoined))

@@ -44,11 +44,10 @@ func doZabsList(ctx context.Context, sc *cli.Subcommand, args []string) error {
 		return errors.Wrap(err, "invalid filter specification on command line")
 	}

-	abstractions, errors, drainDone, err := endpoint.ListAbstractionsStreamed(ctx, q)
+	abstractions, errors, err := endpoint.ListAbstractionsStreamed(ctx, q)
 	if err != nil {
 		return err // context clear by invocation of command
 	}
-	defer drainDone()

 	var line chainlock.L
 	var wg sync.WaitGroup
@@ -6,23 +6,16 @@ import (
 	"log/syslog"
 	"os"
 	"reflect"
+	"regexp"
+	"strconv"
 	"time"

 	"github.com/pkg/errors"
-	"github.com/robfig/cron/v3"
 	"github.com/zrepl/yaml-config"

-	"github.com/zrepl/zrepl/util/datasizeunit"
 	zfsprop "github.com/zrepl/zrepl/zfs/property"
 )

-type ParseFlags uint
-
-const (
-	ParseFlagsNone        ParseFlags = 0
-	ParseFlagsNoCertCheck ParseFlags = 1 << iota
-)
-
 type Config struct {
 	Jobs   []JobEnum `yaml:"jobs"`
 	Global *Global   `yaml:"global,optional,fromdefaults"`
@@ -61,28 +54,26 @@ func (j JobEnum) Name() string {
 }

 type ActiveJob struct {
-	Type               string                `yaml:"type"`
-	Name               string                `yaml:"name"`
-	Connect            ConnectEnum           `yaml:"connect"`
-	Pruning            PruningSenderReceiver `yaml:"pruning"`
-	Replication        *Replication          `yaml:"replication,optional,fromdefaults"`
-	ConflictResolution *ConflictResolution   `yaml:"conflict_resolution,optional,fromdefaults"`
-}
-
-type ConflictResolution struct {
-	InitialReplication string `yaml:"initial_replication,optional,default=most_recent"`
+	Type        string                `yaml:"type"`
+	Name        string                `yaml:"name"`
+	Connect     ConnectEnum           `yaml:"connect"`
+	Pruning     PruningSenderReceiver `yaml:"pruning"`
+	Debug       JobDebugSettings      `yaml:"debug,optional"`
+	Replication *Replication          `yaml:"replication,optional,fromdefaults"`
 }

 type PassiveJob struct {
-	Type  string    `yaml:"type"`
-	Name  string    `yaml:"name"`
-	Serve ServeEnum `yaml:"serve"`
+	Type  string           `yaml:"type"`
+	Name  string           `yaml:"name"`
+	Serve ServeEnum        `yaml:"serve"`
+	Debug JobDebugSettings `yaml:"debug,optional"`
 }

 type SnapJob struct {
 	Type         string            `yaml:"type"`
 	Name         string            `yaml:"name"`
 	Pruning      PruningLocal      `yaml:"pruning"`
+	Debug        JobDebugSettings  `yaml:"debug,optional"`
 	Snapshotting SnapshottingEnum  `yaml:"snapshotting"`
 	Filesystems  FilesystemsFilter `yaml:"filesystems"`
 }
@@ -94,10 +85,8 @@ type SendOptions struct {
 	BackupProperties bool `yaml:"backup_properties,optional,default=false"`
 	LargeBlocks      bool `yaml:"large_blocks,optional,default=false"`
 	Compressed       bool `yaml:"compressed,optional,default=false"`
-	EmbeddedData     bool `yaml:"embedded_data,optional,default=false"`
+	EmbeddedData     bool `yaml:"embbeded_data,optional,default=false"`
 	Saved            bool `yaml:"saved,optional,default=false"`
-
-	BandwidthLimit *BandwidthLimit `yaml:"bandwidth_limit,optional,fromdefaults"`
 }

 type RecvOptions struct {
@@ -107,21 +96,9 @@ type RecvOptions struct {
 	// Reencrypt bool `yaml:"reencrypt"`

 	Properties *PropertyRecvOptions `yaml:"properties,fromdefaults"`
-
-	BandwidthLimit *BandwidthLimit `yaml:"bandwidth_limit,optional,fromdefaults"`
-
-	Placeholder *PlaceholderRecvOptions `yaml:"placeholder,fromdefaults"`
-}
-
-var _ yaml.Unmarshaler = &datasizeunit.Bits{}
-
-type BandwidthLimit struct {
-	Max            datasizeunit.Bits `yaml:"max,default=-1 B"`
-	BucketCapacity datasizeunit.Bits `yaml:"bucket_capacity,default=128 KiB"`
 }

 type Replication struct {
-	Triggers    []*ReplicationTriggerEnum
 	Protection  *ReplicationOptionsProtection  `yaml:"protection,optional,fromdefaults"`
 	Concurrency *ReplicationOptionsConcurrency `yaml:"concurrency,optional,fromdefaults"`
 }
@@ -136,30 +113,8 @@ type ReplicationOptionsConcurrency struct {
 	SizeEstimates int `yaml:"size_estimates,optional,default=4"`
 }

-type ReplicationTriggerEnum struct {
-	Ret interface{}
-}
-
-func (t *ReplicationTriggerEnum) UnmarshalYAML(u func(interface{}, bool) error) (err error) {
-	t.Ret, err = enumUnmarshal(u, map[string]interface{}{
-		"manual":   &ReplicationTriggerManual{},
-		"periodic": &ReplicationTriggerPeriodic{},
-	})
-	return
-}
-
-type ReplicationTriggerManual struct {
-	Type string `yaml:"type"`
-}
-
-type ReplicationTriggerPeriodic struct {
-	Type     string            `yaml:"type"`
-	Interval *PositiveDuration `yaml:"interval"`
-}
-
-type ReplicationTriggerCron struct {
-	Type string   `yaml:"type"`
-	Cron CronSpec `yaml:"cron"`
+func (l *RecvOptions) SetDefault() {
+	*l = RecvOptions{Properties: &PropertyRecvOptions{}}
 }

 type PropertyRecvOptions struct {
@@ -167,10 +122,6 @@ type PropertyRecvOptions struct {
 	Override map[zfsprop.Property]string `yaml:"override,optional"`
 }

-type PlaceholderRecvOptions struct {
-	Encryption string `yaml:"encryption,default=unspecified"`
-}
-
 type PushJob struct {
 	ActiveJob    `yaml:",inline"`
 	Snapshotting SnapshottingEnum  `yaml:"snapshotting"`
@@ -184,6 +135,7 @@ func (j *PushJob) GetSendOptions() *SendOptions      { return j.Send }
 type PullJob struct {
 	ActiveJob `yaml:",inline"`
 	RootFS    string                   `yaml:"root_fs"`
+	Interval  PositiveDurationOrManual `yaml:"interval"`
 	Recv      *RecvOptions             `yaml:"recv,fromdefaults,optional"`
 }

@@ -211,10 +163,13 @@ func (i *PositiveDurationOrManual) UnmarshalYAML(u func(interface{}, bool) error
 		return fmt.Errorf("value must not be empty")
 	default:
 		i.Manual = false
-		i.Interval, err = parsePositiveDuration(s)
+		i.Interval, err = time.ParseDuration(s)
 		if err != nil {
 			return err
 		}
+		if i.Interval <= 0 {
+			return fmt.Errorf("value must be a positive duration, got %q", s)
+		}
 	}
 	return nil
 }
@@ -246,44 +201,10 @@ type SnapshottingEnum struct {
 }

 type SnapshottingPeriodic struct {
-	Type            string            `yaml:"type"`
-	Prefix          string            `yaml:"prefix"`
-	Interval        *PositiveDuration `yaml:"interval"`
-	Hooks           HookList          `yaml:"hooks,optional"`
-	TimestampFormat string            `yaml:"timestamp_format,optional,default=dense"`
-}
-
-type CronSpec struct {
-	Schedule cron.Schedule
-}
-
-var _ yaml.Unmarshaler = &CronSpec{}
-
-func (s *CronSpec) UnmarshalYAML(unmarshal func(v interface{}, not_strict bool) error) error {
-	var specString string
-	if err := unmarshal(&specString, false); err != nil {
-		return err
-	}
-
-	// Use standard cron format.
-	// Disable the various "descriptors" (@daily, etc)
-	// They are just aliases to "top of hour", "midnight", etc.
-	parser := cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.SecondOptional)
-
-	sched, err := parser.Parse(specString)
-	if err != nil {
-		return errors.Wrap(err, "cron syntax invalid")
-	}
-	s.Schedule = sched
-	return nil
-}
-
-type SnapshottingCron struct {
-	Type            string   `yaml:"type"`
-	Prefix          string   `yaml:"prefix"`
-	Cron            CronSpec `yaml:"cron"`
-	Hooks           HookList `yaml:"hooks,optional"`
-	TimestampFormat string   `yaml:"timestamp_format,optional,default=dense"`
+	Type     string        `yaml:"type"`
+	Prefix   string        `yaml:"prefix"`
+	Interval time.Duration `yaml:"interval,positive"`
+	Hooks    HookList      `yaml:"hooks,optional"`
 }

 type SnapshottingManual struct {
@@ -503,6 +424,14 @@ type GlobalStdinServer struct {
 	SockDir string `yaml:"sockdir,default=/var/run/zrepl/stdinserver"`
 }

+type JobDebugSettings struct {
+	Conn *struct {
+		ReadDump  string `yaml:"read_dump"`
+		WriteDump string `yaml:"write_dump"`
+	} `yaml:"conn,optional"`
+	RPCLog bool `yaml:"rpc_log,optional,default=false"`
+}
+
 type HookList []HookEnum

 type HookEnum struct {
@@ -601,7 +530,6 @@ func (t *SnapshottingEnum) UnmarshalYAML(u func(interface{}, bool) error) (err e
 	t.Ret, err = enumUnmarshal(u, map[string]interface{}{
 		"periodic": &SnapshottingPeriodic{},
 		"manual":   &SnapshottingManual{},
-		"cron":     &SnapshottingCron{},
 	})
 	return
 }
@@ -727,3 +655,41 @@ func ParseConfigBytes(bytes []byte) (*Config, error) {
 	}
 	return c, nil
 }
+
+var durationStringRegex *regexp.Regexp = regexp.MustCompile(`^\s*(\d+)\s*(s|m|h|d|w)\s*$`)
+
+func parsePositiveDuration(e string) (d time.Duration, err error) {
+	comps := durationStringRegex.FindStringSubmatch(e)
+	if len(comps) != 3 {
+		err = fmt.Errorf("does not match regex: %s %#v", e, comps)
+		return
+	}
+
+	durationFactor, err := strconv.ParseInt(comps[1], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	if durationFactor <= 0 {
+		return 0, errors.New("duration must be positive integer")
+	}
+
+	var durationUnit time.Duration
+	switch comps[2] {
+	case "s":
+		durationUnit = time.Second
+	case "m":
+		durationUnit = time.Minute
+	case "h":
+		durationUnit = time.Hour
+	case "d":
+		durationUnit = 24 * time.Hour
+	case "w":
+		durationUnit = 24 * 7 * time.Hour
+	default:
+		err = fmt.Errorf("contains unknown time unit '%s'", comps[2])
+		return
+	}
+
+	d = time.Duration(durationFactor) * durationUnit
+	return
+}
@@ -1,106 +0,0 @@
-package config
-
-import (
-	"errors"
-	"fmt"
-	"regexp"
-	"strconv"
-	"time"
-
-	"github.com/kr/pretty"
-	"github.com/zrepl/yaml-config"
-)
-
-type Duration struct{ d time.Duration }
-
-func (d Duration) Duration() time.Duration { return d.d }
-
-var _ yaml.Unmarshaler = &Duration{}
-
-func (d *Duration) UnmarshalYAML(unmarshal func(v interface{}, not_strict bool) error) error {
-	var s string
-	err := unmarshal(&s, false)
-	if err != nil {
-		return err
-	}
-	d.d, err = parseDuration(s)
-	if err != nil {
-		d.d = 0
-		return &yaml.TypeError{Errors: []string{fmt.Sprintf("cannot parse value %q: %s", s, err)}}
-	}
-	return nil
-}
-
-type PositiveDuration struct{ d Duration }
-
-var _ yaml.Unmarshaler = &PositiveDuration{}
-
-func (d PositiveDuration) Duration() time.Duration { return d.d.Duration() }
-
-func (d *PositiveDuration) UnmarshalYAML(unmarshal func(v interface{}, not_strict bool) error) error {
-	err := d.d.UnmarshalYAML(unmarshal)
-	if err != nil {
-		return err
-	}
-	if d.d.Duration() <= 0 {
-		return fmt.Errorf("duration must be positive, got %s", d.d.Duration())
-	}
-	return nil
-}
-
-func parsePositiveDuration(e string) (time.Duration, error) {
-	d, err := parseDuration(e)
-	if err != nil {
-		return d, err
-	}
-	if d <= 0 {
-		return 0, errors.New("duration must be positive integer")
-	}
-	return d, err
-}
-
-var durationStringRegex *regexp.Regexp = regexp.MustCompile(`^\s*([\+-]?\d+)\s*(|s|m|h|d|w)\s*$`)
-
-func parseDuration(e string) (d time.Duration, err error) {
-	comps := durationStringRegex.FindStringSubmatch(e)
-	if comps == nil {
-		err = fmt.Errorf("must match %s", durationStringRegex)
-		return
-	}
-	if len(comps) != 3 {
-		panic(pretty.Sprint(comps))
-	}
-
-	durationFactor, err := strconv.ParseInt(comps[1], 10, 64)
-	if err != nil {
-		return 0, err
-	}
-
-	var durationUnit time.Duration
-	switch comps[2] {
-	case "":
-		if durationFactor != 0 {
-			err = fmt.Errorf("missing time unit")
-			return
-		} else {
-			// It's the case where user specified '0'.
-			// We want to allow this, just like time.ParseDuration.
-		}
-	case "s":
-		durationUnit = time.Second
-	case "m":
-		durationUnit = time.Minute
-	case "h":
-		durationUnit = time.Hour
-	case "d":
-		durationUnit = 24 * time.Hour
-	case "w":
-		durationUnit = 24 * 7 * time.Hour
-	default:
-		err = fmt.Errorf("contains unknown time unit '%s'", comps[2])
-		return
-	}
-
-	d = time.Duration(durationFactor) * durationUnit
-	return
-}
@@ -70,9 +70,9 @@ func TestPrometheusMonitoring(t *testing.T) {
 global:
  monitoring:
    - type: prometheus
-      listen: ':9811'
+      listen: ':9091'
 `)
-	assert.Equal(t, ":9811", conf.Global.Monitoring[0].Ret.(*PrometheusMonitoring).Listen)
+	assert.Equal(t, ":9091", conf.Global.Monitoring[0].Ret.(*PrometheusMonitoring).Listen)
 }

 func TestSyslogLoggingOutletFacility(t *testing.T) {
@@ -35,23 +35,8 @@ jobs:
  snapshotting:
    type: periodic
    prefix: zrepl_
-    timestamp_format: dense
    interval: 10m
 `
-	cron := `
-  snapshotting:
-    type: cron
-    prefix: zrepl_
-    timestamp_format: human
-    cron: "10 * * * *"
-`
-
-	periodicDaily := `
-  snapshotting:
-    type: periodic
-    prefix: zrepl_
-    interval: 1d
-`

 	hooks := `
  snapshotting:
@@ -89,27 +74,10 @@ jobs:
 		c = testValidConfig(t, fillSnapshotting(periodic))
 		snp := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingPeriodic)
 		assert.Equal(t, "periodic", snp.Type)
-		assert.Equal(t, 10*time.Minute, snp.Interval.Duration())
+		assert.Equal(t, 10*time.Minute, snp.Interval)
 		assert.Equal(t, "zrepl_", snp.Prefix)
 	})

-	t.Run("periodicDaily", func(t *testing.T) {
-		c = testValidConfig(t, fillSnapshotting(periodicDaily))
-		snp := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingPeriodic)
-		assert.Equal(t, "periodic", snp.Type)
-		assert.Equal(t, 24*time.Hour, snp.Interval.Duration())
-		assert.Equal(t, "zrepl_", snp.Prefix)
-		assert.Equal(t, "dense", snp.TimestampFormat)
-	})
-
-	t.Run("cron", func(t *testing.T) {
-		c = testValidConfig(t, fillSnapshotting(cron))
-		snp := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingCron)
-		assert.Equal(t, "cron", snp.Type)
-		assert.Equal(t, "zrepl_", snp.Prefix)
-		assert.Equal(t, "human", snp.TimestampFormat)
-	})
-
 	t.Run("hooks", func(t *testing.T) {
 		c = testValidConfig(t, fillSnapshotting(hooks))
 		hs := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingPeriodic).Hooks
@@ -120,57 +88,3 @@ jobs:
 	})

 }
-
-func TestSnapshottingTimestampDefaults(t *testing.T) {
-	tmpl := `
-jobs:
- name: foo
-  type: push
-  connect:
-    type: local
-    listener_name: foo
-    client_identity: bar
-  filesystems: {"<": true}
-  %s
-  pruning:
-    keep_sender:
-    - type: last_n
-      count: 10
-    keep_receiver:
-    - type: last_n
-      count: 10
-`
-
-	periodic := `
-  snapshotting:
-    type: periodic
-    prefix: zrepl_
-    interval: 10m
-`
-	cron := `
-  snapshotting:
-    type: cron
-    prefix: zrepl_
-    cron: "10 * * * *"
-`
-
-	fillSnapshotting := func(s string) string { return fmt.Sprintf(tmpl, s) }
-	var c *Config
-
-	t.Run("periodic", func(t *testing.T) {
-		c = testValidConfig(t, fillSnapshotting(periodic))
-		snp := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingPeriodic)
-		assert.Equal(t, "periodic", snp.Type)
-		assert.Equal(t, 10*time.Minute, snp.Interval.Duration())
-		assert.Equal(t, "zrepl_", snp.Prefix)
-		assert.Equal(t, "dense", snp.TimestampFormat) // default was set correctly
-	})
-
-	t.Run("cron", func(t *testing.T) {
-		c = testValidConfig(t, fillSnapshotting(cron))
-		snp := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingCron)
-		assert.Equal(t, "cron", snp.Type)
-		assert.Equal(t, "zrepl_", snp.Prefix)
-		assert.Equal(t, "dense", snp.TimestampFormat) // default was set correctly
-	})
-}
@@ -13,7 +13,6 @@ import (
 	"github.com/kr/pretty"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/zrepl/yaml-config"
 )

 func TestSampleConfigsAreParsedWithoutErrors(t *testing.T) {
@@ -44,8 +43,7 @@ func TestSampleConfigsAreParsedWithoutErrors(t *testing.T) {
 }

 // template must be a template/text template with a single '{{ . }}' as placeholder for val
-//
-//nolint:deadcode,unused
+//nolint[:deadcode,unused]
 func testValidConfigTemplate(t *testing.T, tmpl string, val string) *Config {
 	tmp, err := template.New("master").Parse(tmpl)
 	if err != nil {
@@ -88,53 +86,3 @@ func TestTrimSpaceEachLineAndPad(t *testing.T) {
 	`
 	assert.Equal(t, "  \n  foo\n  bar baz\n  \n", trimSpaceEachLineAndPad(foo, "  "))
 }
-
-func TestCronSpec(t *testing.T) {
-
-	expectAccept := []string{
-		`"* * * * *"`,
-		`"0-10 * * * *"`,
-		`"* 0-5,8,12 * * *"`,
-	}
-
-	expectFail := []string{
-		`* * * *`,
-		``,
-		`23`,
-		`"@reboot"`,
-		`"@every 1h30m"`,
-		`"@daily"`,
-		`* * * * * *`,
-	}
-
-	for _, input := range expectAccept {
-		t.Run(input, func(t *testing.T) {
-			s := fmt.Sprintf("spec: %s\n", input)
-			var v struct {
-				Spec CronSpec
-			}
-			v.Spec.Schedule = nil
-			t.Logf("input:\n%s", s)
-			err := yaml.UnmarshalStrict([]byte(s), &v)
-			t.Logf("error: %T %s", err, err)
-			require.NoError(t, err)
-			require.NotNil(t, v.Spec.Schedule)
-		})
-	}
-
-	for _, input := range expectFail {
-		t.Run(input, func(t *testing.T) {
-			s := fmt.Sprintf("spec: %s\n", input)
-			var v struct {
-				Spec CronSpec
-			}
-			v.Spec.Schedule = nil
-			t.Logf("input: %q", s)
-			err := yaml.UnmarshalStrict([]byte(s), &v)
-			t.Logf("error: %T %s", err, err)
-			require.Error(t, err)
-			require.Nil(t, v.Spec.Schedule)
-		})
-	}
-
-}
@@ -1,41 +0,0 @@
-
-jobs:
-  - type: sink
-    name: "limited_sink"
-    root_fs: "fs0"
-    recv:
-      bandwidth_limit:
-        max: 12345 B
-    serve:
-      type: local
-      listener_name: localsink
-
-  - type: push
-    name: "limited_push"
-    connect:
-      type: local
-      listener_name: localsink
-      client_identity: local_backup
-    filesystems: {
-      "root<": true,
-    }
-    send:
-      bandwidth_limit:
-        max: 54321 B
-        bucket_capacity: 1024 B
-    snapshotting:
-      type: manual
-    pruning:
-      keep_sender:
-        - type: last_n
-          count: 1
-      keep_receiver:
-        - type: last_n
-          count: 1
-
-  - type: sink
-    name: "nolimit_sink"
-    root_fs: "fs1"
-    serve:
-      type: local
-      listener_name: localsink
@@ -5,7 +5,7 @@
 # quick start section which inlines this example.
 #
 # CUSTOMIZATIONS YOU WILL LIKELY WANT TO APPLY:
-# - adjust the name of the production pool `system` in the `filesystems` filter of jobs `snapjob` and `push_to_drive`
+# - adjust the name of the production pool `system` in the `filesystems` filter of jobs `snapjob` and `push_to_derive`
 # - adjust the name of the backup pool `backuppool` in the `backuppool_sink` job
 # - adjust the occurences of `myhostname` to the name of the system you are backing up (cannot be easily changed once you start replicating)
 # - make sure the `zrepl_` prefix is not being used by any other zfs tools you might have installed (it likely isn't)
@@ -40,7 +40,7 @@ jobs:

 # This job pushes to the local sink defined in job `backuppool_sink`.
 # We trigger replication manually from the command line / udev rules using
-#  `zrepl signal wakeup push_to_drive`
+#  `zrepl signal replication push_to_drive`
 - type: push
  name: push_to_drive
  connect:
@@ -85,4 +85,4 @@ jobs:
  root_fs: "backuppool/zrepl/sink"
  serve:
    type: local
-    listener_name: backuppool_sink
+    listener_name: backuppool_sink
@@ -9,8 +9,8 @@ jobs:
    key:  /etc/zrepl/prod.key
    server_cn: "backups"
  filesystems: {
-    "zroot<": true,
-    "zroot/var/tmp<": false,
+    "zroot/var/db": true,
+    "zroot/usr/home<": true,
    "zroot/usr/home/paranoid": false
  }
  snapshotting:
@@ -1,59 +0,0 @@
-jobs:
-# Separate job for snapshots and pruning
- name: snapshots
-  type: snap
-  filesystems:
-    'tank<': true # all filesystems
-  snapshotting:
-    type: periodic
-    prefix: zrepl_
-    interval: 10m
-  pruning:
-    keep:
-      # Keep non-zrepl snapshots
-      - type: regex
-        negate: true
-        regex: '^zrepl_'
-      # Time-based snapshot retention
-      - type: grid
-        grid: 1x1h(keep=all) | 24x1h | 30x1d | 12x30d
-        regex: '^zrepl_'
-
-# Source job for target B
- name: target_b
-  type: source
-  serve:
-    type: tls
-    listen: :8888
-    ca: /etc/zrepl/b.example.com.crt
-    cert: /etc/zrepl/a.example.com.crt
-    key: /etc/zrepl/a.example.com.key
-    client_cns:
-      - b.example.com
-  filesystems:
-    'tank<': true # all filesystems
-  # Snapshots are handled by the separate snap job
-  snapshotting:
-    type: manual
-
-# Source job for target C
- name: target_c
-  type: source
-  serve:
-    type: tls
-    listen: :8889
-    ca: /etc/zrepl/c.example.com.crt
-    cert: /etc/zrepl/a.example.com.crt
-    key: /etc/zrepl/a.example.com.key
-    client_cns:
-      - c.example.com
-  filesystems:
-    'tank<': true # all filesystems
-  # Snapshots are handled by the separate snap job
-  snapshotting:
-    type: manual
-
-# Source jobs for remaining targets. Each one should listen on a different port
-# and reference the correct certificate and client CN.
-# - name: target_c
-#   ...
@@ -1,30 +0,0 @@
-jobs:
-# Pull from source server A
- name: source_a
-  type: pull
-  connect:
-    type: tls
-    # Use the correct port for this specific client (eg. B is 8888, C is 8889, etc.)
-    address: a.example.com:8888
-    ca: /etc/zrepl/a.example.com.crt
-    # Use the correct key pair for this specific client
-    cert: /etc/zrepl/b.example.com.crt
-    key: /etc/zrepl/b.example.com.key
-    server_cn: a.example.com
-  root_fs: pool0/backup
-  interval: 10m
-  pruning:
-    keep_sender:
-      # Source does the pruning in its snap job
-      - type: regex
-        regex: '.*'
-    # Receiver-side pruning can be configured as desired on each target server
-    keep_receiver:
-      # Keep non-zrepl snapshots
-      - type: regex
-        negate: true
-        regex: '^zrepl_'
-      # Time-based snapshot retention
-      - type: grid
-        grid: 1x1h(keep=all) | 24x1h | 30x1d | 12x30d
-        regex: '^zrepl_'
@@ -1,14 +0,0 @@
-jobs:
- name: snapjob
-  type: snap
-  filesystems: {
-    "tank<": true,
-  }
-  snapshotting:
-    type: cron
-    prefix: zrepl_snapjob_
-    cron: "*/5 * * * *"
-  pruning:
-    keep:
-      - type: last_n
-        count: 60
@@ -8,7 +8,6 @@ import (
 	"io"
 	"net"
 	"net/http"
-	"os"
 	"time"

 	"github.com/pkg/errors"
@@ -74,12 +73,29 @@ func (j *controlJob) RegisterMetrics(registerer prometheus.Registerer) {
 }

 const (
-	ControlJobEndpointPProf   string = "/debug/pprof"
-	ControlJobEndpointVersion string = "/version"
-	ControlJobEndpointStatus  string = "/status"
-	ControlJobEndpointSignal  string = "/signal"
+	ControlJobEndpointPProf         string = "/debug/pprof"
+	ControlJobEndpointVersion       string = "/version"
+	ControlJobEndpointStatus        string = "/status"
+	ControlJobEndpointTriggerActive string = "/signal/active"
+	ControlJobEndpointPollActive    string = "/poll/active"
+	ControlJobEndpointResetActive   string = "/reset/active"
 )

+type ControlJobEndpointTriggerActiveRequest struct {
+	Job string
+	job.ActiveSideTriggerRequest
+}
+
+type ControlJobEndpointResetActiveRequest struct {
+	Job string
+	job.ActiveSideResetRequest
+}
+
+type ControlJobEndpointWaitActiveRequest struct {
+	Job string
+	job.ActiveSidePollRequest
+}
+
 func (j *controlJob) Run(ctx context.Context) {

 	log := job.GetLogger(ctx)
@@ -125,41 +141,117 @@ func (j *controlJob) Run(ctx context.Context) {
 			s := Status{
 				Jobs: jobs,
 				Global: GlobalStatus{
-					ZFSCmds:   globalZFS,
-					Envconst:  envconstReport,
-					OsEnviron: os.Environ(),
+					ZFSCmds:  globalZFS,
+					Envconst: envconstReport,
 				}}
 			return s, nil
 		}})

-	mux.Handle(ControlJobEndpointSignal,
-		requestLogger{log: log, handler: jsonRequestResponder{log, func(decoder jsonDecoder) (interface{}, error) {
+	mux.Handle(ControlJobEndpointPollActive, requestLogger{log: log, handler: jsonRequestResponder{log, func(decoder jsonDecoder) (v interface{}, err error) {
+		var req ControlJobEndpointWaitActiveRequest
+		if decoder(&req) != nil {
+			return nil, errors.Errorf("decode failed")
+		}
+
+		j.jobs.m.RLock()
+
+		jo, ok := j.jobs.jobs[req.Job]
+		if !ok {
+			j.jobs.m.RUnlock()
+			return struct{}{}, fmt.Errorf("unknown job name %q", req.Job)
+		}
+
+		ajo, ok := jo.(*job.ActiveSide)
+		if !ok {
+			v, err = struct{}{}, fmt.Errorf("job %q is not an active side (it's a %T)", jo.Name(), jo)
+			j.jobs.m.RUnlock()
+			return v, err
+		}
+
+		res, err := ajo.Poll(req.ActiveSidePollRequest)
+
+		j.jobs.m.RUnlock()
+
+		return res, err
+	}}})
+
+	mux.Handle(ControlJobEndpointTriggerActive,
+		requestLogger{log: log, handler: jsonRequestResponder{log, func(decoder jsonDecoder) (v interface{}, err error) {
 			type reqT struct {
-				Name string
-				Op   string
+				Job string
+				job.ActiveSideTriggerRequest
 			}
 			var req reqT
 			if decoder(&req) != nil {
 				return nil, errors.Errorf("decode failed")
 			}

-			var err error
-			switch req.Op {
-			case "wakeup":
-				err = j.jobs.wakeup(req.Name)
-			case "reset":
-				err = j.jobs.reset(req.Name)
-			default:
-				err = fmt.Errorf("operation %q is invalid", req.Op)
+			// FIXME dedup the following code with ControlJobEndpointPollActive
+
+			j.jobs.m.RLock()
+
+			jo, ok := j.jobs.jobs[req.Job]
+			if !ok {
+				j.jobs.m.RUnlock()
+				return struct{}{}, fmt.Errorf("unknown job name %q", req.Job)
 			}

-			return struct{}{}, err
+			ajo, ok := jo.(*job.ActiveSide)
+			if !ok {
+				v, err = struct{}{}, fmt.Errorf("job %q is not an active side (it's a %T)", jo.Name(), jo)
+				j.jobs.m.RUnlock()
+				return v, err
+			}
+
+			res, err := ajo.Trigger(req.ActiveSideTriggerRequest)
+
+			j.jobs.m.RUnlock()
+
+			return res, err
+
 		}}})
+
+	mux.Handle(ControlJobEndpointResetActive,
+		requestLogger{log: log, handler: jsonRequestResponder{log, func(decoder jsonDecoder) (v interface{}, err error) {
+			type reqT struct {
+				Job string
+				job.ActiveSideResetRequest
+			}
+			var req reqT
+			if decoder(&req) != nil {
+				return nil, errors.Errorf("decode failed")
+			}
+
+			// FIXME dedup the following code with ControlJobEndpointPollActive
+
+			j.jobs.m.RLock()
+
+			jo, ok := j.jobs.jobs[req.Job]
+			if !ok {
+				j.jobs.m.RUnlock()
+				return struct{}{}, fmt.Errorf("unknown job name %q", req.Job)
+			}
+
+			ajo, ok := jo.(*job.ActiveSide)
+			if !ok {
+				v, err = struct{}{}, fmt.Errorf("job %q is not an active side (it's a %T)", jo.Name(), jo)
+				j.jobs.m.RUnlock()
+				return v, err
+			}
+
+			res, err := ajo.Reset(req.ActiveSideResetRequest)
+
+			j.jobs.m.RUnlock()
+
+			return res, err
+
+		}}})
+
 	server := http.Server{
 		Handler: mux,
 		// control socket is local, 1s timeout should be more than sufficient, even on a loaded system
-		WriteTimeout: envconst.Duration("ZREPL_DAEMON_CONTROL_SERVER_WRITE_TIMEOUT", 1*time.Second),
-		ReadTimeout:  envconst.Duration("ZREPL_DAEMON_CONTROL_SERVER_READ_TIMEOUT", 1*time.Second),
+		WriteTimeout: 1 * time.Second,
+		ReadTimeout:  1 * time.Second,
 	}

 outer:
@@ -20,8 +20,6 @@ import (

 	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/daemon/job"
-	"github.com/zrepl/zrepl/daemon/job/reset"
-	"github.com/zrepl/zrepl/daemon/job/wakeup"
 	"github.com/zrepl/zrepl/daemon/logging"
 	"github.com/zrepl/zrepl/logger"
 	"github.com/zrepl/zrepl/version"
@@ -51,7 +49,7 @@ func Run(ctx context.Context, conf *config.Config) error {
 	}
 	outlets.Add(newPrometheusLogOutlet(), logger.Debug)

-	confJobs, err := job.JobsFromConfig(conf, config.ParseFlagsNone)
+	confJobs, err := job.JobsFromConfig(conf)
 	if err != nil {
 		return errors.Wrap(err, "cannot build jobs from config")
 	}
@@ -131,17 +129,13 @@ type jobs struct {
 	wg sync.WaitGroup

 	// m protects all fields below it
-	m       sync.RWMutex
-	wakeups map[string]wakeup.Func // by Job.Name
-	resets  map[string]reset.Func  // by Job.Name
-	jobs    map[string]job.Job
+	m    sync.RWMutex
+	jobs map[string]job.Job
 }

 func newJobs() *jobs {
 	return &jobs{
-		wakeups: make(map[string]wakeup.Func),
-		resets:  make(map[string]reset.Func),
-		jobs:    make(map[string]job.Job),
+		jobs: make(map[string]job.Job),
 	}
 }

@@ -160,9 +154,8 @@ type Status struct {
 }

 type GlobalStatus struct {
-	ZFSCmds   *zfscmd.Report
-	Envconst  *envconst.Report
-	OsEnviron []string
+	ZFSCmds  *zfscmd.Report
+	Envconst *envconst.Report
 }

 func (s *jobs) status() map[string]*job.Status {
@@ -191,28 +184,6 @@ func (s *jobs) status() map[string]*job.Status {
 	return ret
 }

-func (s *jobs) wakeup(job string) error {
-	s.m.RLock()
-	defer s.m.RUnlock()
-
-	wu, ok := s.wakeups[job]
-	if !ok {
-		return errors.Errorf("Job %s does not exist", job)
-	}
-	return wu()
-}
-
-func (s *jobs) reset(job string) error {
-	s.m.RLock()
-	defer s.m.RUnlock()
-
-	wu, ok := s.resets[job]
-	if !ok {
-		return errors.Errorf("Job %s does not exist", job)
-	}
-	return wu()
-}
-
 const (
 	jobNamePrometheus = "_prometheus"
 	jobNameControl    = "_control"
@@ -243,10 +214,6 @@ func (s *jobs) start(ctx context.Context, j job.Job, internal bool) {

 	s.jobs[jobName] = j
 	ctx = zfscmd.WithJobID(ctx, j.Name())
-	ctx, wakeup := wakeup.Context(ctx)
-	ctx, resetFunc := reset.Context(ctx)
-	s.wakeups[jobName] = wakeup
-	s.resets[jobName] = resetFunc

 	s.wg.Add(1)
 	go func() {
@@ -160,14 +160,6 @@ func (m DatasetMapFilter) Filter(p *zfs.DatasetPath) (pass bool, err error) {
 	return
 }

-func (m DatasetMapFilter) UserSpecifiedDatasets() (datasets zfs.UserSpecifiedDatasetsSet) {
-	datasets = make(zfs.UserSpecifiedDatasetsSet)
-	for i := range m.entries {
-		datasets[m.entries[i].path.ToString()] = true
-	}
-	return
-}
-
 // Construct a new filter-only DatasetMapFilter from a mapping
 // The new filter allows exactly those paths that were not forbidden by the mapping.
 func (m DatasetMapFilter) InvertedFilter() (inv *DatasetMapFilter, err error) {
@@ -5,7 +5,7 @@
 //
 // This package also provides all supported hook type implementations and abstractions around them.
 //
-// # Use For Other Kinds Of ExpectStepReports
+// Use For Other Kinds Of ExpectStepReports
 //
 // This package REQUIRES REFACTORING before it can be used for other activities than snapshots, e.g. pre- and post-replication:
 //
@@ -15,7 +15,7 @@
 // The hook implementations should move out of this package.
 // However, there is a lot of tight coupling which to untangle isn't worth it ATM.
 //
-// # How This Package Is Used By Package Snapper
+// How This Package Is Used By Package Snapper
 //
 // Deserialize a config.List using ListFromConfig().
 // Then it MUST filter the list to only contain hooks for a particular filesystem using
@@ -30,4 +30,5 @@
 // Command hooks make it available in the environment variable ZREPL_DRYRUN.
 //
 // Plan.Report() can be called while Plan.Run() is executing to give an overview of plan execution progress (future use in "zrepl status").
+//
 package hooks
@@ -93,14 +93,7 @@ func (r *CommandHookReport) String() string {
 		cmdLine.WriteString(fmt.Sprintf("%s'%s'", sep, a))
 	}

-	var msg string
-	if r.Err == nil {
-		msg = "command hook"
-	} else {
-		msg = fmt.Sprintf("command hook failed with %q", r.Err)
-	}
-
-	return fmt.Sprintf("%s: \"%s\"", msg, cmdLine.String()) // no %q to make copy-pastable
+	return fmt.Sprintf("command hook invocation: \"%s\"", cmdLine.String()) // no %q to make copy-pastable
 }
 func (r *CommandHookReport) Error() string {
 	if r.Err == nil {
@@ -17,22 +17,19 @@ import (
 	"github.com/zrepl/zrepl/zfs"
 )

-// Hook to implement the following recommmendation from MySQL docs
 // https://dev.mysql.com/doc/mysql-backup-excerpt/5.7/en/backup-methods.html
 //
-//	Making Backups Using a File System Snapshot:
+// Making Backups Using a File System Snapshot:
 //
-//	If you are using a Veritas file system, you can make a backup like this:
+//  If you are using a Veritas file system, you can make a backup like this:
 //
-//	   	From a client program, execute FLUSH TABLES WITH READ LOCK.
-//	   	From another shell, execute mount vxfs snapshot.
-//	   	From the first client, execute UNLOCK TABLES.
-//	   	Copy files from the snapshot.
-//	   	Unmount the snapshot.
+//    	From a client program, execute FLUSH TABLES WITH READ LOCK.
+//    	From another shell, execute mount vxfs snapshot.
+//    	From the first client, execute UNLOCK TABLES.
+//    	Copy files from the snapshot.
+//    	Unmount the snapshot.
 //
-//		Similar snapshot capabilities may be available in other file systems, such as LVM or ZFS.
-//
-
+//	Similar snapshot capabilities may be available in other file systems, such as LVM or ZFS.
 type MySQLLockTables struct {
 	errIsFatal  bool
 	connector   sqldriver.Connector
@@ -161,7 +161,7 @@ jobs:
 					ExpectedEdge: hooks.Pre,
 					ExpectStatus: hooks.StepErr,
 					OutputTest:   containsTest(fmt.Sprintf("TEST ERROR pre_testing %s@%s", testFSName, testSnapshotName)),
-					ErrorTest:    regexpTest("^command hook failed.*exit status 1$"),
+					ErrorTest:    regexpTest("^command hook invocation.*exit status 1$"),
 				},
 				expectStep{ExpectedEdge: hooks.Callback, ExpectStatus: hooks.StepOk},
 				expectStep{
@@ -185,7 +185,7 @@ jobs:
 					ExpectedEdge: hooks.Pre,
 					ExpectStatus: hooks.StepErr,
 					OutputTest:   containsTest(fmt.Sprintf("TEST ERROR pre_testing %s@%s", testFSName, testSnapshotName)),
-					ErrorTest:    regexpTest("^command hook failed.*exit status 1$"),
+					ErrorTest:    regexpTest("^command hook invocation.*exit status 1$"),
 				},
 				expectStep{
 					ExpectedEdge: hooks.Pre,
@@ -234,7 +234,7 @@ jobs:
 					ExpectedEdge: hooks.Post,
 					ExpectStatus: hooks.StepErr,
 					OutputTest:   containsTest(fmt.Sprintf("TEST ERROR post_testing %s@%s", testFSName, testSnapshotName)),
-					ErrorTest:    regexpTest("^command hook failed.*exit status 1$"),
+					ErrorTest:    regexpTest("^command hook invocation.*exit status 1$"),
 				},
 			},
 		},
@@ -267,7 +267,7 @@ jobs:
 					ExpectedEdge: hooks.Pre,
 					ExpectStatus: hooks.StepErr,
 					OutputTest:   containsTest(fmt.Sprintf("TEST ERROR pre_testing %s@%s", testFSName, testSnapshotName)),
-					ErrorTest:    regexpTest("^command hook failed.*exit status 1$"),
+					ErrorTest:    regexpTest("^command hook invocation.*exit status 1$"),
 				},
 				expectStep{ExpectedEdge: hooks.Callback, ExpectStatus: hooks.StepOk},
 				expectStep{
@@ -295,7 +295,7 @@ jobs:
 					ExpectedEdge: hooks.Pre,
 					ExpectStatus: hooks.StepErr,
 					OutputTest:   containsTest(fmt.Sprintf("TEST ERROR pre_testing %s@%s", testFSName, testSnapshotName)),
-					ErrorTest:    regexpTest("^command hook failed.*exit status 1$"),
+					ErrorTest:    regexpTest("^command hook invocation.*exit status 1$"),
 				},
 				expectStep{ExpectedEdge: hooks.Callback, ExpectStatus: hooks.StepOk},
 				expectStep{
@@ -8,15 +8,11 @@ import (

 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/common/log"

 	"github.com/zrepl/zrepl/daemon/logging/trace"
 	"github.com/zrepl/zrepl/util/envconst"

 	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon/job/reset"
-	"github.com/zrepl/zrepl/daemon/job/trigger"
-	"github.com/zrepl/zrepl/daemon/job/wakeup"
 	"github.com/zrepl/zrepl/daemon/pruner"
 	"github.com/zrepl/zrepl/daemon/snapper"
 	"github.com/zrepl/zrepl/endpoint"
@@ -43,12 +39,13 @@ type ActiveSide struct {
 	promPruneSecs         *prometheus.HistogramVec // labels: prune_side
 	promBytesReplicated   *prometheus.CounterVec   // labels: filesystem
 	promReplicationErrors prometheus.Gauge
-	promLastSuccessful    prometheus.Gauge

-	triggers *trigger.Triggers
-
-	tasksMtx sync.Mutex
-	tasks    activeSideTasks
+	tasksMtx           sync.Mutex
+	tasks              activeSideTasks
+	nextInvocationId   uint64
+	activeInvocationId uint64 // 0 <=> inactive
+	trigger            chan struct{}
+	reset              chan uint64
 }

 //go:generate enumer -type=ActiveSideState
@@ -61,18 +58,17 @@ const (
 	ActiveSideDone // also errors
 )

-type activeSideTasks struct {
+type activeSideReplicationAndTriggerRemotePruneSequence struct {
 	state ActiveSideState

 	// valid for state ActiveSideReplicating, ActiveSidePruneSender, ActiveSidePruneReceiver, ActiveSideDone
 	replicationReport driver.ReportFunc
 	replicationCancel context.CancelFunc
+	replicationDone   *report.Report

 	// valid for state ActiveSidePruneSender, ActiveSidePruneReceiver, ActiveSideDone
-	prunerSender, prunerReceiver *pruner.Pruner
-
-	// valid for state ActiveSidePruneReceiver, ActiveSideDone
-	prunerSenderCancel, prunerReceiverCancel context.CancelFunc
+	pruneRemote *pruner.Pruner
+	pruneRemoteCancel context.CancelFunc
 }

 func (a *ActiveSide) updateTasks(u func(*activeSideTasks)) activeSideTasks {
@@ -93,7 +89,7 @@ type activeMode interface {
 	SenderReceiver() (logic.Sender, logic.Receiver)
 	Type() Type
 	PlannerPolicy() logic.PlannerPolicy
-	RunPeriodic(ctx context.Context, wakeReplication *trigger.Manual)
+	RunPeriodic(ctx context.Context, wakePeriodic <-chan struct{}, replicationCommon chan<- struct{})
 	SnapperReport() *snapper.Report
 	ResetConnectBackoff()
 }
@@ -104,7 +100,7 @@ type modePush struct {
 	receiver      *rpc.Client
 	senderConfig  *endpoint.SenderConfig
 	plannerPolicy *logic.PlannerPolicy
-	snapper       snapper.Snapper
+	snapper       *snapper.PeriodicOrManual
 }

 func (m *modePush) ConnectEndpoints(ctx context.Context, connecter transport.Connecter) {
@@ -135,13 +131,12 @@ func (m *modePush) Type() Type { return TypePush }

 func (m *modePush) PlannerPolicy() logic.PlannerPolicy { return *m.plannerPolicy }

-func (m *modePush) RunPeriodic(ctx context.Context, trigger *trigger.Manual) {
-	m.snapper.Run(ctx, trigger)
+func (m *modePush) RunPeriodic(ctx context.Context, wakePeriodic <-chan struct{}, replicationCommon chan<- struct{}) {
+	m.snapper.Run(ctx, replicationCommon)
 }

 func (m *modePush) SnapperReport() *snapper.Report {
-	r := m.snapper.Report()
-	return &r
+	return m.snapper.Report()
 }

 func (m *modePush) ResetConnectBackoff() {
@@ -166,13 +161,8 @@ func modePushFromConfig(g *config.Global, in *config.PushJob, jobID endpoint.Job
 		return nil, errors.Wrap(err, "field `replication`")
 	}

-	conflictResolution, err := logic.ConflictResolutionFromConfig(in.ConflictResolution)
-	if err != nil {
-		return nil, errors.Wrap(err, "field `conflict_resolution`")
-	}
-
 	m.plannerPolicy = &logic.PlannerPolicy{
-		ConflictResolution:        conflictResolution,
+		EncryptedSend:             logic.TriFromBool(in.Send.Encrypted),
 		ReplicationConfig:         replicationConfig,
 		SizeEstimationConcurrency: in.Replication.Concurrency.SizeEstimates,
 	}
@@ -224,10 +214,10 @@ func (*modePull) Type() Type { return TypePull }

 func (m *modePull) PlannerPolicy() logic.PlannerPolicy { return *m.plannerPolicy }

-func (m *modePull) RunPeriodic(ctx context.Context, wakeReplication *trigger.Manual) {
+func (m *modePull) RunPeriodic(ctx context.Context, wakePeriodic <-chan struct{}, replicationCommon chan<- struct{}) {
 	if m.interval.Manual {
 		GetLogger(ctx).Info("manual pull configured, periodic pull disabled")
-		// "waiting for wakeups" is printed in common ActiveSide.do
+		// "waiting for wakeup replications" is printed in common ActiveSide.do
 		return
 	}
 	t := time.NewTicker(m.interval.Interval)
@@ -235,7 +225,14 @@ func (m *modePull) RunPeriodic(ctx context.Context, wakeReplication *trigger.Man
 	for {
 		select {
 		case <-t.C:
-			wakeReplication.Fire()
+			select {
+			case replicationCommon <- struct{}{}:
+			default:
+				GetLogger(ctx).
+					WithField("pull_interval", m.interval).
+					Warn("pull job took longer than pull interval")
+				replicationCommon <- struct{}{} // block anyways, to queue up the wakeup replication
+			}
 		case <-ctx.Done():
 			return
 		}
@@ -263,13 +260,8 @@ func modePullFromConfig(g *config.Global, in *config.PullJob, jobID endpoint.Job
 		return nil, errors.Wrap(err, "field `replication`")
 	}

-	conflictResolution, err := logic.ConflictResolutionFromConfig(in.ConflictResolution)
-	if err != nil {
-		return nil, errors.Wrap(err, "field `conflict_resolution`")
-	}
-
 	m.plannerPolicy = &logic.PlannerPolicy{
-		ConflictResolution:        conflictResolution,
+		EncryptedSend:             logic.DontCare,
 		ReplicationConfig:         replicationConfig,
 		SizeEstimationConcurrency: in.Replication.Concurrency.SizeEstimates,
 	}
@@ -295,7 +287,7 @@ func replicationDriverConfigFromConfig(in *config.Replication) (c driver.Config,
 	return c, err
 }

-func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}, parseFlags config.ParseFlags) (j *ActiveSide, err error) {
+func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}) (j *ActiveSide, err error) {

 	j = &ActiveSide{}
 	j.name, err = endpoint.MakeJobID(in.Name)
@@ -329,6 +321,7 @@ func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}, p
 		Help:        "number of bytes replicated from sender to receiver per filesystem",
 		ConstLabels: prometheus.Labels{"zrepl_job": j.name.String()},
 	}, []string{"filesystem"})
+
 	j.promReplicationErrors = prometheus.NewGauge(prometheus.GaugeOpts{
 		Namespace:   "zrepl",
 		Subsystem:   "replication",
@@ -336,15 +329,8 @@ func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}, p
 		Help:        "number of filesystems that failed replication in the latest replication attempt, or -1 if the job failed before enumerating the filesystems",
 		ConstLabels: prometheus.Labels{"zrepl_job": j.name.String()},
 	})
-	j.promLastSuccessful = prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace:   "zrepl",
-		Subsystem:   "replication",
-		Name:        "last_successful",
-		Help:        "timestamp of last successful replication",
-		ConstLabels: prometheus.Labels{"zrepl_job": j.name.String()},
-	})

-	j.connecter, err = fromconfig.ConnecterFromConfig(g, in.Connect, parseFlags)
+	j.connecter, err = fromconfig.ConnecterFromConfig(g, in.Connect)
 	if err != nil {
 		return nil, errors.Wrap(err, "cannot build client")
 	}
@@ -366,11 +352,6 @@ func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}, p
 		return nil, errors.Wrap(err, "cannot build replication driver config")
 	}

-	j.triggers, err = trigger.FromConfig(in.Replication.Triggers)
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot build triggers")
-	}
-
 	return j, nil
 }

@@ -379,7 +360,6 @@ func (j *ActiveSide) RegisterMetrics(registerer prometheus.Registerer) {
 	registerer.MustRegister(j.promPruneSecs)
 	registerer.MustRegister(j.promBytesReplicated)
 	registerer.MustRegister(j.promReplicationErrors)
-	registerer.MustRegister(j.promLastSuccessful)
 }

 func (j *ActiveSide) Name() string { return j.name.String() }
@@ -445,60 +425,205 @@ func (j *ActiveSide) Run(ctx context.Context) {

 	defer log.Info("job exiting")

+	type Activity interface {
+		Trigger() (interface{}, error)
+	}
+
+	var periodicActivity Activity
+	var replicationActivity Activity
+	
+	periodicDone := make(chan struct{})
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
-
-	periodCtx, endTask := trace.WithTask(ctx, "periodic")
-	defer endTask()
-	go j.mode.RunPeriodic(periodCtx, periodicTrigger)
-
-	wakeupTrigger := wakeup.Trigger(ctx)
-
-	triggered, endTask := j.triggers.Spawn(ctx, []*trigger.Trigger{periodicTrigger, wakeupTrigger})
+	periodicCtx, endTask := trace.WithTask(ctx, "periodic")
 	defer endTask()

-	invocationCount := 0
-outer:
+	wakePeriodic := make(chan struct{})
+	go j.mode.RunPeriodic(periodicCtx, wakePeriodic, periodicDone)
+
+	j.trigger = make(chan struct{})
+	j.reset = make(chan uint64)
+	j.nextInvocationId = 1
+
+	type WaitTriggerResult interface {
+		
+	}
+	var t interface{
+		WaitForTrigger(context.Context) (context.Context, <-chan WaitTriggerResult)
+	}
+
 	for {
-		log.Info("wait for wakeups")
-		select {
-		case <-ctx.Done():
-			log.WithError(ctx.Err()).Info("context")
-			break outer
-		case trigger := <-triggered:
-			log :=
-				log.WithField("trigger_id", trigger.ID())
-			log.Info("triggered")
-			switch trigger {
-			case wakeupTrigger:
-				log.Info("trigger is wakeup command, resetting connection backoff")
-				j.mode.ResetConnectBackoff()
-			}
+		log.Info("wait for triggers")
+
+			// j.tasksMtx.Lock()
+		// j.activeInvocationId = j.nextInvocationId
+		// j.nextInvocationId++
+		// thisInvocation := j.activeInvocationId // stack-local, for use in reset-handler goroutine below
+		// j.tasksMtx.Unlock()
+		
+		// // setup the goroutine that waits for task resets
+		// // Task resets are converted into cancellations of the invocation context.
+		
+		invocationCtx, cancelInvocation := context.WithCancel(invocationCtx)
+		// waitForResetCtx, stopWaitForReset := context.WithCancel(ctx)
+		// var wg sync.WaitGroup
+		// wg.Add(1)
+		// go func() {
+		// 	defer wg.Done()
+		// 	select {
+		// 	case <-waitForResetCtx.Done():
+		// 		return
+		// 	case reqResetInvocation := <-j.reset:
+		// 		l := log.WithField("requested_invocation_id", reqResetInvocation).
+		// 			WithField("this_invocation_id", thisInvocation)
+		// 		if reqResetInvocation == thisInvocation {
+		// 			l.Info("reset received, cancelling current invocation")
+		// 			cancelInvocation()
+		// 		} else {
+		// 			l.Debug("received reset for invocation id that is not us, discarding request")
+		// 		}
+		// 	}
+		// }()
+
+		// j.tasksMtx.Lock()
+		// j.activeInvocationId = 0
+		// j.tasksMtx.Unlock()
+
+		invocationCtx, err := t.WaitForTrigger(ctx)
+		if err != nil {
+			log.WithError(ctx.Err()).Info("error waiting for trigger")
+			break
 		}
-		invocationCount++
-		invocationCtx, endSpan := trace.WithSpan(ctx, fmt.Sprintf("invocation-%d", invocationCount))
+
+		j.mode.ResetConnectBackoff()
+
+		// setup the invocation context
+		invocationCtx, endSpan := trace.WithSpan(invocationCtx, fmt.Sprintf("invocation-%d", j.nextInvocationId))
+		
+
 		j.do(invocationCtx)
+		stopWaitForReset()
+		wg.Wait()
+
+	
+
 		endSpan()
 	}
 }

+type ActiveSidePollRequest struct {
+	InvocationId uint64
+}
+
+type ActiveSidePollResponse struct {
+	Done         bool
+	InvocationId uint64
+}
+
+func (j *ActiveSide) Poll(req ActiveSidePollRequest) (*ActiveSidePollResponse, error) {
+	j.tasksMtx.Lock()
+	defer j.tasksMtx.Unlock()
+
+	waitForId := req.InvocationId
+	if req.InvocationId == 0 {
+		// handle the case where the client doesn't know what the current invocation id is
+		if j.activeInvocationId != 0 {
+			waitForId = j.activeInvocationId
+		} else {
+			waitForId = j.nextInvocationId
+		}
+	}
+
+	var done bool
+	if j.activeInvocationId == 0 {
+		done = waitForId < j.nextInvocationId
+	} else {
+		done = waitForId < j.activeInvocationId
+	}
+	res := &ActiveSidePollResponse{Done: done, InvocationId: waitForId}
+	return res, nil
+}
+
+type ActiveSideResetRequest struct {
+	InvocationId uint64
+}
+
+type ActiveSideResetResponse struct {
+	InvocationId uint64
+}
+
+func (j *ActiveSide) Reset(req ActiveSideResetRequest) (*ActiveSideResetResponse, error) {
+	j.tasksMtx.Lock()
+	defer j.tasksMtx.Unlock()
+
+	resetId := req.InvocationId
+	if req.InvocationId == 0 {
+		// handle the case where the client doesn't know what the current invocation id is
+		resetId = j.activeInvocationId
+	}
+
+	if resetId == 0 {
+		return nil, fmt.Errorf("no active invocation")
+	}
+
+	if resetId != j.activeInvocationId {
+		return nil, fmt.Errorf("active invocation (%d) is not the invocation requested for reset (%d); (active invocation '0' indicates no active invocation)", j.activeInvocationId, resetId)
+	}
+
+	// non-blocking send (.Run() must not hold mutex while waiting for resets)
+	select {
+	case j.reset <- resetId:
+	default:
+	}
+
+	return &ActiveSideResetResponse{InvocationId: resetId}, nil
+}
+
+type ActiveSideTriggerRequest struct {
+}
+
+type ActiveSideSignalResponse struct {
+	InvocationId uint64
+	
+}
+
+func (j *ActiveSide) Trigger(req ActiveSideTriggerRequest) (*ActiveSideSignalResponse, error) {
+	// switch req.What {
+	// case "replication":
+	// 	invocationId, err = j.jobs.doreplication(req.Name)
+	// case "reset":
+	// 	err = j.jobs.reset(req.Name)
+	// case "snapshot":
+	// 	err = j.jobs.dosnapshot(req.Name)
+	// default:
+	// 	err = fmt.Errorf("operation %q is invalid", req.Op)
+	// }
+
+	j.tasksMtx.Lock()
+	var invocationId uint64
+	if j.activeInvocationId != 0 {
+		invocationId = j.activeInvocationId
+	} else {
+		invocationId = j.nextInvocationId
+	}
+	// non-blocking send (.Run() must not hold mutex while waiting for signals)
+	select {
+	case j.trigger <- struct{}{}:
+	default:
+	}
+	j.tasksMtx.Unlock()
+	return &ActiveSideSignalResponse{InvocationId: invocationId}, nil
+}
+
+type ReplicationPlusRemotePruneSequence struct {
+
+}
+
 func (j *ActiveSide) do(ctx context.Context) {

 	j.mode.ConnectEndpoints(ctx, j.connecter)
 	defer j.mode.DisconnectEndpoints()

-	// allow cancellation of an invocation (this function)
-	ctx, cancelThisRun := context.WithCancel(ctx)
-	defer cancelThisRun()
-	go func() {
-		select {
-		case <-reset.Wait(ctx):
-			log.Info("reset received, cancelling current invocation")
-			cancelThisRun()
-		case <-ctx.Done():
-		}
-	}()
-
 	sender, receiver := j.mode.SenderReceiver()

 	{
@@ -522,14 +647,11 @@ func (j *ActiveSide) do(ctx context.Context) {
 		GetLogger(ctx).Info("start replication")
 		repWait(true) // wait blocking
 		repCancel()   // always cancel to free up context resources
-
 		replicationReport := j.tasks.replicationReport()
-		var numErrors = replicationReport.GetFailedFilesystemsCountInLatestAttempt()
-		j.promReplicationErrors.Set(float64(numErrors))
-		if numErrors == 0 {
-			j.promLastSuccessful.SetToCurrentTime()
-		}
-
+		j.promReplicationErrors.Set(float64(replicationReport.GetFailedFilesystemsCountInLatestAttempt()))
+		j.updateTasks(func(tasks *activeSideTasks) {
+			tasks.replicationDone = replicationReport
+		})
 		endSpan()
 	}

@@ -8,13 +8,12 @@ import (
 	"github.com/pkg/errors"

 	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/util/bandwidthlimit"
 )

-func JobsFromConfig(c *config.Config, parseFlags config.ParseFlags) ([]Job, error) {
+func JobsFromConfig(c *config.Config) ([]Job, error) {
 	js := make([]Job, len(c.Jobs))
 	for i := range c.Jobs {
-		j, err := buildJob(c.Global, c.Jobs[i], parseFlags)
+		j, err := buildJob(c.Global, c.Jobs[i])
 		if err != nil {
 			return nil, err
 		}
@@ -24,22 +23,37 @@ func JobsFromConfig(c *config.Config, parseFlags config.ParseFlags) ([]Job, erro
 		js[i] = j
 	}

+	// receiving-side root filesystems must not overlap
+	{
+		rfss := make([]string, 0, len(js))
+		for _, j := range js {
+			jrfs, ok := j.OwnedDatasetSubtreeRoot()
+			if !ok {
+				continue
+			}
+			rfss = append(rfss, jrfs.ToString())
+		}
+		if err := validateReceivingSidesDoNotOverlap(rfss); err != nil {
+			return nil, err
+		}
+	}
+
 	return js, nil
 }

-func buildJob(c *config.Global, in config.JobEnum, parseFlags config.ParseFlags) (j Job, err error) {
+func buildJob(c *config.Global, in config.JobEnum) (j Job, err error) {
 	cannotBuildJob := func(e error, name string) (Job, error) {
 		return nil, errors.Wrapf(e, "cannot build job %q", name)
 	}
 	// FIXME prettify this
 	switch v := in.Ret.(type) {
 	case *config.SinkJob:
-		j, err = passiveSideFromConfig(c, &v.PassiveJob, v, parseFlags)
+		j, err = passiveSideFromConfig(c, &v.PassiveJob, v)
 		if err != nil {
 			return cannotBuildJob(err, v.Name)
 		}
 	case *config.SourceJob:
-		j, err = passiveSideFromConfig(c, &v.PassiveJob, v, parseFlags)
+		j, err = passiveSideFromConfig(c, &v.PassiveJob, v)
 		if err != nil {
 			return cannotBuildJob(err, v.Name)
 		}
@@ -49,12 +63,12 @@ func buildJob(c *config.Global, in config.JobEnum, parseFlags config.ParseFlags)
 			return cannotBuildJob(err, v.Name)
 		}
 	case *config.PushJob:
-		j, err = activeSide(c, &v.ActiveJob, v, parseFlags)
+		j, err = activeSide(c, &v.ActiveJob, v)
 		if err != nil {
 			return cannotBuildJob(err, v.Name)
 		}
 	case *config.PullJob:
-		j, err = activeSide(c, &v.ActiveJob, v, parseFlags)
+		j, err = activeSide(c, &v.ActiveJob, v)
 		if err != nil {
 			return cannotBuildJob(err, v.Name)
 		}
@@ -93,13 +107,3 @@ func validateReceivingSidesDoNotOverlap(receivingRootFSs []string) error {
 	}
 	return nil
 }
-
-func buildBandwidthLimitConfig(in *config.BandwidthLimit) (c bandwidthlimit.Config, _ error) {
-	if in.Max.ToBytes() > 0 && int64(in.Max.ToBytes()) == 0 {
-		return c, fmt.Errorf("bandwidth limit `max` is too small, must at least specify one byte")
-	}
-	return bandwidthlimit.Config{
-		Max:            int64(in.Max.ToBytes()),
-		BucketCapacity: int64(in.BucketCapacity.ToBytes()),
-	}, nil
-}
@@ -22,12 +22,7 @@ func buildSenderConfig(in SendingJobConfig, jobID endpoint.JobID) (*endpoint.Sen
 		return nil, errors.Wrap(err, "cannot build filesystem filter")
 	}
 	sendOpts := in.GetSendOptions()
-	bwlim, err := buildBandwidthLimitConfig(sendOpts.BandwidthLimit)
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot build bandwith limit config")
-	}
-
-	sc := &endpoint.SenderConfig{
+	return &endpoint.SenderConfig{
 		FSF:   fsf,
 		JobID: jobID,

@@ -39,15 +34,7 @@ func buildSenderConfig(in SendingJobConfig, jobID endpoint.JobID) (*endpoint.Sen
 		SendCompressed:       sendOpts.Compressed,
 		SendEmbeddedData:     sendOpts.EmbeddedData,
 		SendSaved:            sendOpts.Saved,
-
-		BandwidthLimit: bwlim,
-	}
-
-	if err := sc.Validate(); err != nil {
-		return nil, errors.Wrap(err, "cannot build sender config")
-	}
-
-	return sc, nil
+	}, nil
 }

 type ReceivingJobConfig interface {
@@ -66,22 +53,6 @@ func buildReceiverConfig(in ReceivingJobConfig, jobID endpoint.JobID) (rc endpoi
 	}

 	recvOpts := in.GetRecvOptions()
-
-	bwlim, err := buildBandwidthLimitConfig(recvOpts.BandwidthLimit)
-	if err != nil {
-		return rc, errors.Wrap(err, "cannot build bandwith limit config")
-	}
-
-	placeholderEncryption, err := endpoint.PlaceholderCreationEncryptionPropertyString(recvOpts.Placeholder.Encryption)
-	if err != nil {
-		options := []string{}
-		for _, v := range endpoint.PlaceholderCreationEncryptionPropertyValues() {
-			options = append(options, endpoint.PlaceholderCreationEncryptionProperty(v).String())
-		}
-		return rc, errors.Errorf("placeholder encryption value %q is invalid, must be one of %s",
-			recvOpts.Placeholder.Encryption, options)
-	}
-
 	rc = endpoint.ReceiverConfig{
 		JobID:                      jobID,
 		RootWithoutClientComponent: rootFs,
@@ -89,10 +60,6 @@ func buildReceiverConfig(in ReceivingJobConfig, jobID endpoint.JobID) (rc endpoi

 		InheritProperties:  recvOpts.Properties.Inherit,
 		OverrideProperties: recvOpts.Properties.Override,
-
-		BandwidthLimit: bwlim,
-
-		PlaceholderEncryption: placeholderEncryption,
 	}
 	if err := rc.Validate(); err != nil {
 		return rc, errors.Wrap(err, "cannot build receiver config")
@@ -11,6 +11,7 @@ import (
 	"github.com/stretchr/testify/require"

 	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/transport/tls"
 )

 func TestValidateReceivingSidesDoNotOverlap(t *testing.T) {
@@ -95,7 +96,7 @@ jobs:
 			conf, err := config.ParseConfigBytes([]byte(fill(c.jobName)))
 			require.NoError(t, err, "not expecting yaml-config to know about job ids")
 			require.NotNil(t, conf)
-			jobs, err := JobsFromConfig(conf, config.ParseFlagsNone)
+			jobs, err := JobsFromConfig(conf)

 			if c.valid {
 				assert.NoError(t, err)
@@ -118,14 +119,6 @@ func TestSampleConfigsAreBuiltWithoutErrors(t *testing.T) {
 		t.Errorf("glob failed: %+v", err)
 	}

-	type additionalCheck struct {
-		state int
-		test  func(t *testing.T, jobs []Job)
-	}
-	additionalChecks := map[string]*additionalCheck{
-		"bandwidth_limit.yml": {test: testSampleConfig_BandwidthLimit},
-	}
-
 	for _, p := range paths {

 		if path.Ext(p) != ".yml" {
@@ -133,78 +126,23 @@ func TestSampleConfigsAreBuiltWithoutErrors(t *testing.T) {
 			continue
 		}

-		filename := path.Base(p)
-		t.Logf("checking for presence additonal checks for file %q", filename)
-		additionalCheck := additionalChecks[filename]
-		if additionalCheck == nil {
-			t.Logf("no additional checks")
-		} else {
-			t.Logf("additional check present")
-			additionalCheck.state = 1
-		}
-
 		t.Run(p, func(t *testing.T) {
 			c, err := config.ParseConfig(p)
 			if err != nil {
-				t.Fatalf("error parsing %s:\n%+v", p, err)
+				t.Errorf("error parsing %s:\n%+v", p, err)
 			}

 			t.Logf("file: %s", p)
 			t.Log(pretty.Sprint(c))

-			jobs, err := JobsFromConfig(c, config.ParseFlagsNoCertCheck)
+			tls.FakeCertificateLoading(t)
+			jobs, err := JobsFromConfig(c)
 			t.Logf("jobs: %#v", jobs)
-			require.NoError(t, err)
-
-			if additionalCheck != nil {
-				additionalCheck.test(t, jobs)
-				additionalCheck.state = 2
-			}
+			assert.NoError(t, err)
 		})

 	}

-	for basename, c := range additionalChecks {
-		if c.state == 0 {
-			panic("univisited additional check " + basename)
-		}
-	}
-
-}
-
-func testSampleConfig_BandwidthLimit(t *testing.T, jobs []Job) {
-	require.Len(t, jobs, 3)
-
-	{
-		limitedSink, ok := jobs[0].(*PassiveSide)
-		require.True(t, ok, "%T", jobs[0])
-		limitedSinkMode, ok := limitedSink.mode.(*modeSink)
-		require.True(t, ok, "%T", limitedSink)
-
-		assert.Equal(t, int64(12345), limitedSinkMode.receiverConfig.BandwidthLimit.Max)
-		assert.Equal(t, int64(1<<17), limitedSinkMode.receiverConfig.BandwidthLimit.BucketCapacity)
-	}
-
-	{
-		limitedPush, ok := jobs[1].(*ActiveSide)
-		require.True(t, ok, "%T", jobs[1])
-		limitedPushMode, ok := limitedPush.mode.(*modePush)
-		require.True(t, ok, "%T", limitedPush)
-
-		assert.Equal(t, int64(54321), limitedPushMode.senderConfig.BandwidthLimit.Max)
-		assert.Equal(t, int64(1024), limitedPushMode.senderConfig.BandwidthLimit.BucketCapacity)
-	}
-
-	{
-		unlimitedSink, ok := jobs[2].(*PassiveSide)
-		require.True(t, ok, "%T", jobs[2])
-		unlimitedSinkMode, ok := unlimitedSink.mode.(*modeSink)
-		require.True(t, ok, "%T", unlimitedSink)
-
-		max := unlimitedSinkMode.receiverConfig.BandwidthLimit.Max
-		assert.Less(t, max, int64(0), max, "unlimited mode <=> negative value for .Max, see bandwidthlimit.Config")
-	}
-
 }

 func TestReplicationOptions(t *testing.T) {
@@ -297,7 +235,7 @@ jobs:
 			t.Logf("testing config:\n%s", cstr)
 			c, err := config.ParseConfigBytes([]byte(cstr))
 			require.NoError(t, err)
-			jobs, err := JobsFromConfig(c, config.ParseFlagsNone)
+			jobs, err := JobsFromConfig(c)
 			if ts.expectOk != nil {
 				require.NoError(t, err)
 				require.NotNil(t, c)
@@ -19,6 +19,7 @@ func GetLogger(ctx context.Context) Logger {
 	return logging.GetLogger(ctx, logging.SubsysJob)
 }

+
 type Job interface {
 	Name() string
 	Run(ctx context.Context)
@@ -58,7 +58,7 @@ func modeSinkFromConfig(g *config.Global, in *config.SinkJob, jobID endpoint.Job

 type modeSource struct {
 	senderConfig *endpoint.SenderConfig
-	snapper      snapper.Snapper
+	snapper      *snapper.PeriodicOrManual
 }

 func modeSourceFromConfig(g *config.Global, in *config.SourceJob, jobID endpoint.JobID) (m *modeSource, err error) {
@@ -88,11 +88,10 @@ func (m *modeSource) RunPeriodic(ctx context.Context) {
 }

 func (m *modeSource) SnapperReport() *snapper.Report {
-	r := m.snapper.Report()
-	return &r
+	return m.snapper.Report()
 }

-func passiveSideFromConfig(g *config.Global, in *config.PassiveJob, configJob interface{}, parseFlags config.ParseFlags) (s *PassiveSide, err error) {
+func passiveSideFromConfig(g *config.Global, in *config.PassiveJob, configJob interface{}) (s *PassiveSide, err error) {

 	s = &PassiveSide{}

@@ -111,7 +110,7 @@ func passiveSideFromConfig(g *config.Global, in *config.PassiveJob, configJob in
 		return nil, err // no wrapping necessary
 	}

-	if s.listen, err = fromconfig.ListenerFactoryFromConfig(g, in.Serve, parseFlags); err != nil {
+	if s.listen, err = fromconfig.ListenerFactoryFromConfig(g, in.Serve); err != nil {
 		return nil, errors.Wrap(err, "cannot build listener factory")
 	}

@@ -1,35 +0,0 @@
-package reset
-
-import (
-	"context"
-	"errors"
-)
-
-type contextKey int
-
-const contextKeyReset contextKey = iota
-
-func Wait(ctx context.Context) <-chan struct{} {
-	wc, ok := ctx.Value(contextKeyReset).(chan struct{})
-	if !ok {
-		wc = make(chan struct{})
-	}
-	return wc
-}
-
-type Func func() error
-
-var AlreadyReset = errors.New("already reset")
-
-func Context(ctx context.Context) (context.Context, Func) {
-	wc := make(chan struct{})
-	wuf := func() error {
-		select {
-		case wc <- struct{}{}:
-			return nil
-		default:
-			return AlreadyReset
-		}
-	}
-	return context.WithValue(ctx, contextKeyReset, wc), wuf
-}
@@ -10,13 +10,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus"

 	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/util/bandwidthlimit"
 	"github.com/zrepl/zrepl/util/nodefault"

 	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/daemon/job/trigger"
-	"github.com/zrepl/zrepl/daemon/job/wakeup"
 	"github.com/zrepl/zrepl/daemon/pruner"
 	"github.com/zrepl/zrepl/daemon/snapper"
 	"github.com/zrepl/zrepl/endpoint"
@@ -27,7 +24,7 @@ import (
 type SnapJob struct {
 	name     endpoint.JobID
 	fsfilter zfs.DatasetFilter
-	snapper  snapper.Snapper
+	snapper  *snapper.PeriodicOrManual

 	prunerFactory *pruner.LocalPrunerFactory

@@ -87,8 +84,7 @@ func (j *SnapJob) Status() *Status {
 		s.Pruning = j.pruner.Report()
 	}
 	j.prunerMtx.Unlock()
-	r := j.snapper.Report()
-	s.Snapshotting = &r
+	s.Snapshotting = j.snapper.Report()
 	return &Status{Type: t, JobSpecific: s}
 }

@@ -105,28 +101,24 @@ func (j *SnapJob) Run(ctx context.Context) {

 	defer log.Info("job exiting")

-	wakeupTrigger := wakeup.Trigger(ctx)
-
-	snapshottingTrigger := trigger.New("periodic")
+	periodicDone := make(chan struct{})
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	periodicCtx, endTask := trace.WithTask(ctx, "snapshotting")
 	defer endTask()
-	go j.snapper.Run(periodicCtx, snapshottingTrigger)
-
-	triggers := trigger.Empty()
-	triggered, endTask := triggers.Spawn(ctx, []trigger.Trigger{snapshottingTrigger, wakeupTrigger})
-	defer endTask()
+	go j.snapper.Run(periodicCtx, periodicDone)

 	invocationCount := 0
 outer:
 	for {
-		log.Info("wait for wakeups")
+		log.Info("wait for replications")
 		select {
 		case <-ctx.Done():
 			log.WithError(ctx.Err()).Info("context")
 			break outer
-		case <-triggered:
+
+		// case <-doreplication.Wait(ctx):
+		case <-periodicDone:
 		}
 		invocationCount++

@@ -143,7 +135,7 @@ outer:
 // TODO:
 // This is a work-around for the current package daemon/pruner
 // and package pruning.Snapshot limitation: they require the
-// `Replicated` getter method be present, but obviously,
+//  `Replicated` getter method be present, but obviously,
 // a local job like SnapJob can't deliver on that.
 // But the pruner.Pruner gives up on an FS if no replication
 // cursor is present, which is why this pruner returns the
@@ -153,7 +145,7 @@ type alwaysUpToDateReplicationCursorHistory struct {
 	target pruner.Target
 }

-var _ pruner.Sender = (*alwaysUpToDateReplicationCursorHistory)(nil)
+var _ pruner.History = (*alwaysUpToDateReplicationCursorHistory)(nil)

 func (h alwaysUpToDateReplicationCursorHistory) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error) {
 	fsvReq := &pdu.ListFilesystemVersionsReq{
@@ -186,11 +178,8 @@ func (j *SnapJob) doPrune(ctx context.Context) {
 	sender := endpoint.NewSender(endpoint.SenderConfig{
 		JobID: j.name,
 		FSF:   j.fsfilter,
-		// FIXME the following config fields are irrelevant for SnapJob
-		// because the endpoint is only used as pruner.Target.
-		// However, the implementation requires them to be set.
-		Encrypt:        &nodefault.Bool{B: true},
-		BandwidthLimit: bandwidthlimit.NoLimitConfig(),
+		// FIXME encryption setting is irrelevant for SnapJob because the endpoint is only used as pruner.Target
+		Encrypt: &nodefault.Bool{B: true},
 	})
 	j.prunerMtx.Lock()
 	j.pruner = j.prunerFactory.BuildLocalPruner(ctx, sender, alwaysUpToDateReplicationCursorHistory{sender})
@@ -1,23 +0,0 @@
-package trigger
-
-import (
-	"context"
-
-	"github.com/robfig/cron/v3"
-)
-
-type Cron struct {
-	spec cron.Schedule
-}
-
-var _ Trigger = &Cron{}
-
-func NewCron(spec cron.Schedule) *Cron {
-	return &Cron{spec: spec}
-}
-
-func (t *Cron) ID() string { return "cron" }
-
-func (t *Cron) run(ctx context.Context, signal chan<- struct{}) {
-	panic("unimpl: extract from cron snapper")
-}
@@ -1,30 +0,0 @@
-package trigger
-
-import (
-	"fmt"
-
-	"github.com/zrepl/zrepl/config"
-)
-
-func FromConfig(in []*config.ReplicationTriggerEnum) (*Triggers, error) {
-	triggers := make([]Trigger, len(in))
-	for i, e := range in {
-		var t Trigger = nil
-		switch te := e.Ret.(type) {
-		case *config.ReplicationTriggerManual:
-			// not a trigger
-			t = NewManual("manual")
-		case *config.ReplicationTriggerPeriodic:
-			t = NewPeriodic(te.Interval.Duration())
-		case *config.ReplicationTriggerCron:
-			t = NewCron(te.Cron.Schedule)
-		default:
-			return nil, fmt.Errorf("unknown trigger type %T", te)
-		}
-		triggers[i] = t
-	}
-	return &Triggers{
-		spawned:  false,
-		triggers: triggers,
-	}, nil
-}
@@ -1,12 +0,0 @@
-package trigger
-
-import (
-	"context"
-
-	"github.com/zrepl/zrepl/logger"
-)
-
-
-func getLogger(ctx context.Context) logger.Logger {
-	panic("unimpl")
-}
@@ -1,33 +0,0 @@
-package trigger
-
-import "context"
-
-type Manual struct {
-	id     string
-	signal chan<- struct{}
-}
-
-var _ Trigger = &Manual{}
-
-func NewManual(id string) *Manual {
-	return &Manual{
-		id:     id,
-		signal: nil,
-	}
-}
-
-func (t *Manual) ID() string {
-	return t.id
-}
-
-func (t *Manual) run(ctx context.Context, signal chan<- struct{}) {
-	if t.signal != nil {
-		panic("run must only be called once")
-	}
-	t.signal = signal
-}
-
-// Panics if called before the trigger has been spanwed as part of a `Triggers`.
-func (t *Manual) Fire() {
-	t.signal <- struct{}{}
-}
@@ -1,33 +0,0 @@
-package trigger
-
-import (
-	"context"
-	"time"
-)
-
-type Periodic struct {
-	interval time.Duration
-}
-
-var _ Trigger = &Periodic{}
-
-func NewPeriodic(interval time.Duration) *Periodic {
-	return &Periodic{
-		interval: interval,
-	}
-}
-
-func (p *Periodic) ID() string { return "periodic" }
-
-func (p *Periodic) run(ctx context.Context, signal chan<- struct{}) {
-	t := time.NewTicker(p.interval)
-	defer t.Stop()
-	for {
-		select {
-		case <-t.C:
-			signal <- struct{}{}
-		case <-ctx.Done():
-			return
-		}
-	}
-}
@@ -1,91 +1,184 @@
+//
+//
+// Alternative Design (in "RustGo")
+//
+//	enum InternalMsg {
+//	    Trigger((), chan (TriggerResponse, error)),
+//	    Poll(PollRequest, chan PollResponse),
+//	    Reset(ResetRequest, chan (ResetResponse, error)),
+//	}
+//
+//	enum State {
+//	    Running{
+//	        invocationId: u32,
+//	        cancelCurrentInvocation: context.CancelFunc
+//	    }
+//	    Waiting{
+//	        nextInvocationId: u32,
+//	    }
+//	}
+//
+//	for msg := <- t.internalMsgs {
+//	    match (msg, state) {
+//	        ...
+//	    }
+//	}
 package trigger

 import (
 	"context"
-	"github.com/zrepl/zrepl/daemon/logging/trace"
+	"fmt"
+	"math"
+	"sync"
 )

-type Triggers struct {
-	spawned  bool
-	triggers []Trigger
+type T struct {
+	mtx sync.Mutex
+	cv  sync.Cond
+
+	nextInvocationId        uint64
+	activeInvocationId      uint64 // 0 <=> inactive
+	triggerPending          bool
+	contextDone             bool
+	reset                   chan uint64
+	stopWaitForReset        chan struct{}
+	cancelCurrentInvocation context.CancelFunc
 }

-type Trigger interface {
-	ID() string
-	run(context.Context, chan<- struct{})
-}
-
-func Empty() *Triggers {
-	return &Triggers{
-		spawned:  false,
-		triggers: nil,
+func New() *T {
+	t := &T{
+		activeInvocationId: math.MaxUint64,
+		nextInvocationId:   1,
 	}
+	t.cv.L = &t.mtx
+	return t
 }

-func (t *Triggers) Spawn(ctx context.Context, additionalTriggers []Trigger) (chan Trigger, trace.DoneFunc) {
-	if t.spawned {
-		panic("must only spawn once")
+func (t *T) WaitForTrigger(ctx context.Context) (rctx context.Context, err error) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+
+	if t.activeInvocationId == 0 {
+		return nil, fmt.Errorf("must be running when calling this function")
 	}
-	t.spawned = true
-	t.triggers = append(t.triggers, additionalTriggers...)
-	sink := make(chan Trigger)
-	endTask := t.spawn(ctx, sink)
-	return sink, endTask
-}
+	t.activeInvocationId = 0
+	t.cancelCurrentInvocation = nil

-type triggering struct {
-	trigger Trigger
-	handled chan struct{}
-}
-
-func (t *Triggers) spawn(ctx context.Context, sink chan Trigger) trace.DoneFunc {
-	ctx, endTask := trace.WithTask(ctx, "triggers")
-	ctx, add, wait := trace.WithTaskGroup(ctx, "trigger-tasks")
-	triggered := make(chan triggering, len(t.triggers))
-	for _, t := range t.triggers {
-		t := t
-		signal := make(chan struct{})
-		go add(func(ctx context.Context) {
-			t.run(ctx, signal)
-		})
-		go func() {
-			for {
-				select {
-				case <-ctx.Done():
-					return
-				case <-signal:
-					handled := make(chan struct{})
-					select {
-					case triggered <- triggering{trigger: t, handled: handled}:
-					default:
-						panic("this funtion ensures that there's always room in the channel")
-					}
-					select {
-					case <-handled:
-					case <-ctx.Done():
-						return
-					}
-				}
-			}
-		}()
+	if t.contextDone == true {
+		panic("implementation error: this variable is only true while in WaitForTrigger, and that's a mutually exclusive function")
 	}
+	stopWaitingForDone := make(chan struct{})
 	go func() {
-		defer wait()
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case triggering := <-triggered:
-				select {
-				case sink <- triggering.trigger:
-				default:
-					getLogger(ctx).
-						WithField("trigger_id", triggering.trigger.ID()).
-						Warn("dropping triggering because job is busy")
-				}
-				close(triggering.handled)
-			}
+		select {
+		case <-stopWaitingForDone:
+		case <-ctx.Done():
+			t.mtx.Lock()
+			t.contextDone = true
+			t.cv.Broadcast()
+			t.mtx.Unlock()
 		}
 	}()
-	return endTask
+
+	defer func() {
+		t.triggerPending = false
+		t.contextDone = false
+	}()
+	for !t.triggerPending && !t.contextDone {
+		t.cv.Wait()
+	}
+	close(stopWaitingForDone)
+	if t.contextDone {
+		if ctx.Err() == nil {
+			panic("implementation error: contextDone <=> ctx.Err() != nil")
+		}
+		return nil, ctx.Err()
+	}
+
+	t.activeInvocationId = t.nextInvocationId
+	t.nextInvocationId++
+	rctx, t.cancelCurrentInvocation = context.WithCancel(ctx)
+
+	return rctx, nil
+}
+
+type TriggerResponse struct {
+	InvocationId uint64
+}
+
+func (t *T) Trigger() (TriggerResponse, error) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	var invocationId uint64
+	if t.activeInvocationId != 0 {
+		invocationId = t.activeInvocationId
+	} else {
+		invocationId = t.nextInvocationId
+	}
+	// non-blocking send (.Run() must not hold mutex while waiting for signals)
+	t.triggerPending = true
+	t.cv.Broadcast()
+	return TriggerResponse{InvocationId: invocationId}, nil
+}
+
+type PollRequest struct {
+	InvocationId uint64
+}
+
+type PollResponse struct {
+	Done         bool
+	InvocationId uint64
+}
+
+func (t *T) Poll(req PollRequest) (res PollResponse) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+
+	waitForId := req.InvocationId
+	if req.InvocationId == 0 {
+		// handle the case where the client doesn't know what the current invocation id is
+		if t.activeInvocationId != 0 {
+			waitForId = t.activeInvocationId
+		} else {
+			waitForId = t.nextInvocationId
+		}
+	}
+
+	var done bool
+	if t.activeInvocationId == 0 {
+		done = waitForId < t.nextInvocationId
+	} else {
+		done = waitForId < t.activeInvocationId
+	}
+	return PollResponse{Done: done, InvocationId: waitForId}
+}
+
+type ResetRequest struct {
+	InvocationId uint64
+}
+
+type ResetResponse struct {
+	InvocationId uint64
+}
+
+func (t *T) Reset(req ResetRequest) (*ResetResponse, error) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+
+	resetId := req.InvocationId
+	if req.InvocationId == 0 {
+		// handle the case where the client doesn't know what the current invocation id is
+		resetId = t.activeInvocationId
+	}
+
+	if resetId == 0 {
+		return nil, fmt.Errorf("no active invocation")
+	}
+
+	if resetId != t.activeInvocationId {
+		return nil, fmt.Errorf("active invocation (%d) is not the invocation requested for reset (%d); (active invocation '0' indicates no active invocation)", t.activeInvocationId, resetId)
+	}
+
+	t.cancelCurrentInvocation()
+
+	return &ResetResponse{InvocationId: resetId}, nil
 }
@@ -0,0 +1,205 @@
+package trigger_test
+
+import (
+	"context"
+	"net/http"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/zrepl/zrepl/daemon/job/trigger"
+	"github.com/zrepl/zrepl/daemon/logging/trace"
+	"github.com/zrepl/zrepl/replication"
+	"github.com/zrepl/zrepl/replication/driver"
+	"github.com/zrepl/zrepl/replication/logic"
+)
+
+func TestBasics(t *testing.T) {
+
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	tr := trigger.New()
+
+	triggered := make(chan int)
+	waitForTriggerError := make(chan error)
+	waitForResetCallToBeMadeByMainGoroutine := make(chan struct{})
+	postResetAssertionsDone := make(chan struct{})
+
+	taskCtx := context.Background()
+	taskCtx, cancelTaskCtx := context.WithCancel(taskCtx)
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		taskCtx := context.WithValue(taskCtx, "mykey", "myvalue")
+
+		triggers := 0
+
+	outer:
+		for {
+			invocationCtx, err := tr.WaitForTrigger(taskCtx)
+			if err != nil {
+				waitForTriggerError <- err
+				return
+			}
+			require.Equal(t, invocationCtx.Value("mykey"), "myvalue")
+
+			triggers++
+			triggered <- triggers
+
+			switch triggers {
+			case 1:
+				continue outer
+			case 2:
+				<-waitForResetCallToBeMadeByMainGoroutine
+				require.Equal(t, context.Canceled, invocationCtx.Err(), "Reset() cancels invocation context")
+				require.Nil(t, taskCtx.Err(), "Reset() does not cancel task context")
+				close(postResetAssertionsDone)
+			}
+
+		}
+
+	}()
+
+	t.Logf("trigger 1")
+	_, err := tr.Trigger()
+	require.NoError(t, err)
+	v := <-triggered
+	require.Equal(t, 1, v)
+
+	t.Logf("trigger 2")
+	triggerResponse, err := tr.Trigger()
+	require.NoError(t, err)
+	v = <-triggered
+	require.Equal(t, 2, v)
+
+	t.Logf("reset")
+	resetResponse, err := tr.Reset(trigger.ResetRequest{InvocationId: triggerResponse.InvocationId})
+	require.NoError(t, err)
+	t.Logf("reset response: %#v", resetResponse)
+	close(waitForResetCallToBeMadeByMainGoroutine)
+	<-postResetAssertionsDone
+
+	t.Logf("cancel the context")
+	cancelTaskCtx()
+	wfte := <-waitForTriggerError
+	require.Equal(t, taskCtx.Err(), wfte)
+
+}
+
+type PushJob struct {
+	snap *Snapshotter
+	repl *ReplicationAndTriggerRemotePruningSequence
+}
+
+func (j *PushJob) Handle(w http.ResponseWriter, r *http.Request) {
+	panic("unimplemented")
+}
+
+func (j *PushJob) HandleTrigger(w http.ResponseWriter, r *http.Request) {
+	panic("unimplemented")
+}
+
+func (j *PushJob) Run(ctx context.Context) {
+
+}
+
+type SnapshotSequence struct {
+
+}
+
+type ReplicationAndTriggerRemotePruningSequence struct {
+
+}
+
+func (s ReplicationAndTriggerRemotePruningSequence) Run(ctx context.Context) {
+
+	j.mode.ConnectEndpoints(ctx, j.connecter)
+	defer j.mode.DisconnectEndpoints()
+
+	sender, receiver := j.mode.SenderReceiver()
+
+	{
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		ctx, endSpan := trace.WithSpan(ctx, "replication")
+		ctx, repCancel := context.WithCancel(ctx)
+		var repWait driver.WaitFunc
+		j.updateTasks(func(tasks *activeSideTasks) {
+			// reset it
+			*tasks = activeSideTasks{}
+			tasks.replicationCancel = func() { repCancel(); endSpan() }
+			tasks.replicationReport, repWait = replication.Do(
+				ctx, j.replicationDriverConfig, logic.NewPlanner(j.promRepStateSecs, j.promBytesReplicated, sender, receiver, j.mode.PlannerPolicy()),
+			)
+			tasks.state = ActiveSideReplicating
+		})
+		GetLogger(ctx).Info("start replication")
+		repWait(true) // wait blocking
+		repCancel()   // always cancel to free up context resources
+		replicationReport := j.tasks.replicationReport()
+		j.promReplicationErrors.Set(float64(replicationReport.GetFailedFilesystemsCountInLatestAttempt()))
+		j.updateTasks(func(tasks *activeSideTasks) {
+			tasks.replicationDone = replicationReport
+		})
+		endSpan()
+	}
+
+	{
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		ctx, endSpan := trace.WithSpan(ctx, "prune_sender")
+		ctx, senderCancel := context.WithCancel(ctx)
+		tasks := j.updateTasks(func(tasks *activeSideTasks) {
+			tasks.prunerSender = j.prunerFactory.BuildSenderPruner(ctx, sender, sender)
+			tasks.prunerSenderCancel = func() { senderCancel(); endSpan() }
+			tasks.state = ActiveSidePruneSender
+		})
+		GetLogger(ctx).Info("start pruning sender")
+		tasks.prunerSender.Prune()
+		GetLogger(ctx).Info("finished pruning sender")
+		senderCancel()
+		endSpan()
+	}
+	{
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		ctx, endSpan := trace.WithSpan(ctx, "prune_recever")
+		ctx, receiverCancel := context.WithCancel(ctx)
+		tasks := j.updateTasks(func(tasks *activeSideTasks) {
+			tasks.prunerReceiver = j.prunerFactory.BuildReceiverPruner(ctx, receiver, sender)
+			tasks.prunerReceiverCancel = func() { receiverCancel(); endSpan() }
+			tasks.state = ActiveSidePruneReceiver
+		})
+		GetLogger(ctx).Info("start pruning receiver")
+		tasks.prunerReceiver.Prune()
+		GetLogger(ctx).Info("finished pruning receiver")
+		receiverCancel()
+		endSpan()
+	}
+
+	j.updateTasks(func(tasks *activeSideTasks) {
+		tasks.state = ActiveSideDone
+	})
+
+}
+
+
+func TestUseCase(t *testing.T) {
+
+	var as ActiveSide
+
+	as.
+	
+}
@@ -1,41 +0,0 @@
-package wakeup
-
-import (
-	"context"
-	"errors"
-
-	"github.com/zrepl/zrepl/daemon/job/trigger"
-)
-
-type contextKey int
-
-const contextKeyWakeup contextKey = iota
-
-func Wait(ctx context.Context) <-chan struct{} {
-	wc, ok := ctx.Value(contextKeyWakeup).(chan struct{})
-	if !ok {
-		wc = make(chan struct{})
-	}
-	return wc
-}
-
-func Trigger(ctx context.Context) trigger.Trigger {
-	panic("unimpl")
-}
-
-type Func func() error
-
-var AlreadyWokenUp = errors.New("already woken up")
-
-func Context(ctx context.Context) (context.Context, Func) {
-	wc := make(chan struct{})
-	wuf := func() error {
-		select {
-		case wc <- struct{}{}:
-			return nil
-		default:
-			return AlreadyWokenUp
-		}
-	}
-	return context.WithValue(ctx, contextKeyWakeup, wc), wuf
-}
@@ -63,7 +63,6 @@ type Subsystem string
 const (
 	SubsysMeta         Subsystem = "meta"
 	SubsysJob          Subsystem = "job"
-	SubsysTrigger      Subsystem = "trigger"
 	SubsysReplication  Subsystem = "repl"
 	SubsysEndpoint     Subsystem = "endpoint"
 	SubsysPruning      Subsystem = "pruning"
@@ -1,6 +1,6 @@
 // package trace provides activity tracing via ctx through Tasks and Spans
 //
-// # Basic Concepts
+// Basic Concepts
 //
 // Tracing can be used to identify where a piece of code spends its time.
 //
@@ -10,50 +10,51 @@
 // to tech-savvy users (albeit not developers).
 //
 // This package provides the concept of Tasks and Spans to express what activity is happening within an application:
-// - Neither task nor span is really tangible but instead contained within the context.Context tree
-// - Tasks represent concurrent activity (i.e. goroutines).
-// - Spans represent a semantic stack trace within a task.
+//
+//  - Neither task nor span is really tangible but instead contained within the context.Context tree
+//  - Tasks represent concurrent activity (i.e. goroutines).
+//  - Spans represent a semantic stack trace within a task.
+//
 // As a consequence, whenever a context is propagated across goroutine boundary, you need to create a child task:
 //
-//	go func(ctx context.Context) {
-//	  ctx, endTask = WithTask(ctx, "what-happens-inside-the-child-task")
-//	  defer endTask()
-//	  // ...
-//	}(ctx)
+//   go func(ctx context.Context) {
+//     ctx, endTask = WithTask(ctx, "what-happens-inside-the-child-task")
+//     defer endTask()
+//     // ...
+//   }(ctx)
 //
 // Within the task, you can open up a hierarchy of spans.
 // In contrast to tasks, which have can multiple concurrently running child tasks,
 // spans must nest and not cross the goroutine boundary.
 //
-//	ctx, endSpan = WithSpan(ctx, "copy-dir")
-//	defer endSpan()
-//	for _, f := range dir.Files() {
-//	  func() {
-//	    ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
-//	    defer endspan()
-//	    b, _ := ioutil.ReadFile(f)
-//	    _ = ioutil.WriteFile(f + ".copy", b, 0600)
-//	  }()
-//	}
+//  ctx, endSpan = WithSpan(ctx, "copy-dir")
+//  defer endSpan()
+//  for _, f := range dir.Files() {
+//    func() {
+//      ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
+//      defer endspan()
+//      b, _ := ioutil.ReadFile(f)
+//      _ = ioutil.WriteFile(f + ".copy", b, 0600)
+//    }()
+//  }
 //
 // In combination:
-//
-//	ctx, endTask = WithTask(ctx, "copy-dirs")
-//	defer endTask()
-//	for i := range dirs {
-//	  go func(dir string) {
-//	    ctx, endTask := WithTask(ctx, "copy-dir")
-//	    defer endTask()
-//	    for _, f := range filesIn(dir) {
-//	      func() {
-//	        ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
-//	        defer endspan()
-//	        b, _ := ioutil.ReadFile(f)
-//	        _ = ioutil.WriteFile(f + ".copy", b, 0600)
-//	      }()
-//	    }
-//	  }()
-//	}
+//  ctx, endTask = WithTask(ctx, "copy-dirs")
+//  defer endTask()
+//  for i := range dirs {
+//    go func(dir string) {
+//      ctx, endTask := WithTask(ctx, "copy-dir")
+//      defer endTask()
+//      for _, f := range filesIn(dir) {
+//        func() {
+//          ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
+//          defer endspan()
+//          b, _ := ioutil.ReadFile(f)
+//          _ = ioutil.WriteFile(f + ".copy", b, 0600)
+//        }()
+//      }
+//    }()
+//  }
 //
 // Note that a span ends at the time you call endSpan - not before and not after that.
 // If you violate the stack-like nesting of spans by forgetting an endSpan() invocation,
@@ -64,7 +65,8 @@
 //
 // Recovering from endSpan() or endTask() panics will corrupt the trace stack and lead to corrupt tracefile output.
 //
-// # Best Practices For Naming Tasks And Spans
+//
+// Best Practices For Naming Tasks And Spans
 //
 // Tasks should always have string constants as names, and must not contain the `#` character. WHy?
 // First, the visualization by chrome://tracing draws a horizontal bar for each task in the trace.
@@ -72,7 +74,8 @@
 // Note that the `#NUM` suffix will be reused if a task has ended, in order to avoid an
 // infinite number of horizontal bars in the visualization.
 //
-// # Chrome-compatible Tracefile Support
+//
+// Chrome-compatible Tracefile Support
 //
 // The activity trace generated by usage of WithTask and WithSpan can be rendered to a JSON output file
 // that can be loaded into chrome://tracing .
@@ -243,7 +246,7 @@ func WithTask(ctx context.Context, taskName string) (context.Context, DoneFunc)
 					// the debugString can be quite long and panic won't print it completely
 					fmt.Fprintf(os.Stderr, "going to panic due to activeChildTasks:\n%s\n", this.debugString())
 				}
-				panic(errors.WithMessagef(ErrTaskStillHasActiveChildTasks, "end task: %v active child tasks (run daemon with env var %s=1 for more details)\n", this.activeChildTasks, debugEnabledEnvVar))
+				panic(errors.WithMessagef(ErrTaskStillHasActiveChildTasks, "end task: %v active child tasks\n", this.activeChildTasks))
 			}

 			// support idempotent task ends
@@ -11,6 +11,8 @@ import (
 // use like this:
 //
 //	defer WithSpanFromStackUpdateCtx(&existingCtx)()
+//
+//
 func WithSpanFromStackUpdateCtx(ctx *context.Context) DoneFunc {
 	childSpanCtx, end := WithSpan(*ctx, getMyCallerOrPanic())
 	*ctx = childSpanCtx
@@ -7,9 +7,7 @@ import (
 	"github.com/zrepl/zrepl/util/envconst"
 )

-const debugEnabledEnvVar = "ZREPL_TRACE_DEBUG_ENABLED"
-
-var debugEnabled = envconst.Bool(debugEnabledEnvVar, false)
+var debugEnabled = envconst.Bool("ZREPL_TRACE_DEBUG_ENABLED", false)

 func debug(format string, args ...interface{}) {
 	if !debugEnabled {
@@ -19,20 +19,12 @@ import (
 	"github.com/zrepl/zrepl/util/envconst"
 )

-// The sender in the replication setup.
-// The pruner uses the Sender to determine which of the Target's filesystems need to be pruned.
-// Also, it asks the Sender about the replication cursor of each filesystem
-// to enable the 'not_replicated' pruning rule.
-//
 // Try to keep it compatible with github.com/zrepl/zrepl/endpoint.Endpoint
-type Sender interface {
+type History interface {
 	ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error)
 	ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error)
 }

-// The pruning target, i.e., on which snapshots are destroyed.
-// This can be a replication sender or receiver.
-//
 // Try to keep it compatible with github.com/zrepl/zrepl/endpoint.Endpoint
 type Target interface {
 	ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error)
@@ -56,7 +48,7 @@ func GetLogger(ctx context.Context) Logger {
 type args struct {
 	ctx                            context.Context
 	target                         Target
-	sender                         Sender
+	receiver                       History
 	rules                          []pruning.KeepRule
 	retryWait                      time.Duration
 	considerSnapAtCursorReplicated bool
@@ -140,12 +132,12 @@ func NewPrunerFactory(in config.PruningSenderReceiver, promPruneSecs *prometheus
 	return f, nil
 }

-func (f *PrunerFactory) BuildSenderPruner(ctx context.Context, target Target, sender Sender) *Pruner {
+func (f *PrunerFactory) BuildSenderPruner(ctx context.Context, target Target, receiver History) *Pruner {
 	p := &Pruner{
 		args: args{
 			context.WithValue(ctx, contextKeyPruneSide, "sender"),
 			target,
-			sender,
+			receiver,
 			f.senderRules,
 			f.retryWait,
 			f.considerSnapAtCursorReplicated,
@@ -156,12 +148,12 @@ func (f *PrunerFactory) BuildSenderPruner(ctx context.Context, target Target, se
 	return p
 }

-func (f *PrunerFactory) BuildReceiverPruner(ctx context.Context, target Target, sender Sender) *Pruner {
+func (f *PrunerFactory) BuildReceiverPruner(ctx context.Context, target Target, receiver History) *Pruner {
 	p := &Pruner{
 		args: args{
 			context.WithValue(ctx, contextKeyPruneSide, "receiver"),
 			target,
-			sender,
+			receiver,
 			f.receiverRules,
 			f.retryWait,
 			false, // senseless here anyways
@@ -172,12 +164,12 @@ func (f *PrunerFactory) BuildReceiverPruner(ctx context.Context, target Target,
 	return p
 }

-func (f *LocalPrunerFactory) BuildLocalPruner(ctx context.Context, target Target, history Sender) *Pruner {
+func (f *LocalPrunerFactory) BuildLocalPruner(ctx context.Context, target Target, receiver History) *Pruner {
 	p := &Pruner{
 		args: args{
 			context.WithValue(ctx, contextKeyPruneSide, "local"),
 			target,
-			history,
+			receiver,
 			f.keepRules,
 			f.retryWait,
 			false, // considerSnapAtCursorReplicated is not relevant for local pruning
@@ -199,16 +191,6 @@ const (
 	Done
 )

-// Returns true in case the State is a terminal state(PlanErr, ExecErr, Done)
-func (s State) IsTerminal() bool {
-	switch s {
-	case PlanErr, ExecErr, Done:
-		return true
-	default:
-		return false
-	}
-}
-
 type updater func(func(*Pruner))

 func (p *Pruner) Prune() {
@@ -361,9 +343,9 @@ func (s snapshot) Date() time.Time { return s.date }

 func doOneAttempt(a *args, u updater) {

-	ctx, target, sender := a.ctx, a.target, a.sender
+	ctx, target, receiver := a.ctx, a.target, a.receiver

-	sfssres, err := sender.ListFilesystems(ctx, &pdu.ListFilesystemReq{})
+	sfssres, err := receiver.ListFilesystems(ctx, &pdu.ListFilesystemReq{})
 	if err != nil {
 		u(func(p *Pruner) {
 			p.state = PlanErr
@@ -428,7 +410,7 @@ tfss_loop:
 		rcReq := &pdu.ReplicationCursorReq{
 			Filesystem: tfs.Path,
 		}
-		rc, err := sender.ReplicationCursor(ctx, rcReq)
+		rc, err := receiver.ReplicationCursor(ctx, rcReq)
 		if err != nil {
 			pfsPlanErrAndLog(err, "cannot get replication cursor bookmark")
 			continue tfss_loop
@@ -474,7 +456,7 @@ tfss_loop:
 			})
 		}
 		if preCursor {
-			pfsPlanErrAndLog(fmt.Errorf("prune target has no snapshot that corresponds to sender replication cursor bookmark"), "")
+			pfsPlanErrAndLog(fmt.Errorf("replication cursor not found in prune target filesystem versions"), "")
 			continue tfss_loop
 		}

@@ -1,147 +0,0 @@
-package snapper
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/pkg/errors"
-
-	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon/hooks"
-	"github.com/zrepl/zrepl/daemon/job/trigger"
-	"github.com/zrepl/zrepl/util/suspendresumesafetimer"
-	"github.com/zrepl/zrepl/zfs"
-)
-
-func cronFromConfig(fsf zfs.DatasetFilter, in config.SnapshottingCron) (*Cron, error) {
-
-	hooksList, err := hooks.ListFromConfig(&in.Hooks)
-	if err != nil {
-		return nil, errors.Wrap(err, "hook config error")
-	}
-	planArgs := planArgs{
-		prefix:          in.Prefix,
-		timestampFormat: in.TimestampFormat,
-		hooks:           hooksList,
-	}
-	return &Cron{config: in, fsf: fsf, planArgs: planArgs}, nil
-}
-
-type Cron struct {
-	config   config.SnapshottingCron
-	fsf      zfs.DatasetFilter
-	planArgs planArgs
-
-	mtx sync.RWMutex
-
-	running                 bool
-	wakeupTime              time.Time // zero value means uninit
-	lastError               error
-	lastPlan                *plan
-	wakeupWhileRunningCount int
-}
-
-func (s *Cron) Run(ctx context.Context, snapshotsTaken *trigger.Manual) {
-
-	for {
-		now := time.Now()
-		s.mtx.Lock()
-		s.wakeupTime = s.config.Cron.Schedule.Next(now)
-		s.mtx.Unlock()
-
-		ctxDone := suspendresumesafetimer.SleepUntil(ctx, s.wakeupTime)
-		if ctxDone != nil {
-			return
-		}
-
-		getLogger(ctx).Debug("cron timer fired")
-		s.mtx.Lock()
-		if s.running {
-			getLogger(ctx).Warn("snapshotting triggered according to cron rules but previous snapshotting is not done; not taking a snapshot this time")
-			s.wakeupWhileRunningCount++
-			s.mtx.Unlock()
-			continue
-		}
-		s.lastError = nil
-		s.lastPlan = nil
-		s.wakeupWhileRunningCount = 0
-		s.running = true
-		s.mtx.Unlock()
-		go func() {
-			err := s.do(ctx)
-			s.mtx.Lock()
-			s.lastError = err
-			s.running = false
-			s.mtx.Unlock()
-
-			snapshotsTaken.Fire()
-		}()
-	}
-
-}
-
-func (s *Cron) do(ctx context.Context) error {
-	fss, err := zfs.ZFSListMapping(ctx, s.fsf)
-	if err != nil {
-		return errors.Wrap(err, "cannot list filesystems")
-	}
-	p := makePlan(s.planArgs, fss)
-
-	s.mtx.Lock()
-	s.lastPlan = p
-	s.lastError = nil
-	s.mtx.Unlock()
-
-	ok := p.execute(ctx, false)
-	if !ok {
-		return errors.New("one or more snapshots could not be created, check logs for details")
-	} else {
-		return nil
-	}
-}
-
-type CronState string
-
-const (
-	CronStateRunning CronState = "running"
-	CronStateWaiting CronState = "waiting"
-)
-
-type CronReport struct {
-	State      CronState
-	WakeupTime time.Time
-	Errors     []string
-	Progress   []*ReportFilesystem
-}
-
-func (s *Cron) Report() Report {
-
-	s.mtx.Lock()
-	defer s.mtx.Unlock()
-
-	r := CronReport{}
-
-	r.WakeupTime = s.wakeupTime
-
-	if s.running {
-		r.State = CronStateRunning
-	} else {
-		r.State = CronStateWaiting
-	}
-
-	if s.lastError != nil {
-		r.Errors = append(r.Errors, s.lastError.Error())
-	}
-	if s.wakeupWhileRunningCount > 0 {
-		r.Errors = append(r.Errors, fmt.Sprintf("cron frequency is too high; snapshots were not taken %d times", s.wakeupWhileRunningCount))
-	}
-
-	r.Progress = nil
-	if s.lastPlan != nil {
-		r.Progress = s.lastPlan.report()
-	}
-
-	return Report{Type: TypeCron, Cron: &r}
-}
@@ -1,68 +0,0 @@
-package snapper
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zrepl/yaml-config"
-
-	"github.com/zrepl/zrepl/config"
-)
-
-func TestCronLibraryWorks(t *testing.T) {
-
-	type testCase struct {
-		spec   string
-		in     time.Time
-		expect time.Time
-	}
-	dhm := func(day, hour, minutes int) time.Time {
-		return time.Date(2022, 7, day, hour, minutes, 0, 0, time.UTC)
-	}
-	hm := func(hour, minutes int) time.Time {
-		return dhm(23, hour, minutes)
-	}
-
-	tcs := []testCase{
-		{"0-10 * * * *", dhm(17, 1, 10), dhm(17, 2, 0)},
-		{"0-10 * * * *", dhm(17, 23, 10), dhm(18, 0, 0)},
-		{"0-10 * * * *", hm(1, 9), hm(1, 10)},
-		{"0-10 * * * *", hm(1, 9), hm(1, 10)},
-
-		{"1,3,5 * * * *", hm(1, 1), hm(1, 3)},
-		{"1,3,5 * * * *", hm(1, 2), hm(1, 3)},
-		{"1,3,5 * * * *", hm(1, 3), hm(1, 5)},
-		{"1,3,5 * * * *", hm(1, 5), hm(2, 1)},
-
-		{"* 0-5,8,12 * * *", hm(0, 0), hm(0, 1)},
-		{"* 0-5,8,12 * * *", hm(4, 59), hm(5, 0)},
-		{"* 0-5,8,12 * * *", hm(5, 0), hm(5, 1)},
-		{"* 0-5,8,12 * * *", hm(5, 59), hm(8, 0)},
-		{"* 0-5,8,12 * * *", hm(8, 59), hm(12, 0)},
-
-		// https://github.com/zrepl/zrepl/pull/614#issuecomment-1188358989
-		{"53 17,18,19 * * *", dhm(23, 17, 52), dhm(23, 17, 53)},
-		{"53 17,18,19 * * *", dhm(23, 17, 53), dhm(23, 18, 53)},
-		{"53 17,18,19 * * *", dhm(23, 18, 53), dhm(23, 19, 53)},
-		{"53 17,18,19 * * *", dhm(23, 19, 53), dhm(24 /* ! */, 17, 53)},
-	}
-
-	for i, tc := range tcs {
-		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
-			var s struct {
-				Cron config.CronSpec `yaml:"cron"`
-			}
-			inp := fmt.Sprintf("cron: %q", tc.spec)
-			fmt.Println("spec is ", inp)
-			err := yaml.UnmarshalStrict([]byte(inp), &s)
-			require.NoError(t, err)
-
-			actual := s.Cron.Schedule.Next(tc.in)
-			assert.Equal(t, tc.expect, actual)
-		})
-	}
-
-}
@@ -1,268 +0,0 @@
-package snapper
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/zrepl/zrepl/daemon/hooks"
-	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/util/chainlock"
-	"github.com/zrepl/zrepl/zfs"
-)
-
-type planArgs struct {
-	prefix          string
-	timestampFormat string
-	hooks           *hooks.List
-}
-
-type plan struct {
-	mtx   chainlock.L
-	args  planArgs
-	snaps map[*zfs.DatasetPath]*snapProgress
-}
-
-func makePlan(args planArgs, fss []*zfs.DatasetPath) *plan {
-	snaps := make(map[*zfs.DatasetPath]*snapProgress, len(fss))
-	for _, fs := range fss {
-		snaps[fs] = &snapProgress{state: SnapPending}
-	}
-	return &plan{snaps: snaps, args: args}
-}
-
-//go:generate stringer -type=SnapState
-type SnapState uint
-
-const (
-	SnapPending SnapState = 1 << iota
-	SnapStarted
-	SnapDone
-	SnapError
-)
-
-// All fields protected by Snapper.mtx
-type snapProgress struct {
-	state SnapState
-
-	// SnapStarted, SnapDone, SnapError
-	name     string
-	startAt  time.Time
-	hookPlan *hooks.Plan
-
-	// SnapDone
-	doneAt time.Time
-
-	// SnapErr TODO disambiguate state
-	runResults hooks.PlanReport
-}
-
-func (plan *plan) formatNow(format string) string {
-	now := time.Now().UTC()
-	switch strings.ToLower(format) {
-	case "dense":
-		format = "20060102_150405_000"
-	case "human":
-		format = "2006-01-02_15:04:05"
-	case "iso-8601":
-		format = "2006-01-02T15:04:05.000Z"
-	case "unix-seconds":
-		return strconv.FormatInt(now.Unix(), 10)
-	}
-	return now.Format(format)
-}
-
-func (plan *plan) execute(ctx context.Context, dryRun bool) (ok bool) {
-
-	hookMatchCount := make(map[hooks.Hook]int, len(*plan.args.hooks))
-	for _, h := range *plan.args.hooks {
-		hookMatchCount[h] = 0
-	}
-
-	anyFsHadErr := false
-	// TODO channel programs -> allow a little jitter?
-	for fs, progress := range plan.snaps {
-		suffix := plan.formatNow(plan.args.timestampFormat)
-		snapname := fmt.Sprintf("%s%s", plan.args.prefix, suffix)
-
-		ctx := logging.WithInjectedField(ctx, "fs", fs.ToString())
-		ctx = logging.WithInjectedField(ctx, "snap", snapname)
-
-		hookEnvExtra := hooks.Env{
-			hooks.EnvFS:       fs.ToString(),
-			hooks.EnvSnapshot: snapname,
-		}
-
-		jobCallback := hooks.NewCallbackHookForFilesystem("snapshot", fs, func(ctx context.Context) (err error) {
-			l := getLogger(ctx)
-			l.Debug("create snapshot")
-			err = zfs.ZFSSnapshot(ctx, fs, snapname, false) // TODO propagate context to ZFSSnapshot
-			if err != nil {
-				l.WithError(err).Error("cannot create snapshot")
-			}
-			return
-		})
-
-		fsHadErr := false
-		var hookPlanReport hooks.PlanReport
-		var hookPlan *hooks.Plan
-		{
-			filteredHooks, err := plan.args.hooks.CopyFilteredForFilesystem(fs)
-			if err != nil {
-				getLogger(ctx).WithError(err).Error("unexpected filter error")
-				fsHadErr = true
-				goto updateFSState
-			}
-			// account for running hooks
-			for _, h := range filteredHooks {
-				hookMatchCount[h] = hookMatchCount[h] + 1
-			}
-
-			var planErr error
-			hookPlan, planErr = hooks.NewPlan(&filteredHooks, hooks.PhaseSnapshot, jobCallback, hookEnvExtra)
-			if planErr != nil {
-				fsHadErr = true
-				getLogger(ctx).WithError(planErr).Error("cannot create job hook plan")
-				goto updateFSState
-			}
-		}
-
-		plan.mtx.HoldWhile(func() {
-			progress.name = snapname
-			progress.startAt = time.Now()
-			progress.hookPlan = hookPlan
-			progress.state = SnapStarted
-		})
-
-		{
-			getLogger(ctx).WithField("report", hookPlan.Report().String()).Debug("begin run job plan")
-			hookPlan.Run(ctx, dryRun)
-			hookPlanReport = hookPlan.Report()
-			fsHadErr = hookPlanReport.HadError() // not just fatal errors
-			if fsHadErr {
-				getLogger(ctx).WithField("report", hookPlanReport.String()).Error("end run job plan with error")
-			} else {
-				getLogger(ctx).WithField("report", hookPlanReport.String()).Info("end run job plan successful")
-			}
-		}
-
-	updateFSState:
-		anyFsHadErr = anyFsHadErr || fsHadErr
-		plan.mtx.HoldWhile(func() {
-			progress.doneAt = time.Now()
-			progress.state = SnapDone
-			if fsHadErr {
-				progress.state = SnapError
-			}
-			progress.runResults = hookPlanReport
-		})
-	}
-
-	for h, mc := range hookMatchCount {
-		if mc == 0 {
-			hookIdx := -1
-			for idx, ah := range *plan.args.hooks {
-				if ah == h {
-					hookIdx = idx
-					break
-				}
-			}
-			getLogger(ctx).WithField("hook", h.String()).WithField("hook_number", hookIdx+1).Warn("hook did not match any snapshotted filesystems")
-		}
-	}
-
-	return !anyFsHadErr
-}
-
-type ReportFilesystem struct {
-	Path  string
-	State SnapState
-
-	// Valid in SnapStarted and later
-	SnapName      string
-	StartAt       time.Time
-	Hooks         string
-	HooksHadError bool
-
-	// Valid in SnapDone | SnapError
-	DoneAt time.Time
-}
-
-func (plan *plan) report() []*ReportFilesystem {
-	plan.mtx.Lock()
-	defer plan.mtx.Unlock()
-
-	pReps := make([]*ReportFilesystem, 0, len(plan.snaps))
-	for fs, p := range plan.snaps {
-		var hooksStr string
-		var hooksHadError bool
-		if p.hookPlan != nil {
-			hooksStr, hooksHadError = p.report()
-		}
-		pReps = append(pReps, &ReportFilesystem{
-			Path:          fs.ToString(),
-			State:         p.state,
-			SnapName:      p.name,
-			StartAt:       p.startAt,
-			DoneAt:        p.doneAt,
-			Hooks:         hooksStr,
-			HooksHadError: hooksHadError,
-		})
-	}
-
-	sort.Slice(pReps, func(i, j int) bool {
-		return strings.Compare(pReps[i].Path, pReps[j].Path) == -1
-	})
-
-	return pReps
-}
-
-func (p *snapProgress) report() (hooksStr string, hooksHadError bool) {
-	hr := p.hookPlan.Report()
-	// FIXME: technically this belongs into client
-	// but we can't serialize hooks.Step ATM
-	rightPad := func(str string, length int, pad string) string {
-		if len(str) > length {
-			return str[:length]
-		}
-		return str + strings.Repeat(pad, length-len(str))
-	}
-	hooksHadError = hr.HadError()
-	rows := make([][]string, len(hr))
-	const numCols = 4
-	lens := make([]int, numCols)
-	for i, e := range hr {
-		rows[i] = make([]string, numCols)
-		rows[i][0] = fmt.Sprintf("%d", i+1)
-		rows[i][1] = e.Status.String()
-		runTime := "..."
-		if e.Status != hooks.StepPending {
-			runTime = e.End.Sub(e.Begin).Round(time.Millisecond).String()
-		}
-		rows[i][2] = runTime
-		rows[i][3] = ""
-		if e.Report != nil {
-			rows[i][3] = e.Report.String()
-		}
-		for j, col := range lens {
-			if len(rows[i][j]) > col {
-				lens[j] = len(rows[i][j])
-			}
-		}
-	}
-	rowsFlat := make([]string, len(hr))
-	for i, r := range rows {
-		colsPadded := make([]string, len(r))
-		for j, c := range r[:len(r)-1] {
-			colsPadded[j] = rightPad(c, lens[j], " ")
-		}
-		colsPadded[len(r)-1] = r[len(r)-1]
-		rowsFlat[i] = strings.Join(colsPadded, " ")
-	}
-	hooksStr = strings.Join(rowsFlat, "\n")
-
-	return hooksStr, hooksHadError
-}
@@ -1,17 +0,0 @@
-package snapper
-
-import (
-	"context"
-
-	"github.com/zrepl/zrepl/daemon/job/trigger"
-)
-
-type manual struct{}
-
-func (s *manual) Run(ctx context.Context, snapshotsTaken *trigger.Manual) {
-	// nothing to do
-}
-
-func (s *manual) Report() Report {
-	return Report{Type: TypeManual, Manual: &struct{}{}}
-}
@@ -1,389 +0,0 @@
-package snapper
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/pkg/errors"
-
-	"github.com/zrepl/zrepl/daemon/job/trigger"
-	"github.com/zrepl/zrepl/daemon/logging/trace"
-
-	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon/hooks"
-	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/util/envconst"
-	"github.com/zrepl/zrepl/util/suspendresumesafetimer"
-	"github.com/zrepl/zrepl/zfs"
-)
-
-func periodicFromConfig(g *config.Global, fsf zfs.DatasetFilter, in *config.SnapshottingPeriodic) (*Periodic, error) {
-	if in.Prefix == "" {
-		return nil, errors.New("prefix must not be empty")
-	}
-	if in.Interval.Duration() <= 0 {
-		return nil, errors.New("interval must be positive")
-	}
-
-	hookList, err := hooks.ListFromConfig(&in.Hooks)
-	if err != nil {
-		return nil, errors.Wrap(err, "hook config error")
-	}
-
-	args := periodicArgs{
-		interval: in.Interval.Duration(),
-		fsf:      fsf,
-		planArgs: planArgs{
-			prefix:          in.Prefix,
-			timestampFormat: in.TimestampFormat,
-			hooks:           hookList,
-		},
-		// ctx and log is set in Run()
-	}
-
-	return &Periodic{state: SyncUp, args: args}, nil
-}
-
-type periodicArgs struct {
-	ctx            context.Context
-	interval       time.Duration
-	fsf            zfs.DatasetFilter
-	planArgs       planArgs
-	snapshotsTaken *trigger.Manual
-	dryRun         bool
-}
-
-type Periodic struct {
-	args periodicArgs
-
-	mtx   sync.Mutex
-	state State
-
-	// set in state Plan, used in Waiting
-	lastInvocation time.Time
-
-	// valid for state Snapshotting
-	plan *plan
-
-	// valid for state SyncUp and Waiting
-	sleepUntil time.Time
-
-	// valid for state Err
-	err error
-}
-
-//go:generate stringer -type=State
-type State uint
-
-const (
-	SyncUp State = 1 << iota
-	SyncUpErrWait
-	Planning
-	Snapshotting
-	Waiting
-	ErrorWait
-	Stopped
-)
-
-func (s State) sf() state {
-	m := map[State]state{
-		SyncUp:        periodicStateSyncUp,
-		SyncUpErrWait: periodicStateWait,
-		Planning:      periodicStatePlan,
-		Snapshotting:  periodicStateSnapshot,
-		Waiting:       periodicStateWait,
-		ErrorWait:     periodicStateWait,
-		Stopped:       nil,
-	}
-	return m[s]
-}
-
-type updater func(u func(*Periodic)) State
-type state func(a periodicArgs, u updater) state
-
-func (s *Periodic) Run(ctx context.Context, snapshotsTaken *trigger.Manual) {
-	defer trace.WithSpanFromStackUpdateCtx(&ctx)()
-	getLogger(ctx).Debug("start")
-	defer getLogger(ctx).Debug("stop")
-
-	s.args.snapshotsTaken = snapshotsTaken
-	s.args.ctx = ctx
-	s.args.dryRun = false // for future expansion
-
-	u := func(u func(*Periodic)) State {
-		s.mtx.Lock()
-		defer s.mtx.Unlock()
-		if u != nil {
-			u(s)
-		}
-		return s.state
-	}
-
-	var st state = periodicStateSyncUp
-
-	for st != nil {
-		pre := u(nil)
-		st = st(s.args, u)
-		post := u(nil)
-		getLogger(ctx).
-			WithField("transition", fmt.Sprintf("%s=>%s", pre, post)).
-			Debug("state transition")
-
-	}
-
-}
-
-func onErr(err error, u updater) state {
-	return u(func(s *Periodic) {
-		s.err = err
-		preState := s.state
-		switch s.state {
-		case SyncUp:
-			s.state = SyncUpErrWait
-		case Planning:
-			fallthrough
-		case Snapshotting:
-			s.state = ErrorWait
-		}
-		getLogger(s.args.ctx).WithError(err).WithField("pre_state", preState).WithField("post_state", s.state).Error("snapshotting error")
-	}).sf()
-}
-
-func onMainCtxDone(ctx context.Context, u updater) state {
-	return u(func(s *Periodic) {
-		s.err = ctx.Err()
-		s.state = Stopped
-	}).sf()
-}
-
-func periodicStateSyncUp(a periodicArgs, u updater) state {
-	u(func(snapper *Periodic) {
-		snapper.lastInvocation = time.Now()
-	})
-	fss, err := listFSes(a.ctx, a.fsf)
-	if err != nil {
-		return onErr(err, u)
-	}
-	syncPoint, err := findSyncPoint(a.ctx, fss, a.planArgs.prefix, a.interval)
-	if err != nil {
-		return onErr(err, u)
-	}
-	u(func(s *Periodic) {
-		s.sleepUntil = syncPoint
-	})
-	ctxDone := suspendresumesafetimer.SleepUntil(a.ctx, syncPoint)
-	if ctxDone != nil {
-		return onMainCtxDone(a.ctx, u)
-	}
-	return u(func(s *Periodic) {
-		s.state = Planning
-	}).sf()
-}
-
-func periodicStatePlan(a periodicArgs, u updater) state {
-	u(func(snapper *Periodic) {
-		snapper.lastInvocation = time.Now()
-	})
-	fss, err := listFSes(a.ctx, a.fsf)
-	if err != nil {
-		return onErr(err, u)
-	}
-	p := makePlan(a.planArgs, fss)
-	return u(func(s *Periodic) {
-		s.state = Snapshotting
-		s.plan = p
-		s.err = nil
-	}).sf()
-}
-
-func periodicStateSnapshot(a periodicArgs, u updater) state {
-
-	var plan *plan
-	u(func(snapper *Periodic) {
-		plan = snapper.plan
-	})
-
-	ok := plan.execute(a.ctx, false)
-
-	a.snapshotsTaken.Fire()
-
-	return u(func(snapper *Periodic) {
-		if !ok {
-			snapper.state = ErrorWait
-			snapper.err = errors.New("one or more snapshots could not be created, check logs for details")
-		} else {
-			snapper.state = Waiting
-			snapper.err = nil
-		}
-	}).sf()
-}
-
-func periodicStateWait(a periodicArgs, u updater) state {
-	var sleepUntil time.Time
-	u(func(snapper *Periodic) {
-		lastTick := snapper.lastInvocation
-		snapper.sleepUntil = lastTick.Add(a.interval)
-		sleepUntil = snapper.sleepUntil
-		log := getLogger(a.ctx).WithField("sleep_until", sleepUntil).WithField("duration", a.interval)
-		logFunc := log.Debug
-		if snapper.state == ErrorWait || snapper.state == SyncUpErrWait {
-			logFunc = log.Error
-		}
-		logFunc("enter wait-state after error")
-	})
-
-	ctxDone := suspendresumesafetimer.SleepUntil(a.ctx, sleepUntil)
-	if ctxDone != nil {
-		return onMainCtxDone(a.ctx, u)
-	}
-	return u(func(snapper *Periodic) {
-		snapper.state = Planning
-	}).sf()
-}
-
-func listFSes(ctx context.Context, mf zfs.DatasetFilter) (fss []*zfs.DatasetPath, err error) {
-	return zfs.ZFSListMapping(ctx, mf)
-}
-
-var syncUpWarnNoSnapshotUntilSyncupMinDuration = envconst.Duration("ZREPL_SNAPPER_SYNCUP_WARN_MIN_DURATION", 1*time.Second)
-
-// see docs/snapshotting.rst
-func findSyncPoint(ctx context.Context, fss []*zfs.DatasetPath, prefix string, interval time.Duration) (syncPoint time.Time, err error) {
-
-	const (
-		prioHasVersions int = iota
-		prioNoVersions
-	)
-
-	type snapTime struct {
-		ds   *zfs.DatasetPath
-		prio int // lower is higher
-		time time.Time
-	}
-
-	if len(fss) == 0 {
-		return time.Now(), nil
-	}
-
-	snaptimes := make([]snapTime, 0, len(fss))
-	hardErrs := 0
-
-	now := time.Now()
-
-	getLogger(ctx).Debug("examine filesystem state to find sync point")
-	for _, d := range fss {
-		ctx := logging.WithInjectedField(ctx, "fs", d.ToString())
-		syncPoint, err := findSyncPointFSNextOptimalSnapshotTime(ctx, now, interval, prefix, d)
-		if err == findSyncPointFSNoFilesystemVersionsErr {
-			snaptimes = append(snaptimes, snapTime{
-				ds:   d,
-				prio: prioNoVersions,
-				time: now,
-			})
-		} else if err != nil {
-			hardErrs++
-			getLogger(ctx).WithError(err).Error("cannot determine optimal sync point for this filesystem")
-		} else {
-			getLogger(ctx).WithField("syncPoint", syncPoint).Debug("found optimal sync point for this filesystem")
-			snaptimes = append(snaptimes, snapTime{
-				ds:   d,
-				prio: prioHasVersions,
-				time: syncPoint,
-			})
-		}
-	}
-
-	if hardErrs == len(fss) {
-		return time.Time{}, fmt.Errorf("hard errors in determining sync point for every matching filesystem")
-	}
-
-	if len(snaptimes) == 0 {
-		panic("implementation error: loop must either inc hardErrs or add result to snaptimes")
-	}
-
-	// sort ascending by (prio,time)
-	// => those filesystems with versions win over those without any
-	sort.Slice(snaptimes, func(i, j int) bool {
-		if snaptimes[i].prio == snaptimes[j].prio {
-			return snaptimes[i].time.Before(snaptimes[j].time)
-		}
-		return snaptimes[i].prio < snaptimes[j].prio
-	})
-
-	winnerSyncPoint := snaptimes[0].time
-	l := getLogger(ctx).WithField("syncPoint", winnerSyncPoint.String())
-	l.Info("determined sync point")
-	if winnerSyncPoint.Sub(now) > syncUpWarnNoSnapshotUntilSyncupMinDuration {
-		for _, st := range snaptimes {
-			if st.prio == prioNoVersions {
-				l.WithField("fs", st.ds.ToString()).Warn("filesystem will not be snapshotted until sync point")
-			}
-		}
-	}
-
-	return snaptimes[0].time, nil
-
-}
-
-var findSyncPointFSNoFilesystemVersionsErr = fmt.Errorf("no filesystem versions")
-
-func findSyncPointFSNextOptimalSnapshotTime(ctx context.Context, now time.Time, interval time.Duration, prefix string, d *zfs.DatasetPath) (time.Time, error) {
-
-	fsvs, err := zfs.ZFSListFilesystemVersions(ctx, d, zfs.ListFilesystemVersionsOptions{
-		Types:           zfs.Snapshots,
-		ShortnamePrefix: prefix,
-	})
-	if err != nil {
-		return time.Time{}, errors.Wrap(err, "list filesystem versions")
-	}
-	if len(fsvs) <= 0 {
-		return time.Time{}, findSyncPointFSNoFilesystemVersionsErr
-	}
-
-	// Sort versions by creation
-	sort.SliceStable(fsvs, func(i, j int) bool {
-		return fsvs[i].CreateTXG < fsvs[j].CreateTXG
-	})
-
-	latest := fsvs[len(fsvs)-1]
-	getLogger(ctx).WithField("creation", latest.Creation).Debug("found latest snapshot")
-
-	since := now.Sub(latest.Creation)
-	if since < 0 {
-		return time.Time{}, fmt.Errorf("snapshot %q is from the future: creation=%q now=%q", latest.ToAbsPath(d), latest.Creation, now)
-	}
-
-	return latest.Creation.Add(interval), nil
-}
-
-type PeriodicReport struct {
-	State State
-	// valid in state SyncUp and Waiting
-	SleepUntil time.Time
-	// valid in state Err
-	Error string
-	// valid in state Snapshotting
-	Progress []*ReportFilesystem
-}
-
-func (s *Periodic) Report() Report {
-	s.mtx.Lock()
-	defer s.mtx.Unlock()
-
-	var progress []*ReportFilesystem = nil
-	if s.plan != nil {
-		progress = s.plan.report()
-	}
-
-	r := &PeriodicReport{
-		State:      s.state,
-		SleepUntil: s.sleepUntil,
-		Error:      errOrEmptyString(s.err),
-		Progress:   progress,
-	}
-
-	return Report{Type: TypePeriodic, Periodic: r}
-}
@@ -3,41 +3,505 @@ package snapper
 import (
 	"context"
 	"fmt"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/pkg/errors"
+
+	"github.com/zrepl/zrepl/daemon/logging/trace"

 	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon/job/trigger"
+	"github.com/zrepl/zrepl/daemon/hooks"
+	"github.com/zrepl/zrepl/daemon/logging"
+	"github.com/zrepl/zrepl/logger"
+	"github.com/zrepl/zrepl/util/envconst"
 	"github.com/zrepl/zrepl/zfs"
 )

-type Type string
+//go:generate stringer -type=SnapState
+type SnapState uint

 const (
-	TypePeriodic Type = "periodic"
-	TypeCron     Type = "cron"
-	TypeManual   Type = "manual"
+	SnapPending SnapState = 1 << iota
+	SnapStarted
+	SnapDone
+	SnapError
 )

-type Snapper interface {
-	Run(ctx context.Context, snapshotsTaken *trigger.Manual)
-	Report() Report
+// All fields protected by Snapper.mtx
+type snapProgress struct {
+	state SnapState
+
+	// SnapStarted, SnapDone, SnapError
+	name     string
+	startAt  time.Time
+	hookPlan *hooks.Plan
+
+	// SnapDone
+	doneAt time.Time
+
+	// SnapErr TODO disambiguate state
+	runResults hooks.PlanReport
 }

-type Report struct {
-	Type     Type
-	Periodic *PeriodicReport
-	Cron     *CronReport
-	Manual   *struct{}
+type args struct {
+	ctx            context.Context
+	prefix         string
+	interval       time.Duration
+	fsf            zfs.DatasetFilter
+	snapshotsTaken chan<- struct{}
+	hooks          *hooks.List
+	dryRun         bool
 }

-func FromConfig(g *config.Global, fsf zfs.DatasetFilter, in config.SnapshottingEnum) (Snapper, error) {
-	switch v := in.Ret.(type) {
-	case *config.SnapshottingPeriodic:
-		return periodicFromConfig(g, fsf, v)
-	case *config.SnapshottingCron:
-		return cronFromConfig(fsf, *v)
-	case *config.SnapshottingManual:
-		return &manual{}, nil
-	default:
-		return nil, fmt.Errorf("unknown snapshotting type %T", v)
+type Snapper struct {
+	args args
+
+	mtx   sync.Mutex
+	state State
+
+	// set in state Plan, used in Waiting
+	lastInvocation time.Time
+
+	// valid for state Snapshotting
+	plan map[*zfs.DatasetPath]*snapProgress
+
+	// valid for state SyncUp and Waiting
+	sleepUntil time.Time
+
+	// valid for state Err
+	err error
+}
+
+//go:generate stringer -type=State
+type State uint
+
+const (
+	SyncUp State = 1 << iota
+	SyncUpErrWait
+	Planning
+	Snapshotting
+	Waiting
+	ErrorWait
+	Stopped
+)
+
+func (s State) sf() state {
+	m := map[State]state{
+		SyncUp:        syncUp,
+		SyncUpErrWait: wait,
+		Planning:      plan,
+		Snapshotting:  snapshot,
+		Waiting:       wait,
+		ErrorWait:     wait,
+		Stopped:       nil,
+	}
+	return m[s]
+}
+
+type updater func(u func(*Snapper)) State
+type state func(a args, u updater) state
+
+type Logger = logger.Logger
+
+func getLogger(ctx context.Context) Logger {
+	return logging.GetLogger(ctx, logging.SubsysSnapshot)
+}
+
+func PeriodicFromConfig(g *config.Global, fsf zfs.DatasetFilter, in *config.SnapshottingPeriodic) (*Snapper, error) {
+	if in.Prefix == "" {
+		return nil, errors.New("prefix must not be empty")
+	}
+	if in.Interval <= 0 {
+		return nil, errors.New("interval must be positive")
+	}
+
+	hookList, err := hooks.ListFromConfig(&in.Hooks)
+	if err != nil {
+		return nil, errors.Wrap(err, "hook config error")
+	}
+
+	args := args{
+		prefix:   in.Prefix,
+		interval: in.Interval,
+		fsf:      fsf,
+		hooks:    hookList,
+		// ctx and log is set in Run()
+	}
+
+	return &Snapper{state: SyncUp, args: args}, nil
+}
+
+func (s *Snapper) Run(ctx context.Context, snapshotsTaken chan<- struct{}) {
+	defer trace.WithSpanFromStackUpdateCtx(&ctx)()
+	getLogger(ctx).Debug("start")
+	defer getLogger(ctx).Debug("stop")
+
+	s.args.snapshotsTaken = snapshotsTaken
+	s.args.ctx = ctx
+	s.args.dryRun = false // for future expansion
+
+	u := func(u func(*Snapper)) State {
+		s.mtx.Lock()
+		defer s.mtx.Unlock()
+		if u != nil {
+			u(s)
+		}
+		return s.state
+	}
+
+	var st state = syncUp
+
+	for st != nil {
+		pre := u(nil)
+		st = st(s.args, u)
+		post := u(nil)
+		getLogger(ctx).
+			WithField("transition", fmt.Sprintf("%s=>%s", pre, post)).
+			Debug("state transition")
+
+	}
+
+}
+
+func onErr(err error, u updater) state {
+	return u(func(s *Snapper) {
+		s.err = err
+		preState := s.state
+		switch s.state {
+		case SyncUp:
+			s.state = SyncUpErrWait
+		case Planning:
+			fallthrough
+		case Snapshotting:
+			s.state = ErrorWait
+		}
+		getLogger(s.args.ctx).WithError(err).WithField("pre_state", preState).WithField("post_state", s.state).Error("snapshotting error")
+	}).sf()
+}
+
+func onMainCtxDone(ctx context.Context, u updater) state {
+	return u(func(s *Snapper) {
+		s.err = ctx.Err()
+		s.state = Stopped
+	}).sf()
+}
+
+func syncUp(a args, u updater) state {
+	u(func(snapper *Snapper) {
+		snapper.lastInvocation = time.Now()
+	})
+	fss, err := listFSes(a.ctx, a.fsf)
+	if err != nil {
+		return onErr(err, u)
+	}
+	syncPoint, err := findSyncPoint(a.ctx, fss, a.prefix, a.interval)
+	if err != nil {
+		return onErr(err, u)
+	}
+	u(func(s *Snapper) {
+		s.sleepUntil = syncPoint
+	})
+	t := time.NewTimer(time.Until(syncPoint))
+	defer t.Stop()
+	select {
+	case <-t.C:
+		return u(func(s *Snapper) {
+			s.state = Planning
+		}).sf()
+	// case <-dosnapshot.Wait(a.ctx):
+	// 	return u(func(s *Snapper) {
+	// 		s.state = Planning
+	// 	}).sf()
+	case <-a.ctx.Done():
+		return onMainCtxDone(a.ctx, u)
 	}
 }
+
+func plan(a args, u updater) state {
+	u(func(snapper *Snapper) {
+		snapper.lastInvocation = time.Now()
+	})
+	fss, err := listFSes(a.ctx, a.fsf)
+	if err != nil {
+		return onErr(err, u)
+	}
+
+	plan := make(map[*zfs.DatasetPath]*snapProgress, len(fss))
+	for _, fs := range fss {
+		plan[fs] = &snapProgress{state: SnapPending}
+	}
+	return u(func(s *Snapper) {
+		s.state = Snapshotting
+		s.plan = plan
+		s.err = nil
+	}).sf()
+}
+
+func snapshot(a args, u updater) state {
+
+	var plan map[*zfs.DatasetPath]*snapProgress
+	u(func(snapper *Snapper) {
+		plan = snapper.plan
+	})
+
+	hookMatchCount := make(map[hooks.Hook]int, len(*a.hooks))
+	for _, h := range *a.hooks {
+		hookMatchCount[h] = 0
+	}
+
+	anyFsHadErr := false
+	// TODO channel programs -> allow a little jitter?
+	for fs, progress := range plan {
+		suffix := time.Now().In(time.UTC).Format("20060102_150405_000")
+		snapname := fmt.Sprintf("%s%s", a.prefix, suffix)
+
+		ctx := logging.WithInjectedField(a.ctx, "fs", fs.ToString())
+		ctx = logging.WithInjectedField(ctx, "snap", snapname)
+
+		hookEnvExtra := hooks.Env{
+			hooks.EnvFS:       fs.ToString(),
+			hooks.EnvSnapshot: snapname,
+		}
+
+		jobCallback := hooks.NewCallbackHookForFilesystem("snapshot", fs, func(ctx context.Context) (err error) {
+			l := getLogger(ctx)
+			l.Debug("create snapshot")
+			err = zfs.ZFSSnapshot(ctx, fs, snapname, false) // TODO propagate context to ZFSSnapshot
+			if err != nil {
+				l.WithError(err).Error("cannot create snapshot")
+			}
+			return
+		})
+
+		fsHadErr := false
+		var planReport hooks.PlanReport
+		var plan *hooks.Plan
+		{
+			filteredHooks, err := a.hooks.CopyFilteredForFilesystem(fs)
+			if err != nil {
+				getLogger(ctx).WithError(err).Error("unexpected filter error")
+				fsHadErr = true
+				goto updateFSState
+			}
+			// account for running hooks
+			for _, h := range filteredHooks {
+				hookMatchCount[h] = hookMatchCount[h] + 1
+			}
+
+			var planErr error
+			plan, planErr = hooks.NewPlan(&filteredHooks, hooks.PhaseSnapshot, jobCallback, hookEnvExtra)
+			if planErr != nil {
+				fsHadErr = true
+				getLogger(ctx).WithError(planErr).Error("cannot create job hook plan")
+				goto updateFSState
+			}
+		}
+		u(func(snapper *Snapper) {
+			progress.name = snapname
+			progress.startAt = time.Now()
+			progress.hookPlan = plan
+			progress.state = SnapStarted
+		})
+		{
+			getLogger(ctx).WithField("report", plan.Report().String()).Debug("begin run job plan")
+			plan.Run(ctx, a.dryRun)
+			planReport = plan.Report()
+			fsHadErr = planReport.HadError() // not just fatal errors
+			if fsHadErr {
+				getLogger(ctx).WithField("report", planReport.String()).Error("end run job plan with error")
+			} else {
+				getLogger(ctx).WithField("report", planReport.String()).Info("end run job plan successful")
+			}
+		}
+
+	updateFSState:
+		anyFsHadErr = anyFsHadErr || fsHadErr
+		u(func(snapper *Snapper) {
+			progress.doneAt = time.Now()
+			progress.state = SnapDone
+			if fsHadErr {
+				progress.state = SnapError
+			}
+			progress.runResults = planReport
+		})
+	}
+
+	select {
+	case a.snapshotsTaken <- struct{}{}:
+	default:
+		if a.snapshotsTaken != nil {
+			getLogger(a.ctx).Warn("callback channel is full, discarding snapshot update event")
+		}
+	}
+
+	for h, mc := range hookMatchCount {
+		if mc == 0 {
+			hookIdx := -1
+			for idx, ah := range *a.hooks {
+				if ah == h {
+					hookIdx = idx
+					break
+				}
+			}
+			getLogger(a.ctx).WithField("hook", h.String()).WithField("hook_number", hookIdx+1).Warn("hook did not match any snapshotted filesystems")
+		}
+	}
+
+	return u(func(snapper *Snapper) {
+		if anyFsHadErr {
+			snapper.state = ErrorWait
+			snapper.err = errors.New("one or more snapshots could not be created, check logs for details")
+		} else {
+			snapper.state = Waiting
+			snapper.err = nil
+		}
+	}).sf()
+}
+
+func wait(a args, u updater) state {
+	var sleepUntil time.Time
+	u(func(snapper *Snapper) {
+		lastTick := snapper.lastInvocation
+		snapper.sleepUntil = lastTick.Add(a.interval)
+		sleepUntil = snapper.sleepUntil
+		log := getLogger(a.ctx).WithField("sleep_until", sleepUntil).WithField("duration", a.interval)
+		logFunc := log.Debug
+		if snapper.state == ErrorWait || snapper.state == SyncUpErrWait {
+			logFunc = log.Error
+		}
+		logFunc("enter wait-state after error")
+	})
+
+	t := time.NewTimer(time.Until(sleepUntil))
+	defer t.Stop()
+
+	select {
+	case <-t.C:
+		return u(func(snapper *Snapper) {
+			snapper.state = Planning
+		}).sf()
+	// case <-dosnapshot.Wait(a.ctx):
+	// 	return u(func(snapper *Snapper) {
+	// 		snapper.state = Planning
+	// 	}).sf()
+	case <-a.ctx.Done():
+		return onMainCtxDone(a.ctx, u)
+	}
+}
+
+func listFSes(ctx context.Context, mf zfs.DatasetFilter) (fss []*zfs.DatasetPath, err error) {
+	return zfs.ZFSListMapping(ctx, mf)
+}
+
+var syncUpWarnNoSnapshotUntilSyncupMinDuration = envconst.Duration("ZREPL_SNAPPER_SYNCUP_WARN_MIN_DURATION", 1*time.Second)
+
+// see docs/snapshotting.rst
+func findSyncPoint(ctx context.Context, fss []*zfs.DatasetPath, prefix string, interval time.Duration) (syncPoint time.Time, err error) {
+
+	const (
+		prioHasVersions int = iota
+		prioNoVersions
+	)
+
+	type snapTime struct {
+		ds   *zfs.DatasetPath
+		prio int // lower is higher
+		time time.Time
+	}
+
+	if len(fss) == 0 {
+		return time.Now(), nil
+	}
+
+	snaptimes := make([]snapTime, 0, len(fss))
+	hardErrs := 0
+
+	now := time.Now()
+
+	getLogger(ctx).Debug("examine filesystem state to find sync point")
+	for _, d := range fss {
+		ctx := logging.WithInjectedField(ctx, "fs", d.ToString())
+		syncPoint, err := findSyncPointFSNextOptimalSnapshotTime(ctx, now, interval, prefix, d)
+		if err == findSyncPointFSNoFilesystemVersionsErr {
+			snaptimes = append(snaptimes, snapTime{
+				ds:   d,
+				prio: prioNoVersions,
+				time: now,
+			})
+		} else if err != nil {
+			hardErrs++
+			getLogger(ctx).WithError(err).Error("cannot determine optimal sync point for this filesystem")
+		} else {
+			getLogger(ctx).WithField("syncPoint", syncPoint).Debug("found optimal sync point for this filesystem")
+			snaptimes = append(snaptimes, snapTime{
+				ds:   d,
+				prio: prioHasVersions,
+				time: syncPoint,
+			})
+		}
+	}
+
+	if hardErrs == len(fss) {
+		return time.Time{}, fmt.Errorf("hard errors in determining sync point for every matching filesystem")
+	}
+
+	if len(snaptimes) == 0 {
+		panic("implementation error: loop must either inc hardErrs or add result to snaptimes")
+	}
+
+	// sort ascending by (prio,time)
+	// => those filesystems with versions win over those without any
+	sort.Slice(snaptimes, func(i, j int) bool {
+		if snaptimes[i].prio == snaptimes[j].prio {
+			return snaptimes[i].time.Before(snaptimes[j].time)
+		}
+		return snaptimes[i].prio < snaptimes[j].prio
+	})
+
+	winnerSyncPoint := snaptimes[0].time
+	l := getLogger(ctx).WithField("syncPoint", winnerSyncPoint.String())
+	l.Info("determined sync point")
+	if winnerSyncPoint.Sub(now) > syncUpWarnNoSnapshotUntilSyncupMinDuration {
+		for _, st := range snaptimes {
+			if st.prio == prioNoVersions {
+				l.WithField("fs", st.ds.ToString()).Warn("filesystem will not be snapshotted until sync point")
+			}
+		}
+	}
+
+	return snaptimes[0].time, nil
+
+}
+
+var findSyncPointFSNoFilesystemVersionsErr = fmt.Errorf("no filesystem versions")
+
+func findSyncPointFSNextOptimalSnapshotTime(ctx context.Context, now time.Time, interval time.Duration, prefix string, d *zfs.DatasetPath) (time.Time, error) {
+
+	fsvs, err := zfs.ZFSListFilesystemVersions(ctx, d, zfs.ListFilesystemVersionsOptions{
+		Types:           zfs.Snapshots,
+		ShortnamePrefix: prefix,
+	})
+	if err != nil {
+		return time.Time{}, errors.Wrap(err, "list filesystem versions")
+	}
+	if len(fsvs) <= 0 {
+		return time.Time{}, findSyncPointFSNoFilesystemVersionsErr
+	}
+
+	// Sort versions by creation
+	sort.SliceStable(fsvs, func(i, j int) bool {
+		return fsvs[i].CreateTXG < fsvs[j].CreateTXG
+	})
+
+	latest := fsvs[len(fsvs)-1]
+	getLogger(ctx).WithField("creation", latest.Creation).Debug("found latest snapshot")
+
+	since := now.Sub(latest.Creation)
+	if since < 0 {
+		return time.Time{}, fmt.Errorf("snapshot %q is from the future: creation=%q now=%q", latest.ToAbsPath(d), latest.Creation, now)
+	}
+
+	return latest.Creation.Add(interval), nil
+}
@@ -0,0 +1,48 @@
+package snapper
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/zfs"
+)
+
+// FIXME: properly abstract snapshotting:
+//   - split up things that trigger snapshotting from the mechanism
+//     - timer-based trigger (periodic)
+//     - call from control socket (manual)
+//     - mixed modes?
+//   - support a `zrepl snapshot JOBNAME` subcommand for config.SnapshottingManual
+type PeriodicOrManual struct {
+	s *Snapper
+}
+
+func (s *PeriodicOrManual) Run(ctx context.Context, replicationCommon chan<- struct{}) {
+	if s.s != nil {
+		s.s.Run(ctx, replicationCommon)
+	}
+}
+
+// Returns nil if manual
+func (s *PeriodicOrManual) Report() *Report {
+	if s.s != nil {
+		return s.s.Report()
+	}
+	return nil
+}
+
+func FromConfig(g *config.Global, fsf zfs.DatasetFilter, in config.SnapshottingEnum) (*PeriodicOrManual, error) {
+	switch v := in.Ret.(type) {
+	case *config.SnapshottingPeriodic:
+		snapper, err := PeriodicFromConfig(g, fsf, v)
+		if err != nil {
+			return nil, err
+		}
+		return &PeriodicOrManual{snapper}, nil
+	case *config.SnapshottingManual:
+		return &PeriodicOrManual{}, nil
+	default:
+		return nil, fmt.Errorf("unknown snapshotting type %T", v)
+	}
+}
@@ -0,0 +1,118 @@
+package snapper
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/zrepl/zrepl/daemon/hooks"
+)
+
+type Report struct {
+	State State
+	// valid in state SyncUp and Waiting
+	SleepUntil time.Time
+	// valid in state Err
+	Error string
+	// valid in state Snapshotting
+	Progress []*ReportFilesystem
+}
+
+type ReportFilesystem struct {
+	Path  string
+	State SnapState
+
+	// Valid in SnapStarted and later
+	SnapName      string
+	StartAt       time.Time
+	Hooks         string
+	HooksHadError bool
+
+	// Valid in SnapDone | SnapError
+	DoneAt time.Time
+}
+
+func errOrEmptyString(e error) string {
+	if e != nil {
+		return e.Error()
+	}
+	return ""
+}
+
+func (s *Snapper) Report() *Report {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+
+	pReps := make([]*ReportFilesystem, 0, len(s.plan))
+	for fs, p := range s.plan {
+		var hooksStr string
+		var hooksHadError bool
+		if p.hookPlan != nil {
+			hr := p.hookPlan.Report()
+			// FIXME: technically this belongs into client
+			// but we can't serialize hooks.Step ATM
+			rightPad := func(str string, length int, pad string) string {
+				if len(str) > length {
+					return str[:length]
+				}
+				return str + strings.Repeat(pad, length-len(str))
+			}
+			hooksHadError = hr.HadError()
+			rows := make([][]string, len(hr))
+			const numCols = 4
+			lens := make([]int, numCols)
+			for i, e := range hr {
+				rows[i] = make([]string, numCols)
+				rows[i][0] = fmt.Sprintf("%d", i+1)
+				rows[i][1] = e.Status.String()
+				runTime := "..."
+				if e.Status != hooks.StepPending {
+					runTime = e.End.Sub(e.Begin).Round(time.Millisecond).String()
+				}
+				rows[i][2] = runTime
+				rows[i][3] = ""
+				if e.Report != nil {
+					rows[i][3] = e.Report.String()
+				}
+				for j, col := range lens {
+					if len(rows[i][j]) > col {
+						lens[j] = len(rows[i][j])
+					}
+				}
+			}
+			rowsFlat := make([]string, len(hr))
+			for i, r := range rows {
+				colsPadded := make([]string, len(r))
+				for j, c := range r[:len(r)-1] {
+					colsPadded[j] = rightPad(c, lens[j], " ")
+				}
+				colsPadded[len(r)-1] = r[len(r)-1]
+				rowsFlat[i] = strings.Join(colsPadded, " ")
+			}
+			hooksStr = strings.Join(rowsFlat, "\n")
+		}
+		pReps = append(pReps, &ReportFilesystem{
+			Path:          fs.ToString(),
+			State:         p.state,
+			SnapName:      p.name,
+			StartAt:       p.startAt,
+			DoneAt:        p.doneAt,
+			Hooks:         hooksStr,
+			HooksHadError: hooksHadError,
+		})
+	}
+
+	sort.Slice(pReps, func(i, j int) bool {
+		return strings.Compare(pReps[i].Path, pReps[j].Path) == -1
+	})
+
+	r := &Report{
+		State:      s.state,
+		SleepUntil: s.sleepUntil,
+		Error:      errOrEmptyString(s.err),
+		Progress:   pReps,
+	}
+
+	return r
+}
@@ -1,21 +0,0 @@
-package snapper
-
-import (
-	"context"
-
-	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/logger"
-)
-
-type Logger = logger.Logger
-
-func getLogger(ctx context.Context) Logger {
-	return logging.GetLogger(ctx, logging.SubsysSnapshot)
-}
-
-func errOrEmptyString(e error) string {
-	if e != nil {
-		return e.Error()
-	}
-	return ""
-}
@@ -1,23 +0,0 @@
-#!/sbin/openrc-run
-
-command='/usr/local/bin/zrepl'
-command_args='daemon'
-command_background='true'
-pidfile="/run/${RC_SVCNAME}.pid"
-output_log="/var/log/${RC_SVCNAME}.log"
-error_log="/var/log/${RC_SVCNAME}.log"
-
-zrepl_runtime_dir='/var/run/zrepl'
-
-start() {
-	mkdir -p "$zrepl_runtime_dir/stdinserver"
-	chmod -R 0700 "$zrepl_runtime_dir"
-	default_start
-}
-
-stop() {
-	rm -rf "$zrepl_runtime_dir"
-	default_stop
-}
-
-# vi: noet sw=8 sts=0
@@ -9,9 +9,6 @@ ExecStart=/usr/local/bin/zrepl --config /etc/zrepl/zrepl.yml daemon
 RuntimeDirectory=zrepl zrepl/stdinserver
 RuntimeDirectoryMode=0700

-# Make Go produce coredumps
-Environment=GOTRACEBACK='crash'
-
 ProtectSystem=strict
 #PrivateDevices=yes # TODO ZFS needs access to /dev/zfs, could we limit this?
 ProtectKernelTunables=yes
@@ -30,8 +27,7 @@ ProtectHome=read-only
 # SystemCallFilter
 #   ~@privileged doesn't work with Ubuntu 18.04 ssh
 SystemCallFilter=~ @mount @cpu-emulation @keyring @module @obsolete @raw-io @debug @clock @resources
-# Go1.19 added automatic RLIMIT_NOFILE changes, so, we need to allow that
-SystemCallFilter= setrlimit
+

 [Install]
 WantedBy=multi-user.target
@@ -10,11 +10,11 @@ BUILDDIR      = _build

 # Put it first so that "make" without argument is like "make help".
 help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" -c sphinxconf $(SPHINXOPTS) $(O)

 .PHONY: help Makefile

 # Catch-all target: route all unknown targets to Sphinx using the new
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
 %: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" -c sphinxconf $(SPHINXOPTS) $(O)
@@ -1,43 +0,0 @@
-/* https://github.com/sphinx-contrib/sphinxcontrib-versioning/blob/0b56210959c6b21bbb730072e81876491b4e1371/sphinxcontrib/versioning/_static/banner.css */
-
-.scv-banner {
-    padding: 3px;
-    border-radius: 2px;
-    font-size: 80%;
-    text-align: center;
-    color: white;
-    background: #d40 linear-gradient(-45deg,
-        rgba(255, 255, 255, 0.2) 0%,
-        rgba(255, 255, 255, 0.2) 25%,
-        transparent 25%,
-        transparent 50%,
-        rgba(255, 255, 255, 0.2) 50%,
-        rgba(255, 255, 255, 0.2) 75%,
-        transparent 75%,
-        transparent
-    );
-    background-size: 28px 28px;
-}
-.scv-banner > a {
-    color: white;
-}
-
-
-.scv-sphinx_rtd_theme {
-    background-color: #2980B9;
-}
-
-
-.scv-bizstyle {
-    background-color: #336699;
-}
-
-
-.scv-classic {
-    text-align: center !important;
-}
-
-
-.scv-traditional {
-    text-align: center !important;
-}
@@ -1,17 +0,0 @@
-{% extends "!page.html" %}
-{% block body %}
-{% if current_version and latest_version and current_version != latest_version %}
-<p class="scv-banner scv-sphinx_rtd_theme">
-  <strong>
-    {% if current_version.is_released %}
-    You're reading an old version of this documentation.
-    If you want up-to-date information, please have a look at <a href="{{ vpathto(latest_version.name) }}">{{latest_version.name}}</a>.
-    {% else %}
-    You're reading the documentation for a development version.
-    For the latest released version, please have a look at <a href="{{ vpathto(latest_version.name) }}">{{latest_version.name}}</a>.
-    {% endif %}
-  </strong>
-</p>
-{% endif %}
-{{ super() }}
-{% endblock %}%
@@ -1,27 +0,0 @@
-{%- if current_version %}
-<div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
-  <span class="rst-current-version" data-toggle="rst-current-version">
-    <span class="fa fa-book"> Other Versions</span>
-    v: {{ current_version.name }}
-    <span class="fa fa-caret-down"></span>
-  </span>
-  <div class="rst-other-versions">
-    {%- if versions.tags %}
-    <dl>
-      <dt>Tags</dt>
-      {%- for item in versions.tags %}
-      <dd><a href="{{ item.url }}">{{ item.name }}</a></dd>
-      {%- endfor %}
-    </dl>
-    {%- endif %}
-    {%- if versions.branches %}
-    <dl>
-      <dt>Branches</dt>
-      {%- for item in versions.branches %}
-      <dd><a href="{{ item.url }}">{{ item.name }}</a></dd>
-      {%- endfor %}
-    </dl>
-    {%- endif %}
-  </div>
-</div>
-{%- endif %}
@@ -16,125 +16,23 @@ Changelog
 The changelog summarizes bugfixes that are deemed relevant for users and package maintainers.
 Developers should consult the git commit log or GitHub issue tracker.

-Next Release
------------
+We use the following annotations for classifying changes:

-The plan for the next release is to revisit how zrepl does snapshot management.
-High-level goals:
-
- Make it easy to decouple snapshot management (snapshotting, pruning) from replication.
- Ability to include/exclude snapshots from replication.
-  This is useful for aforementioned decoupling, e.g., separate snapshot prefixes for local & remote replication.
-  Also, it makes explicit that by default, zrepl replicates all snapshots, and that
-  replication has no concept of "zrepl-created snapshots", which is a common misconception.
- Use of ``zfs snapshot`` comma syntax or channel programs to take snapshots of multiple
-  datasets atomically.
- Provide an alternative to the ``grid`` pruning policy.
-  Most likely something based on hourly/daily/weekly/monthly "trains" plus a count.
- Ability to prune at the granularity of the **group** of snapshots created at a given
-  time, as opposed to the individual snapshots within a dataset.
-  Maybe this will be addressed by the alternative to the ``grid`` pruning policy,
-  as it will likely be more predictable.
-
-Those changes will likely come with some breakage in the config.
-However, I want to avoid breaking **use cases** that are satisfied by the current design.
-There will be beta/RC releases to give users a chance to evaluate.
-
-0.6.1
-----
-
-* |feature| add metric to detect filesystems rules that don't match any local dataset (thanks, `@gmekicaxcient <https://github.com/gmekicaxcient>`_).
-* |bugfix| ``zrepl status``: hide progress bar once all filesystems reach terminal state (thanks, `@0x3333 <https://github.com/0x3333>`_).
-* |bugfix| handling of tenative cursor presence if protection strategy doesn't use it (:issue:`714`).
-* |docs| address setup with two or more external disks (thanks, `@se-jaeger <https://github.com/se-jaeger>`_).
-* |docs| document ``replication`` and ``conflict_resolution`` options (thanks, `@InsanePrawn <https://github.com/InsanePrawn>`_).
-* |docs| docs: talks: add note on keep_bookmarks option (thanks, `@skirmess <https://github.com/skirmess>`_).
-* |maint| dist: add openrc service file (thanks, `@gramosg <https://github.com/gramosg>`_).
-* |maint| grafana: update dashboard to Grafana 9.3.6.
-* |maint| run platform tests as part of CI.
-* |maint| build: upgrade to Go 1.21 and update golangci-lint; minimum Go version for builds is now 1.20
-
-.. NOTE::
-  |  zrepl is a spare-time project primarily developed by `Christian Schwarz <https://cschwarz.com>`_.
-  |  You can support maintenance and feature development through one of the following services:
-  |  |Donate via Patreon| |Donate via GitHub Sponsors| |Donate via Liberapay| |Donate via PayPal|
-  |  Note that PayPal processing fees are relatively high for small donations.
-  |  For SEPA wire transfer and **commercial support**, please `contact Christian directly <https://cschwarz.com>`_.
-
-0.6
---
-
-* |feature| :ref:`Schedule-based snapshotting<job-snapshotting--cron>` using ``cron`` syntax instead of an interval.
-* |feature| Configurable initial replication policy.
-  When a filesystem is first replicated to a receiver, this control whether just the newest
-  snapshot will be replicated vs. all existing snapshots. Learn more :ref:`in the docs <conflict_resolution-initial_replication>`.
-* |feature| Configurable timestamp format for snapshot names via :ref:`timestamp_format<job-snapshotting-timestamp_format>`
-  (Thanks, `@ydylla <https://github.com/ydylla>`_).
-* |feature| Add ``ZREPL_DESTROY_MAX_BATCH_SIZE`` env var (default 0=unlimited)
-  (Thanks, `@3nprob <https://github.com/3nprob>`_).
-* |feature| Add ``zrepl configcheck --skip-cert-check`` flag (Thanks, `@cole-h <https://github.com/cole-h>`_).
-* |bugfix| Fix resuming from interrupted replications that use ``send.raw`` on unencrypted datasets.
-
-  * The send options introduced in zrepl 0.4 allow users to specify additional zfs send flags for zrepl to use.
-    Before this fix, when setting ``send.raw=true`` on a job that replicates unencrypted datasets,
-    zrepl would not allow an interrupted replication to resume.
-    The reason were overly cautious checks to support the ``send.encrypted`` option.
-  * This bugfix removes these checks from the replication planner.
-    This makes ``send.encrypted`` a sender-side-only concern, much like all other ``send.*`` flags.
-  * However, this means that the ``zrepl status`` UI no longer indicates whether a replication step uses encrypted sends or not.
-    The setting is still effective though.
-
-* |break| convert Prometheus metric ``zrepl_version_daemon`` to ``zrepl_start_time`` metric
-
-  * The metric still reports the zrepl version in a label.
-    But the metric *value* is now the Unix timestamp at the time the daemon was started.
-    The Grafana dashboard in :repomasterlink:`dist/grafana` has been updated.
-
-* |bugfix| transient zrepl status error: ``Post "http://unix/status": EOF``
-* |bugfix| don't treat receive-side bookmarks as a replication conflict.
-  This facilitates chaining of replication jobs. See :issue:`490`.
-* |bugfix| workaround for Go/gRPC problem on Illumos where zrepl would
-  crash when using the ``local`` transport type (:issue:`598`).
-* |bugfix| fix active child tasks panic that cold occur during replication plannig (:issue:`193abbe`)
-* |bugfix| ``zrepl status`` off-by-one error in display of completed step count (:commit:`ce6701f`)
-* |bugfix| Allow using day & week units for ``snapshotting.interval`` (:commit:`ffb1d89`)
-* |docs| ``docs/overview`` improvements (Thanks, `@jtagcat <https://github.com/jtagcat>`_).
-* |maint| Update to Go 1.19.
-
-0.5
---
-
-* |feature| :ref:`Bandwidth limiting <job-send-recv-options--bandwidth-limit>` (Thanks, Prominic.NET, Inc.)
-* |feature| zrepl status: use a ``*`` to indicate which filesystem is currently replicating
-* |feature| include daemon environment variables in zrepl status (currently only in ``--raw``)
-* |bugfix| **fix encrypt-on-receive + placeholders use case** (:issue:`504`)
-
-  * Before this fix, **plain sends** to a receiver with an encrypted ``root_fs`` **could be received unencrypted** if zrepl needed to create placeholders on the receiver.
-  * Existing zrepl users should :ref:`read the docs <job-recv-options--placeholder>` and check ``zfs get -r encryption,zrepl:placeholder PATH_TO_ROOTFS`` on the receiver.
-  * Thanks to `@mologie <https://github.com/mologie>`_ and `@razielgn <https://github.com/razielgn>`_ for reporting and testing!
-
-* |bugfix| Rename mis-spelled :ref:`send option <job-send-options>` ``embbeded_data`` to ``embedded_data``.
-* |bugfix| zrepl status: replication step numbers should start at 1
-* |bugfix| incorrect bandwidth averaging in ``zrepl status``.
-* |bugfix| FreeBSD with OpenZFS 2.0: zrepl would wait indefinitely for zfs send to exit on timeouts.
-* |bugfix| fix ``strconv.ParseInt: value out of range`` bug (and use the control RPCs).
-* |docs| improve description of multiple pruning rules.
-* |docs| document :ref:`platform tests <usage-platform-tests>`.
-* |docs| quickstart: make users aware that prune rules apply to all snapshots.
-* |maint| some platformtests were broken.
-* |maint| FreeBSD: release armv7 and arm64 binaries.
-* |maint| apt repo: update instructions due to ``apt-key`` deprecation.
-
-Note to all users: please read up on the following OpenZFS bugs, as you might be affected:
-
-* `ZFS send/recv with ashift 9->12 leads to data corruption <https://github.com/openzfs/zfs/issues/12762>`_.
-* Various bugs with encrypted send/recv (`Leadership meeting notes <https://openzfs.topicbox.com/groups/developer/T24bdaa2886c6cbf5-Mc039a11c3f1507ea0664817b/december-openzfs-leadership-meeting>`_)
-
-Finally, I'd like to point you to the `GitHub discussion <https://github.com/zrepl/zrepl/discussions/547>`_ about which bugfixes and features should be prioritized in zrepl 0.6 and beyond!
+* |break_config| Change that breaks the config.
+  As a package maintainer, make sure to warn your users about config breakage somehow.
+* |break| Change that breaks interoperability or persistent state representation with previous releases.
+  As a package maintainer, make sure to warn your users about config breakage somehow.
+  Note that even updating the package on both sides might not be sufficient, e.g. if persistent state needs to be migrated to a new format.
+* |mig| Migration that must be run by the user.
+* |feature| Change that introduces new functionality.
+* |bugfix| Change that fixes a bug, no regressions or incompatibilities expected.
+* |docs| Change to the documentation.
+* |maint| Maintenance changes.

 0.4.0
 -----

+* |break| Change syntax to trigger a job replication, rename ``zrepl signal wakeup JOB`` to ``zrepl signal replication JOB``
 * |feature| support setting zfs send / recv flags in the config (send: ``-wLcepbS`` , recv: ``-ox`` ).
  Config docs :ref:`here <job-send-options>` and :ref:`here <job-recv-options>` .
 * |feature| parallel replication is now configurable (disabled by default, :ref:`config docs here <replication-option-concurrency>` ).
@@ -156,6 +54,13 @@ The following bugfix in 0.3.1 :issue:`caused problems for some users <400>`:

 * |bugfix| pruning: ``grid``:  add all snapshots that do not match the regex to the rule's destroy list.

+.. NOTE::
+  |  zrepl is a spare-time project primarily developed by `Christian Schwarz <https://cschwarz.com>`_.
+  |  You can support maintenance and feature development through one of the following services:
+  |  |Donate via Patreon| |Donate via GitHub Sponsors| |Donate via Liberapay| |Donate via PayPal|
+  |  Note that PayPal processing fees are relatively high for small donations.
+  |  For SEPA wire transfer and **commercial support**, please `contact Christian directly <https://cschwarz.com>`_.
+
 0.3.1
 -----

@@ -339,7 +244,7 @@ Changes
 * |feature| Proper timeout handling for the :ref:`SSH transport <transport-ssh+stdinserver>`

  * |break| Requires Go 1.11 or later.
-
+  
 * |break| |break_config|: mappings are no longer supported

  * Receiving sides (``pull`` and ``sink`` job) specify a single ``root_fs``.
@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# zrepl documentation build configuration file, created by
-# sphinx-quickstart on Wed Nov  8 22:28:10 2017.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = ['sphinx.ext.todo',
-    'sphinx.ext.githubpages',
-    'sphinx.ext.extlinks',
-    "sphinx_multiversion",
-]
-
-# suppress_warnings = ['image.nonlocal_uri']
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['./_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = 'zrepl'
-copyright = '2017-2023, Christian Schwarz'
-author = 'Christian Schwarz'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-#version = set by sphinxcontrib-versioning
-# The full version, including alpha/beta/rc tags.
-#release = version
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = 'en'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = True
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'sphinx_rtd_theme'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-# html_theme_options = {}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-html_css_files = [
-    'banner.css',
-]
-
-html_logo = '_static/zrepl.svg'
-
-html_context = {
-  # https://github.com/rtfd/sphinx_rtd_theme/issues/205
-  # Add 'Edit on Github' link instead of 'View page source'
-  "display_github": True,
-  "github_user": "zrepl",
-  "github_repo": "zrepl",
-  "github_version": "master",
-  "conf_py_path": "/docs/",
-  "source_suffix": source_suffix,
-}
-
-# -- Options for HTMLHelp output ------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'zrepldoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    #
-    # 'papersize': 'letterpaper',
-
-    # The font size ('10pt', '11pt' or '12pt').
-    #
-    # 'pointsize': '10pt',
-
-    # Additional stuff for the LaTeX preamble.
-    #
-    # 'preamble': '',
-
-    # Latex figure (float) alignment
-    #
-    # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'zrepl.tex', 'zrepl Documentation',
-     'Christian Schwarz', 'manual'),
-]
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'zrepl', 'zrepl Documentation',
-     [author], 1)
-]
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'zrepl', 'zrepl Documentation',
-     author, 'zrepl', 'One line description of project.',
-     'Miscellaneous'),
-]
-
-
-# -- Options for the extlinks extension -----------------------------------
-# http://www.sphinx-doc.org/en/stable/ext/extlinks.html
-extlinks = {
-    'issue':('https://github.com/zrepl/zrepl/issues/%s', 'issue #%s'),
-    'repomasterlink':('https://github.com/zrepl/zrepl/blob/master/%s', '%s'),
-    'sampleconf':('https://github.com/zrepl/zrepl/blob/master/config/samples%s', 'config/samples%s'),
-    'commit':('https://github.com/zrepl/zrepl/commit/%s', 'commit %s'),
-        }
-
@@ -0,0 +1 @@
+sphinxconf/conf.py
@@ -13,7 +13,6 @@ Configuration
    configuration/filter_syntax
    configuration/sendrecvoptions
    configuration/replication
-    configuration/conflict_resolution
    configuration/snapshotting
    configuration/prune
    configuration/logging
@@ -1,37 +0,0 @@
-.. include:: ../global.rst.inc
-
-.. _conflict_resolution-options:
-
-Conflict Resolution Options
-===========================
-
-
-::
-
-   jobs:
-   - type: push
-     filesystems: ...
-     conflict_resolution:
-       initial_replication: most_recent | all | fail # default: most_recent
-
-     ...
-
-.. _conflict_resolution-initial_replication:
-
-
-``initial_replication`` option
------------------------------
-
-The ``initial_replication`` option determines how many snapshots zrepl replicates if the filesystem has not been replicated before.
-If ``most_recent`` (the default), the initial replication will only transfer the most recent snapshot, while ignoring previous snapshots.
-If all snapshots should be replicated, specify ``all``.
-Use ``fail`` to make replication of the filesystem fail in case there is no corresponding fileystem on the receiver.
-
-For example, suppose there are snapshosts ``tank@1``, ``tank@2``, ``tank@3`` on a sender.
-Then ``most_recent`` will replicate just ``@3``, but ``all`` will replicate ``@1``, ``@2``, and ``@3``.
-
-If initial replication is interrupted, and there is at least one (maybe partial) snapshot on the receiver, zrepl will always resume in **incremental mode**.
-And that is regardless of where the initial replication was interrupted.
-
-For example, if ``initial_replication: all`` and the transfer of ``@1`` is interrupted, zrepl would retry/resume at ``@1``.
-And even if the user changes the config to ``initial_replication: most_recent`` before resuming, **incremental mode** will still resume at ``@1``.
@@ -30,10 +30,6 @@ Job Type ``push``
      - |snapshotting-spec|
    * - ``pruning``
      - |pruning-spec|
-    * - ``replication``
-      - |replication-options|
-    * - ``conflict_resolution``
-      - |conflict-resolution-options|

 Example config: :sampleconf:`/push.yml`

@@ -82,13 +78,9 @@ Job Type ``pull``
        ``$root_fs/$source_path``
    * - ``interval``
      - | Interval at which to pull from the source job (e.g. ``10m``).
-        | ``manual`` disables periodic pulling, replication then only happens on :ref:`wakeup <cli-signal-wakeup>`.
+        | ``manual`` disables periodic pulling, replication then only happens on :ref:`replication <cli-signal-replication>`.
    * - ``pruning``
      - |pruning-spec|
-    * - ``replication``
-      - |replication-options|
-    * - ``conflict_resolution``
-      - |conflict-resolution-options|

 Example config: :sampleconf:`/pull.yml`

@@ -1,5 +1,3 @@
-.. _miscellaneous:
-
 Miscellaneous
 =============

@@ -44,3 +42,27 @@ Interval & duration fields in job definitions, pruning configurations, etc. must

    var durationStringRegex *regexp.Regexp = regexp.MustCompile(`^\s*(\d+)\s*(s|m|h|d|w)\s*$`)
    // s = second, m = minute, h = hour, d = day, w = week (7 days)
+
+Super-Verbose Job Debugging
+---------------------------
+
+You have probably landed here because you opened an issue on GitHub and some developer told you to do this...
+So just read the annotated comments ;)
+
+::
+
+    job:
+    - name: ...
+      ...
+     # JOB DEBUGGING OPTIONS
+      # should be equal for all job types, but each job implements the debugging itself
+      debug:
+        conn: # debug the io.ReadWriteCloser connection
+          read_dump: /tmp/connlog_read   # dump results of Read() invocations to this file
+          write_dump: /tmp/connlog_write # dump results of Write() invocations to this file
+        rpc: # debug the RPC protocol implementation
+          log: true # log output from rpc layer to the job log
+
+.. ATTENTION::
+
+    Connection dumps will almost certainly contain your or other's private data. Do not share it in a bug report.
@@ -13,7 +13,7 @@ Prometheus & Grafana
 --------------------

 zrepl can expose `Prometheus metrics <https://prometheus.io/docs/instrumenting/exposition_formats/>`_ via HTTP.
-The ``listen`` attribute is a `net.Listen <https://golang.org/pkg/net/#Listen>`_  string for tcp, e.g. ``:9811`` or ``127.0.0.1:9811`` (port 9811 was reserved to zrepl `on the official list <https://github.com/prometheus/prometheus/wiki/Default-port-allocations/_compare/43e495dd251ee328ac0d08b58084665b5c0f7a7e...459195059b55b414193ebeb80c5ba463d2606951>`_).
+The ``listen`` attribute is a `net.Listen <https://golang.org/pkg/net/#Listen>`_  string for tcp, e.g. ``:9091`` or ``127.0.0.1:9091``.
 The ``listen_freebind`` attribute is :ref:`explained here <listen-freebind-explanation>`.
 The Prometheus monitoring job appears in the ``zrepl control`` job list and may be specified **at most once**.

@@ -30,7 +30,7 @@ The dashboard also contains some advice on which metrics are important to monito
    global:
      monitoring:
        - type: prometheus
-          listen: ':9811'
+          listen: ':9091'
          listen_freebind: true # optional, default false


@@ -3,17 +3,16 @@ Overview & Terminology
 ======================

 All work zrepl does is performed by the zrepl daemon which is configured in a single YAML configuration file loaded on startup.
-The following paths are searched, in this order:
+The following paths are considered:

-1. The path specified via the global ``--config`` flag
-2. ``/etc/zrepl/zrepl.yml``
-3. ``/usr/local/etc/zrepl/zrepl.yml``
+* If set, the location specified via the global ``--config`` flag
+* ``/etc/zrepl/zrepl.yml``
+* ``/usr/local/etc/zrepl/zrepl.yml``

-``zrepl configcheck`` can be used to validate the configuration.
-If the configuration is valid, it will output nothing and exit with code ``0``.
+The ``zrepl configcheck`` subcommand can be used to validate the configuration.
+The command will output nothing and exit with zero status code if the configuration is valid.
 The error messages vary in quality and usefulness: please report confusing config errors to the tracking :issue:`155`.
-
-Full example configs are available at :ref:`quick-start guides <quickstart-toc>` and :sampleconf:`/`.
+Full example configs such as in the :ref:`quick-start guides <quickstart-toc>` or the :sampleconf:`/` directory might also be helpful.
 However, copy-pasting examples is no substitute for reading documentation!

 Config File Structure
@@ -27,8 +26,9 @@ Config File Structure
     type: push
   - ...

-A zrepl configuration file is divided in to two main sections: ``global`` and ``jobs``.
-``global`` has sensible defaults. It is covered in :ref:`logging <logging>`, :ref:`monitoring <monitoring>` \& :ref:`miscellaneous <miscellaneous>`.
+zrepl is configured using a single YAML configuration file with two main sections: ``global`` and ``jobs``.
+The ``global`` section is filled with sensible defaults and is covered later in this chapter.
+The ``jobs`` section is a list of jobs which we are going to explain now.

 .. _job-overview:

@@ -42,7 +42,8 @@ Jobs are identified by their ``name``, both in log files and the ``zrepl status`
 .. NOTE::
   The job name is persisted in several places on disk and thus :issue:`cannot be changed easily<327>`.

-Replication always happens between a pair of jobs: one **active side** and one **passive side**.
+
+Replication always happens between a pair of jobs: one is the **active side**, and one the **passive side**.
 The active side connects to the passive side using a :ref:`transport <transport>` and starts executing the replication logic.
 The passive side responds to requests from the active side after checking its permissions.

@@ -71,29 +72,30 @@ How the Active Side Works

 The active side (:ref:`push <job-push>` and :ref:`pull <job-pull>` job) executes the replication and pruning logic:

-1. Wakeup after snapshotting (``push`` job) or pull interval ticker (``pull`` job).
-2. Connect to the passive side and instantiate an RPC client.
-3. Replicate data from the sender to the receiver.
-4. Prune on sender & receiver.
+* Wakeup because of finished snapshotting (``push`` job) or pull interval ticker (``pull`` job).
+* Connect to the corresponding passive side using a :ref:`transport <transport>` and instantiate an RPC client.
+* Replicate data from the sending to the receiving side (see below).
+* Prune on sender & receiver.

 .. TIP::
-  The progress of the active side can be watched live using ``zrepl status``.
+  The progress of the active side can be watched live using the ``zrepl status`` subcommand.

 .. _overview-passive-side--client-identity:

 How the Passive Side Works
 --------------------------

-The passive side (:ref:`sink <job-sink>` and :ref:`source <job-source>`) waits for connections from the active side,
-on the :ref:`transport <transport>` specified with ``serve`` in the job configuration.
-The respective transport then perfoms authentication & authorization, resulting in a stable *client identity*.
-The passive side job uses this *client identity* as follows:
+The passive side (:ref:`sink <job-sink>` and :ref:`source <job-source>`) waits for connections from the corresponding active side,
+using the transport listener type specified in the ``serve`` field of the job configuration.
+When a client connects, the transport listener performS listener-specific access control (cert validation, IP ACLs, etc)
+and determines the *client identity*.
+The passive side job then uses this client identity as follows:

-   * In ``sink`` jobs, to map requests from different *client identities* to their respective sub-filesystem tree ``root_fs/${client_identity}``.
-   * *In the future, ``source`` might embed the client identity in :ref:`zrepl's ZFS abstraction names <zrepl-zfs-abstractions>`, to support multi-host replication.*
+* The ``sink`` job maps requests from different client identities to their respective sub-filesystem tree ``root_fs/${client_identity}``.
+* The ``source`` might, in the future, embed the client identity in :ref:`zrepl's ZFS abstraction names <zrepl-zfs-abstractions>` in order to support multi-host replication.

 .. TIP::
-   The use of the client identity in the ``sink`` job implies that it must be usable as a ZFS ZFS filesystem name component.
+   The implementation of the ``sink`` job requires that the connecting client identities be a valid ZFS filesystem name components.

 .. _overview-how-replication-works:

@@ -104,7 +106,7 @@ One of the major design goals of the replication module is to avoid any duplicat
 As such, the code works on abstract senders and receiver **endpoints**, where typically one will be implemented by a local program object and the other is an RPC client instance.
 Regardless of push- or pull-style setup, the logic executes on the active side, i.e. in the ``push`` or ``pull`` job.

-The following high-level steps take place during replication and can be monitored using ``zrepl status``:
+The following high-level steps take place during replication and can be monitored using the ``zrepl status`` subcommand:

 * Plan the replication:

@@ -130,7 +132,7 @@ The following high-level steps take place during replication and can be monitore
  * Move the **replication cursor** bookmark on the sending side (see below).
  * Move the **last-received-hold** on the receiving side (see below).
  * Release the send-side step-holds.
-
+   
 The idea behind the execution order of replication steps is that if the sender snapshots all filesystems simultaneously at fixed intervals, the receiver will have all filesystems snapshotted at time ``T1`` before the first snapshot at ``T2 = T1 + $interval`` is replicated.

 ZFS Background Knowledge
@@ -231,11 +233,22 @@ The ``zrepl zfs-abstraction list`` command provides a listing of all bookmarks a

    More details can be found in the design document :repomasterlink:`replication/design.md`.

+Limitations
+^^^^^^^^^^^

-Caveats With Complex Setups (More Than 2 Jobs or Machines)
----------------------------------------------------------
+.. ATTENTION::

-Most users are served well with a single sender and a single receiver job.
+    Currently, zrepl does not replicate filesystem properties.
+    When receiving a filesystem, it is never mounted (`-u` flag)  and `mountpoint=none` is set.
+    This is temporary and being worked on :issue:`24`.
+
+
+.. _jobs-multiple-jobs:
+
+Multiple Jobs & More than 2 Machines
+------------------------------------
+
+The quick-start guides focus on simple setups with a single sender and a single receiver.
 This section documents considerations for more complex setups.

 .. ATTENTION::
@@ -249,7 +262,7 @@ This section documents considerations for more complex setups.

   If you can't find your desired configuration, have questions or would like to see improvements to multi-job setups, please `open an issue on GitHub <https://github.com/zrepl/zrepl/issues/new>`_.

-Multiple Jobs on One Machine
+Multiple Jobs on one Machine
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 As a general rule, multiple jobs configured on one machine **must operate on disjoint sets of filesystems**.
 Otherwise, concurrently running jobs might interfere when operating on the same filesystem.
@@ -258,9 +271,6 @@ On your setup, ensure that

 * all ``filesystems`` filter specifications are disjoint
 * no ``root_fs`` is a prefix or equal to another ``root_fs``
-
-  * For ``sink`` jobs, consider all possible ``root_fs/${client_identity}``.
-
 * no ``filesystems`` filter matches any ``root_fs``

 **Exceptions to the rule**:
@@ -271,53 +281,18 @@ On your setup, ensure that
  This scenario is detailed in one of the :ref:`quick-start guides <quickstart-backup-to-external-disk>`.


-Two Or More Machines
+More Than 2 Machines
 ^^^^^^^^^^^^^^^^^^^^

 This section might be relevant to users who wish to *fan-in* (N machines replicate to 1) or *fan-out* (replicate 1 machine to N machines).

 **Working setups**:

-* **Fan-in: N servers replicated to one receiver, disjoint dataset trees.**
+* N ``push`` identities, 1 ``sink`` (as long as the different push jobs have a different :ref:`client identity <overview-passive-side--client-identity>`)

-  * This is the common use case of a centralized backup server.
-
-  * Implementation:
-
-    * N ``push`` jobs (one per sender server), 1 ``sink`` (as long as the different push jobs have a different :ref:`client identity <overview-passive-side--client-identity>`)
-    * N ``source`` jobs (one per sender server), N ``pull`` on the receiver server (unique names, disjoint  ``root_fs``)
-
-  * The ``sink`` job automatically constrains each client to a disjoint sub-tree of the sink-side dataset hierarchy ``${root_fs}/${client_identity}``.
+  * ``sink`` constrains each client to a disjoint sub-tree of the sink-side dataset hierarchy ``${root_fs}/${client_identity}``.
    Therefore, the different clients cannot interfere.

-  * The ``pull`` job only pulls from one host, so it's up to the zrepl user to ensure that the different ``pull`` jobs don't interfere.
-
-.. _fan-out-replication:
-
-* **Fan-out: 1 server replicated to N receivers**
-
-  * Can be implemented either in a pull or push fashion.
-
-    * **pull setup**: 1 ``pull`` job on each receiver server, each with a corresponding **unique** ``source`` job on the sender server.
-    * **push setup**: 1 ``sink`` job on each receiver server, each with a corresponding **unique** ``push`` job on the sender server.
-
-  * It is critical that we have one sending-side job (``source``, ``push``) per receiver.
-    The reason is that :ref:`zrepl's ZFS abstractions <zrepl-zfs-abstractions>` (``zrepl zfs-abstraction list``) include the name of the ``source``/``push`` job, but not the receive-side job name or client identity (see :issue:`380`).
-    As a counter-example, suppose we used multiple ``pull`` jobs with only one ``source`` job.
-    All ``pull`` jobs would share the same :ref:`replication cursor bookmark <replication-cursor-and-last-received-hold>` and trip over each other, breaking incremental replication guarantees quickly.
-    The anlogous problem exists for 1 ``push`` to N ``sink`` jobs.
-
-  * The ``filesystems`` matched by the sending side jobs (``source``, ``push``) need not necessarily be disjoint.
-    For this to work, we need to avoid interference between snapshotting and pruning of the different sending jobs.
-    The solution is to centralize sender-side snapshot management in a separate ``snap`` job.
-    Snapshotting in the ``source``/``push`` job should then be disabled (``type: manual``).
-    And sender-side pruning (``keep_sender``) needs to be disabled in the active side (``pull`` / ``push``), since that'll be done by the ``snap job``.
-
-  * **Restore limitations**: when restoring from one of the ``pull`` targets (e.g., using ``zfs send -R``), the replication cursor bookmarks don't exist on the restored system.
-    This can break incremental replication to all other receive-sides after restore.
-
-  * See :ref:`the fan-out replication quick-start guide <quickstart-fan-out-replication>` for an example of this setup.
-

 **Setups that do not work**:

@@ -67,9 +67,8 @@ Policy ``not_replicated``
     ...

 ``not_replicated`` keeps all snapshots that have not been replicated to the receiving side.
-It only makes sense to specify this rule for the ``keep_sender``.
-The reason is that, by definition, all snapshots on the receiver have already been replicated to there from the sender.
-To determine whether a sender-side snapshot has already been replicated, zrepl uses the :ref:`replication cursor bookmark <replication-cursor-and-last-received-hold>` which corresponds to the most recent successfully replicated snapshot.
+It only makes sense to specify this rule on a sender (source or push job).
+The state required to evaluate this rule is stored in the :ref:`replication cursor bookmark <replication-cursor-and-last-received-hold>` on the sending side.

 .. _prune-keep-retention-grid:

@@ -107,7 +106,7 @@ The following procedure happens during pruning:
 #. All subsequent buckets are placed adjacent to their predecessor bucket.
 #. Now each snapshot on the axis either falls into one bucket or it is older than our rightmost bucket.
   Buckets are left-inclusive and right-exclusive which means that a snapshot on the edge of bucket will always 'fall into the right one'.
-#. Snapshots older than the rightmost bucket are **not kept** by the grid specification.
+#. Snapshots older than the rightmost bucket **not kept** by this gridspec.
 #. For each bucket, we only keep the ``keep`` oldest snapshots.

 The syntax to describe the bucket list is as follows:
@@ -125,51 +124,43 @@ The syntax to describe the bucket list is as follows:

 ::

-   Assume the following grid specification:
+          This grid spec produces the following list of adjacent buckets. For the sake of simplicity,
+          we subject all snapshots to the grid pruning policy by settings `regex: .*`.

-      grid: 1x1h(keep=all) | 2x2h | 1x3h
+          `
+           grid: 1x1h(keep=all) | 2x2h | 1x3h
+           regex: .*
+          `

-   This grid specification produces the following constellation of buckets:
-
-   0h        1h        2h        3h        4h        5h        6h        7h        8h        9h
-   |         |         |         |         |         |         |         |         |         |
-   |-Bucket1-|-----Bucket2-------|------Bucket3------|-----------Bucket4-----------|
-   | keep=all|      keep=1       |       keep=1      |            keep=1           |
+          0h        1h        2h        3h        4h        5h        6h        7h        8h        9h
+          |         |         |         |         |         |         |         |         |         |
+          |-Bucket1-|-----Bucket 2------|------Bucket 3-----|-----------Bucket 4----------|
+          | keep=all|      keep=1       |       keep=1      |            keep=1           |



-   Now assume that we have a set of snapshots @a, @b, ..., @D.
-   Snapshot @a is the most recent snapshot.
-   Snapshot @D is the oldest snapshot, it is almost 9 hours older than snapshot @a.
-   We place the snapshots on the same timeline as the buckets:
+          Let us consider the following set of snapshots @a-zA-C:


-   0h        1h        2h        3h        4h        5h        6h        7h        8h        9h
-   |         |         |         |         |         |         |         |         |         |
-   |-Bucket1-|-----Bucket2-------|------Bucket3------|-----------Bucket4-----------|
-   | keep=all|      keep=1       |       keep=1      |            keep=1           |
-   |         |                   |                   |                             |
-   | a  b  c | d  e  f  g  h  i  j  k  l  m  n  o  p |q  r  s  t  u  v  w  x  y  z |A  B  C  D
+          |  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z  A  B  C  D        |

-   We obtain the following mapping of snapshots to buckets:
+          The `grid` algorithm maps them to their respective buckets:

-   Bucket1:   a,b,c
-   Bucket2:   d,e,f,g,h,i
-   Bucket3:   j,k,l,m,n,o,p
-   Bucket4:   q,r,s,t,u,v,w,x,y,z
-   No bucket: A,B,C,D
+          Bucket 1: a, b, c
+          Bucket 2: d,e,f,g,h,i,j
+          Bucket 3: k,l,m,n,o,p
+          Bucket 4: q,r, q,r,s,t,u,v,w,x,y,z
+          None:     A,B,C,D

-   For each bucket, we now prune snapshots until it only contains `keep` snapshots.
-   Newer snapshots are destroyed first.
-   Snapshots that do not fall into a bucket are always destroyed.
+          It then applies the per-bucket pruning logic described above which resulting in the
+          following list of remaining snapshots.

-   Result after pruning:
+          |  a  b  c                    j                 p                             z                    |
+
+          Note that it only makes sense to grow (not shorten) the interval duration for buckets
+          further in the past since each bucket acts like a low-pass filter for incoming snapshots
+          and adding a less-low-pass-filter after a low-pass one has no effect.

-   0h        1h        2h        3h        4h        5h        6h        7h        8h        9h
-   |         |         |         |         |         |         |         |         |         |
-   |-Bucket1-|-----Bucket2-------|------Bucket3------|-----------Bucket4-----------|
-   |         |                   |                   |                             |
-   | a  b  c |                i  |                 p |                           z |

 .. _prune-keep-last-n:

@@ -1,6 +1,5 @@
 .. include:: ../global.rst.inc

-.. _replication-options:

 Replication Options
 ===================
@@ -36,12 +36,9 @@ See the `upstream man page <https://openzfs.github.io/openzfs-docs/man/8/zfs-sen
    * - ``encrypted``
      -
      - Specific to zrepl, :ref:`see below <job-send-options-encrypted>`.
-    * - ``bandwidth_limit``
-      -
-      - Specific to zrepl, :ref:`see below <job-send-recv-options--bandwidth-limit>`.
    * - ``raw``
      - ``-w``
-      - Use ``encrypted`` to only allow encrypted sends. Mixed sends are not supported.
+      - Use ``encrypted`` to only allow encrypted sends.
    * - ``send_properties``
      - ``-p``
      - **Be careful**, read the :ref:`note on property replication below <job-note-property-replication>`.
@@ -54,7 +51,7 @@ See the `upstream man page <https://openzfs.github.io/openzfs-docs/man/8/zfs-sen
    * - ``compressed``
      - ``-c``
      -
-    * - ``embedded_data``
+    * - ``embbeded_data``
      - ``-e``
      -
    * - ``saved``
@@ -141,16 +138,8 @@ Recv Options
         override: {
           "org.openzfs.systemd:ignore": "on"
         }
-       bandwidth_limit: ...
-       placeholder:
-         encryption: unspecified | off | inherit
     ...

-Jump to
-:ref:`properties <job-recv-options--inherit-and-override>` ,
-:ref:`bandwidth_limit <job-send-recv-options--bandwidth-limit>` , and
-:ref:`placeholder <job-recv-options--placeholder>`.
-
 .. _job-recv-options--inherit-and-override:

 ``properties``
@@ -197,8 +186,11 @@ Mount behaviour
 * ``canmount``
 * ``overlay``

-Note: Before `OpenZFS 2.0.5 <https://github.com/openzfs/zfs/issues/11416>`_, inheriting or overriding the ``mountpoint`` property on ZVOLs fails in ``zfs recv``.
-If you are on such an older version, consider creating separate zrepl jobs for your ZVOL and filesystem datasets.
+Note: inheriting or overriding the ``mountpoint`` property on ZVOLs fails in ``zfs recv``.
+This is an `issue in OpenZFS <https://github.com/openzfs/zfs/issues/11416>`_ .
+As a workaround, consider creating separate zrepl jobs for your ZVOL and filesystem datasets.
+Please comment at zrepl :issue:`430` if you encounter this issue and/or would like zrepl to automatically work around it.
+

 Systemd
 -------
@@ -220,60 +212,3 @@ and property replication is enabled, the receiver must :ref:`inherit the followi
 * ``keylocation``
 * ``keyformat``
 * ``encryption``
-
-.. _job-recv-options--placeholder:
-
-Placeholders
-~~~~~~~~~~~~
-
-::
-
-   placeholder:
-     encryption: unspecified | off | inherit
-
-During replication, zrepl :ref:`creates placeholder datasets <replication-placeholder-property>` on the receiving side if the sending side's ``filesystems`` filter creates gaps in the dataset hierarchy.
-This is generally fully transparent to the user.
-However, with OpenZFS Native Encryption, placeholders require zrepl user attention.
-Specifically, the problem is that, when zrepl attempts to create the placeholder dataset on the receiver, and that placeholder's parent dataset is encrypted, ZFS wants to inherit encryption to the placeholder.
-This is relevant to two use cases that zrepl supports:
-
-1. **encrypted-send-to-untrusted-receiver** In this use case, the sender sends an :ref:`encrypted send stream <job-send-options-encrypted>` and the receiver doesn't have the key loaded.
-2. **send-plain-encrypt-on-receive** The receive-side ``root_fs`` dataset is encrypted, and the senders are unencrypted.
-   The key of ``root_fs`` is loaded, and the goal is that the plain sends (e.g., from production) are encrypted on-the-fly during receive, with ``root_fs``'s key.
-
-For **encrypted-send-to-untrusted-receiver**, the placeholder datasets need to be created with ``-o encryption=off``.
-Without it, creation would fail with an error, indicating that the placeholder's parent dataset's key needs to be loaded.
-But we don't trust the receiver, so we can't expect that to ever happen.
-
-However, for **send-plain-encrypt-on-receive**, we cannot set ``-o encryption=off``.
-The reason is that if we did, any of the (non-placeholder) child datasets below the placeholder would inherit ``encryption=off``, thereby silently breaking our encrypt-on-receive use case.
-So, to cover this use case, we need to create placeholders without specifying ``-o encryption``.
-This will make ``zfs create`` inherit the encryption mode from the parent dataset, and thereby transitively from ``root_fs``.
-
-The zrepl config provides the `recv.placeholder.encryption` knob to control this behavior.
-In ``undefined`` mode (default), placeholder creation bails out and asks the user to configure a behavior.
-In ``off`` mode, the placeholder is created with ``encryption=off``, i.e., **encrypted-send-to-untrusted-rceiver** use case.
-In ``inherit`` mode, the placeholder is created without specifying ``-o encryption`` at all, i.e., the **send-plain-encrypt-on-receive** use case.
-
-
-Common Options
-~~~~~~~~~~~~~~
-
-.. _job-send-recv-options--bandwidth-limit:
-
-Bandwidth Limit (send & recv)
-----------------------------
-
-::
-
-   bandwidth_limit:
-     max: 23.5 MiB # -1 is the default and disabled rate limiting
-     bucket_capacity: # token bucket capacity in bytes; defaults to 128KiB
-
-Both ``send`` and ``recv`` can be limited to a maximum bandwidth through ``bandwidth_limit``.
-For most users, it should be sufficient to just set ``bandwidth_limit.max``.
-The ``bandwidth_limit.bucket_capacity`` refers to the `token bucket size <https://github.com/juju/ratelimit>`_.
-
-The bandwidth limit only applies to the payload data, i.e., the ZFS send stream.
-It does not account for transport protocol overheads.
-The scope is the job level, i.e., all :ref:`concurrent <replication-option-concurrency>` sends or incoming receives of a job share the bandwidth limit.
@@ -5,138 +5,53 @@
 Taking Snaphots
 ===============

-You can configure zrepl to take snapshots of the filesystems in the ``filesystems`` field specified in ``push``, ``source`` and ``snap`` jobs.
+The ``push``, ``source`` and ``snap`` jobs can automatically take periodic snapshots of the filesystems matched by the ``filesystems`` filter field.
+The snapshot names are composed of a user-defined prefix followed by a UTC date formatted like ``20060102_150405_000``.
+We use UTC because it will avoid name conflicts when switching time zones or between summer and winter time.

-The following snapshotting types are supported:
-
-
-.. list-table::
-    :widths: 20 70
-    :header-rows: 1
-
-    * - ``snapshotting.type``
-      - Comment
-    * - ``periodic``
-      - Ensure that snapshots are taken at a particular interval.
-    * - ``cron``
-      - Use cron spec to take snapshots at particular points in time.
-    * - ``manual``
-      - zrepl does not take any snapshots by itself.
-
-The ``periodic`` and ``cron`` snapshotting types share some common options and behavior:
-
-* **Naming:** The snapshot names are composed of a user-defined ``prefix`` followed by a UTC date formatted like ``20060102_150405_000``.
-  We use UTC because it will avoid name conflicts when switching time zones or between summer and winter time.
-* **Hooks:** You can configure hooks to run before or after zrepl takes the snapshots. See :ref:`below <job-snapshotting-hooks>` for details.
-* **Push replication:** After creating all snapshots, the snapshotter will wake up the replication part of the job, if it's a ``push`` job.
-  Note that snapshotting is decoupled from replication, i.e., if it is down or takes too long, snapshots will still be taken.
-  Note further that other jobs are not woken up by snapshotting.
-
-.. NOTE::
-
-   There is **no concept of ownership** of the snapshots that are created by ``periodic`` or ``cron``.
-   Thus, there is no distinction between zrepl-created snapshots and user-created snapshots during replication or pruning.
-
-   In particular, pruning will take all snapshots into consideration by default.
-   To constrain pruning to just zrepl-created snapshots:
-
-     1. Assign a unique `prefix` to the snapshotter and
-     2. Use the ``regex`` functionality of the various pruning ``keep`` rules to just consider snapshots with that prefix.
-
-  There is currently no way to constrain replication to just zrepl-created snapshots.
-  Follow and comment at :issue:`403` if you need this functionality.
-
-.. NOTE::
-
-  The ``zrepl signal wakeup JOB`` subcommand does not trigger snapshotting.
-
-``periodic`` Snapshotting
-------------------------
-
-::
-
-   jobs:
-   - ...
-     filesystems: { ... }
-     snapshotting:
-       type: periodic
-       prefix: zrepl_
-       interval: 10m
-       # Timestamp format that is used as snapshot suffix.
-       # Can be any of "dense" (default), "human", "iso-8601", "unix-seconds" or a custom Go time format (see https://go.dev/src/time/format.go)
-       timestamp_format: dense
-       hooks: ...
-    pruning: ...
-
-The ``periodic`` snapshotter ensures that snapshots are taken in the specified ``interval``.
-If you use zrepl for backup, this translates into your recovery point objective (RPO).
-To meet your RPO, you still need to monitor that replication, which happens asynchronously to snapshotting, actually works.
-
-It is desirable to get all ``filesystems`` snapshotted simultaneously because it results in a more consistent backup.
-To accomplish this while still maintaining the ``interval``, the ``periodic`` snapshotter attempts to get the snapshotting rhythms in sync.
-To find that sync point, the most recent snapshot, created by the snapshotter, in any of the matched ``filesystems`` is used.
+When a job is started, the snapshotter attempts to get the snapshotting rhythms of the matched ``filesystems`` in sync because snapshotting all filesystems at the same time results in a more consistent backup.
+To find that sync point, the most recent snapshot, made by the snapshotter, in any of the matched ``filesystems`` is used.
 A filesystem that does not have snapshots by the snapshotter has lower priority than filesystem that do, and thus might not be snapshotted (and replicated) until it is snapshotted at the next sync point.
-The snapshotter uses the ``prefix`` to identify which snapshots it created.

-.. _job-snapshotting--cron:
+For ``push`` jobs, replication is automatically triggered after all filesystems have been snapshotted.
+
+Note that the ``zrepl signal replication JOB`` subcommand does not trigger snapshotting.

-``cron`` Snapshotting
---------------------

 ::

-   jobs:
-   - type: snap
-     filesystems: { ... }
-     snapshotting:
-       type: cron
-       prefix: zrepl_
-       # (second, optional) minute hour day-of-month month day-of-week
-       # This example takes snapshots daily at 3:00.
-       cron: "0 3 * * *"
-       # Timestamp format that is used as snapshot suffix.
-       # Can be any of "dense" (default), "human", "iso-8601", "unix-seconds" or a custom Go time format (see https://go.dev/src/time/format.go)
-       timestamp_format: dense
-     pruning: ...
+    jobs:
+    - type: push
+      filesystems: {
+        "<": true,
+        "tmp": false
+      }
+      snapshotting:
+        type: periodic
+        prefix: zrepl_
+        interval: 10m
+        hooks: ...
+      ...

-In ``cron`` mode, the snapshotter takes snaphots at fixed points in time.
-See https://en.wikipedia.org/wiki/Cron for details on the syntax.
-zrepl uses the ``the github.com/robfig/cron/v3`` Go package for parsing.
-An optional field for "seconds" is supported to take snapshots at sub-minute frequencies.
+There is also a ``manual`` snapshotting type, which covers the following use cases:

-.. _job-snapshotting-timestamp_format:
+* Existing infrastructure for automatic snapshots: you only want to use this zrepl job for replication.
+* Handling snapshotting through a separate ``snap`` job.

-Timestamp Format
-~~~~~~~~~~~~~~~~
-
-The ``cron`` and ``periodic`` snapshotter support configuring a custom timestamp format that is used as suffix for the snapshot name.
-It can be used by setting ``timestamp_format`` to any of the following values:
-
-* ``dense`` (default) looks like ``20060102_150405_000``
-* ``human`` looks like ``2006-01-02_15:04:05``
-* ``iso-8601`` looks like ``2006-01-02T15:04:05.000Z``
-* ``unix-seconds`` looks like ``1136214245``
-* Any custom Go time format accepted by `time.Time#Format <https://go.dev/src/time/format.go>`_.
-
-
-``manual`` Snapshotting
-----------------------
+Note that you will have to trigger replication manually using the ``zrepl signal replication JOB`` subcommand in that case.

 ::

   jobs:
   - type: push
+     filesystems: {
+       "<": true,
+       "tmp": false
+     }
     snapshotting:
       type: manual
     ...

-In ``manual`` mode, zrepl does not take snapshots by itself.
-Manual snapshotting is most useful if you have existing infrastructure for snapshot management.
-Or, if you want to decouple snapshot management from replication using a zrepl ``snap`` job.
-See :ref:`this quickstart guide <quickstart-backup-to-external-disk>` for an example.
-
-To trigger replication after taking snapshots, use the ``zrepl signal wakeup JOB`` command.
-
 .. _job-snapshotting-hooks:

 Pre- and Post-Snapshot Hooks
@@ -1,15 +1,7 @@
 #!/usr/bin/env python3

-from pathlib import Path
 import subprocess
 import re
-import argparse
-import distutils
-
-argparser = argparse.ArgumentParser()
-argparser.add_argument("docsroot")
-argparser.add_argument("outdir")
-args = argparser.parse_args()

 output = subprocess.run(["git", "tag", "-l"], capture_output=True, check=True, text=True)
 tagRE = re.compile(r"^v(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(-rc(?P<rc>\d+))?$")
@@ -35,8 +27,8 @@ for line in output.stdout.split("\n"):

    t = Tag()
    t.orig = line
-    t.major = int(m["major"])
-    t.minor = int(m["minor"])
+    t.major = int(m["major"])   
+    t.minor = int(m["minor"])   
    t.patch = int(m["patch"])
    t.rc = int(m["rc"] if m["rc"] is not None else 0)

@@ -57,16 +49,26 @@ for (mm, l) in by_major_minor.items():
    latest_by_major_minor.append(l[-1])
 latest_by_major_minor.sort(key=lambda tag: (tag.major, tag.minor))

-cmdline = [
-    "sphinx-multiversion",
-    "-D", "smv_tag_whitelist=^({})$".format("|".join([re.escape(tag.orig) for tag in latest_by_major_minor])),
-    "-D", "smv_branch_whitelist=^(master|stable)$",
-    "-D", "smv_remote_whitelist=^.*$",
-    "-D", "smv_latest_version=stable",
-    "-D", r"smv_released_pattern=^refs/(tags|heads|remotes/[^/]+)/(?!master).*$", # treat everything except master as released, that way, the banner message makes sense
-    # "--dump-metadata", # for debugging
-    args.docsroot,
-    args.outdir,
-]
-print(cmdline)
-subprocess.run(cmdline, check=True)
+# print(by_major_minor)
+# print(latest_by_major_minor)
+
+cmdline = []
+
+for latest_patch in latest_by_major_minor:
+    cmdline.append("--whitelist-tags")
+    cmdline.append(f"^{re.escape(latest_patch.orig)}$")
+
+# we want flexibility to update docs for the latest stable release
+# => we have a branch for that, called `stable` which we move manually
+# TODO: in the future, have f"stable-{latest_by_major_minor[-1]}"
+default_version = "stable"
+cmdline.extend(["--whitelist-branches", default_version])
+
+cmdline.extend(["--root-ref", f"{default_version}"])
+cmdline.extend(["--banner-main-ref", f"{default_version}"])
+cmdline.extend(["--show-banner"])
+cmdline.extend(["--sort", "semver"])
+
+cmdline.extend(["--whitelist-branches", "master"])
+
+print(" ".join(cmdline))
@@ -5,7 +5,7 @@

 .. |GitHub license| image:: https://img.shields.io/github/license/zrepl/zrepl.svg
   :target: https://github.com/zrepl/zrepl/blob/master/LICENSE
-.. |Language: Go| image:: https://img.shields.io/badge/lang-Go-6ad7e5.svg
+.. |Language: Go| image:: https://img.shields.io/badge/language-Go-6ad7e5.svg
   :target: https://golang.org/
 .. |User Docs| image:: https://img.shields.io/badge/docs-web-blue.svg
   :target: https://zrepl.github.io
@@ -13,21 +13,18 @@
   :target: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=R5QSXJVYHGX96
 .. |Donate via Liberapay| image:: https://img.shields.io/liberapay/patrons/zrepl.svg?logo=liberapay
   :target: https://liberapay.com/zrepl/donate
-.. |Donate via Patreon| image:: https://img.shields.io/badge/dynamic/json?color=yellow&label=Patreon&query=data.attributes.patron_count&url=https%3A%2F%2Fwww.patreon.com%2Fapi%2Fcampaigns%2F3095079
+.. |Donate via Patreon| image:: https://img.shields.io/badge/dynamic/json?color=yellow&label=Patreon&query=data.attributes.patron_count&suffix=%20patrons&url=https%3A%2F%2Fwww.patreon.com%2Fapi%2Fcampaigns%2F3095079
   :target: https://www.patreon.com/zrepl
 .. |Donate via GitHub Sponsors| image:: https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=yellow
   :target: https://github.com/sponsors/problame
 .. |Twitter| image:: https://img.shields.io/twitter/url/https/github.com/zrepl/zrepl.svg?style=social
   :target: https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fzrepl%2Fzrepl
-.. |Matrix| image:: https://img.shields.io/badge/chat-matrix-blue.svg
-   :target: https://matrix.to/#/#zrepl:matrix.org
+

 .. |serve-transport| replace:: :ref:`serve specification<transport>`
 .. |connect-transport| replace:: :ref:`connect specification<transport>`
 .. |send-options| replace:: :ref:`send options<job-send-options>`, e.g. for encrypted sends
 .. |recv-options| replace:: :ref:`recv options<job-recv-options>`
-.. |replication-options| replace:: :ref:`replication options<replication-options>`
-.. |conflict-resolution-options| replace:: :ref:`conflict resolution options<conflict_resolution-options>`
 .. |snapshotting-spec| replace:: :ref:`snapshotting specification <job-snapshotting-spec>`
 .. |pruning-spec| replace:: :ref:`pruning specification <prune>`
 .. |filter-spec| replace:: :ref:`filter specification<pattern-filter>`
@@ -5,7 +5,7 @@

 .. include:: global.rst.inc

-|GitHub license| |Language: Go| |Twitter| |Donate via Patreon| |Donate via GitHub Sponsors| |Donate via Liberapay| |Donate via PayPal| |Matrix|
+|GitHub license| |Language: Go| |Twitter| |Donate via Patreon| |Donate via GitHub Sponsors| |Donate via Liberapay| |Donate via PayPal|


 zrepl - ZFS replication
@@ -25,10 +25,10 @@ zrepl - ZFS replication
         Progress: [=========================\----] 246.7 MiB / 264.7 MiB @ 11.5 MiB/s
           zroot              STEPPING (step 1/2, 624 B/1.2 KiB) next: @a => @b
           zroot/ROOT         DONE (step 2/2, 1.2 KiB/1.2 KiB)
-         * zroot/ROOT/default STEPPING (step 1/2, 123.4 MiB/129.3 MiB) next: @a => @b
+           zroot/ROOT/default STEPPING (step 1/2, 123.4 MiB/129.3 MiB) next: @a => @b
           zroot/tmp          STEPPING (step 1/2, 29.9 KiB/44.2 KiB) next: @a => @b
           zroot/usr          STEPPING (step 1/2, 624 B/1.2 KiB) next: @a => @b
-         * zroot/usr/home     STEPPING (step 1/2, 123.3 MiB/135.3 MiB) next: @a => @b
+           zroot/usr/home     STEPPING (step 1/2, 123.3 MiB/135.3 MiB) next: @a => @b
           zroot/var          STEPPING (step 1/2, 624 B/1.2 KiB) next: @a => @b
           zroot/var/audit    DONE (step 2/2, 1.2 KiB/1.2 KiB)
           zroot/var/crash    DONE (step 2/2, 1.2 KiB/1.2 KiB)
@@ -66,7 +66,6 @@ Main Features
    * [x] Large blocks send & receive
    * [x] Embedded data send & receive
    * [x] Resume state send & receive
-    * [x] Bandwidth limiting

 * **Automatic snapshot management**

@@ -137,6 +136,5 @@ Table of Contents
   pr
   changelog
   GitHub Repository & Issue Tracker <https://github.com/zrepl/zrepl>
-   Chat: Matrix <https://matrix.to/#/#zrepl:matrix.org>
   supporters

@@ -9,29 +9,18 @@ The fingerprint of the signing key is ``E101 418F D3D6 FBCB 9D65  A62D 7086 99FC
 It is available at `<https://zrepl.cschwarz.com/apt/apt-key.asc>`_ .
 Please open an issue in on GitHub if you encounter any issues with the repository.

+The following snippet configure the repository for your Debian or Ubuntu release:
+
 ::

-    (
-    set -ex
-    zrepl_apt_key_url=https://zrepl.cschwarz.com/apt/apt-key.asc
-    zrepl_apt_key_dst=/usr/share/keyrings/zrepl.gpg
-    zrepl_apt_repo_file=/etc/apt/sources.list.d/zrepl.list
+    apt update && apt install curl gnupg lsb-release; \
+    ARCH="$(dpkg --print-architecture)"; \
+    CODENAME="$(lsb_release -i -s | tr '[:upper:]' '[:lower:]') $(lsb_release -c -s | tr '[:upper:]' '[:lower:]')"; \
+    echo "Using Distro and Codename: $CODENAME"; \
+    (curl https://zrepl.cschwarz.com/apt/apt-key.asc | apt-key add -) && \
+    (echo "deb [arch=$ARCH] https://zrepl.cschwarz.com/apt/$CODENAME main" > /etc/apt/sources.list.d/zrepl.list) && \
+    apt update

-    # Install dependencies for subsequent commands
-    sudo apt update && sudo apt install curl gnupg lsb-release
-
-    # Deploy the zrepl apt key.
-    curl -fsSL "$zrepl_apt_key_url" | tee | gpg --dearmor | sudo tee "$zrepl_apt_key_dst" > /dev/null
-
-    # Add the zrepl apt repo.
-    ARCH="$(dpkg --print-architecture)"
-    CODENAME="$(lsb_release -i -s | tr '[:upper:]' '[:lower:]') $(lsb_release -c -s | tr '[:upper:]' '[:lower:]')"
-    echo "Using Distro and Codename: $CODENAME"
-    echo "deb [arch=$ARCH signed-by=$zrepl_apt_key_dst] https://zrepl.cschwarz.com/apt/$CODENAME main" | sudo tee /etc/apt/sources.list.d/zrepl.list
-
-    # Update apt repos.
-    sudo apt update
-    )

 .. NOTE::

@@ -93,7 +93,6 @@ Enable the zrepl daemon to start automatically at boot:

   sysrc zrepl_enable="YES"

-Now jump to :ref:`the summary <installation-freebsd-jail-summary>` below.

 Plugin
 ######
@@ -135,18 +134,7 @@ Now ``zrepl`` can be started.

   service zrepl start

-Now jump to :ref:`the summary <installation-freebsd-jail-summary>` below.
-
-.. _installation-freebsd-jail-summary:
-
 Summary
 -------

 Congratulations, you have a working jail!
-
-.. NOTE::
-
-   With FreeBSD 13's transition to OpenZFS 2.0, please ensure that your jail's FreeBSD version matches the one in the kernel module.
-   If you are getting cryptic errors such as
-   ``cannot receive new filesystem stream: invalid backup stream``
-   the instructions posted `here <https://github.com/zrepl/zrepl/issues/500#issuecomment-966215205>`_ might help.
@@ -15,5 +15,3 @@ Talks & Presentations
  `Event <https://wiki.freebsd.org/DevSummit/201709>`__
  )

-  * Note: The remarks on ``keep_bookmarks`` are irrelevant as of zrepl 0.1 which introduced the zrepl-managed replication cursor bookmark.
-    Read the `Overview <overview-how-replication-works>`_ section to learn more.
@@ -1,10 +1,10 @@
 #!/bin/bash
-set -euo pipefail
+set -eo pipefail
+

 NON_INTERACTIVE=false
 DO_CLONE=false
-PUSH=false
-while getopts "caP" arg; do
+while getopts "ca" arg; do
    case "$arg" in
        "a")
            NON_INTERACTIVE=true
@@ -12,11 +12,8 @@ while getopts "caP" arg; do
        "c")
            DO_CLONE=true
            ;;
-        "P")
-            PUSH=true
-            ;;
        *)
-            echo "invalid option '-$arg'"
+            echo invalid option
            exit 1
            ;;
    esac
@@ -30,8 +27,13 @@ checkout_repo_msg() {
    echo "clone ${GHPAGESREPO} to ${PUBLICDIR}:"
 }

-if ! type sphinx-multiversion >/dev/null; then
-    echo "install sphinx-multiversion and come back"
+exit_msg() {
+    echo "error, exiting..."
+}
+trap exit_msg EXIT
+
+if ! type sphinx-versioning >/dev/null; then
+    echo "install sphinx-versioning and come back"
    exit 1
 fi

@@ -53,11 +55,11 @@ else
    read -r
 fi

-pushd "$PUBLICDIR"
+pushd "$PUBLICDIR" 

 echo "verify we're in the GitHub pages repo..."
 git remote get-url origin | grep -E "^${GHPAGESREPO}\$"
-if [ "$?" -ne "0" ] ;then
+if [ "$?" -ne "0" ] ;then 
    checkout_repo_msg
    echo "finished checkout, please run again"
    exit 1
@@ -69,39 +71,32 @@ git reset --hard origin/master

 echo "cleaning GitHub pages repo"
 git rm -rf .
-cat > .gitignore <<EOF
-**/.doctrees
-EOF

 popd

 echo "building site"

-python3 run-sphinx-multiversion.py . ./public_git
-
+flags="$(python3 gen-sphinx-versioning-flags.py)"
+set -e
+sphinx-versioning build \
+   $flags \
+   docs ./public_git \
+   -- -c sphinxconf # older conf.py throw errors because they used
+                    # version = subprocess.show_output(["git", "describe"])
+                    # which fails when building with sphinxcontrib-versioning
+set +e

 CURRENT_COMMIT=$(git rev-parse HEAD)
 git status --porcelain
 if [[ "$(git status --porcelain)" != "" ]]; then
-    CURRENT_COMMIT="${CURRENT_COMMIT}(dirty)"
+    CURRENT_COMMIT="${CURRENT_COMMIT}(dirty)" 
 fi
-COMMIT_MSG="render from publish.sh - $(date -u) - ${CURRENT_COMMIT}"
+COMMIT_MSG="sphinx-versioning render from publish.sh - $(date -u) - ${CURRENT_COMMIT}"

 pushd "$PUBLICDIR"

 echo "adding and commiting all changes in GitHub pages repo"
-git add .gitignore
 git add -A
-if [ "$(git status --porcelain)" != "" ]; then
-    git commit -m "$COMMIT_MSG"
-else
-    echo "nothing to commit"
-fi
-
-if $PUSH; then
-    echo "pushing to GitHub pages repo"
-    git push origin master
-else
-    echo "not pushing to GitHub pages repo, set -P flag to push"
-fi
+git commit -m "$COMMIT_MSG"
+git push origin master

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Christian Schwarz	5976264bce	WIP	2021-04-16 10:10:16 +02:00
Christian Schwarz	f28676b8d7	WIP: extract logic for WaitForTrigger, Trigger, Reset, Poll into a reusable abstraction	2021-03-24 00:20:47 +01:00
Christian Schwarz	3e6cae1c8f	forgotten client/reset.go	2021-03-23 00:00:03 +01:00
Christian Schwarz	a4a2cb2833	WIP: reset handling, unified wait token TODO: task-level invocations (replication, snapshotting, pruning)	2021-03-21 23:47:37 +01:00
Christian Schwarz	97a14dba90	WIP PoC signalling	2021-03-21 21:57:26 +01:00
Christian Schwarz	40be626b3a	zrepl wait: poll-based implementation	2021-03-21 19:57:33 +01:00
Christian Schwarz	68b895d0bc	WIP: zrepl wait active JOB INVOCATION_ID WHAT (callback-based implementation)	2021-03-21 19:00:59 +01:00