trace: test for main API, fix bugs discovered by them

endpoint.ListAbstractionsError: fix stack overflow in .Error()
fixes #320 refs #318
2020-05-15 19:13:49 +02:00 · 2020-05-09 11:59:25 +02:00 · 2020-05-03 17:50:24 +02:00 · 2020-05-01 23:39:06 +02:00 · 2020-05-01 22:46:24 +02:00 · 2020-04-25 12:49:04 +02:00
472 changed files with 10206 additions and 22231 deletions
@@ -1,316 +1,145 @@
-version: 2.1
+version: 2.0
 orbs:
  # NB: this 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.11.0
 commands:
  setup-home-local-bin:
    steps:
      - run:
          shell: /bin/bash -euo pipefail
          command: |
            mkdir -p "$HOME/.local/bin"
            line='export PATH="$HOME/.local/bin:$PATH"'
            if grep "$line" $BASH_ENV >/dev/null; then
              echo "$line" >> $BASH_ENV
            fi
  # NOTE: UV version is defined in .uv-version file at repository root
  install-docdep:
    steps:
      - run:
          name: Read UV version from .uv-version
          command: |
            UV_VERSION=$(cat .uv-version)
            echo "export UV_VERSION=$UV_VERSION" >> $BASH_ENV
      # Python is managed by uv - it will automatically download the version
      # specified in docs/.python-version when needed
      - run:
          name: Install uv
          command: curl -LsSf https://astral.sh/uv/${UV_VERSION}/install.sh | sh
      - run:
          name: Add uv to PATH and set cache dir
          command: |
            echo 'export PATH="$HOME/.local/bin:$PATH"' >> $BASH_ENV
            echo 'export UV_CACHE_DIR="$HOME/.cache/uv"' >> $BASH_ENV
      - restore_cache:
          name: Restore uv cache
          keys:
            - uv-cache-v1-${UV_VERSION}-{{ checksum "docs/uv.lock" }}
            - uv-cache-v1-${UV_VERSION}-
  save-uv-cache:
    steps:
      - run:
          name: Prune uv cache for CI
          command: uv cache prune --ci
      - save_cache:
          name: Save uv cache
          key: uv-cache-v1-${UV_VERSION}-{{ checksum "docs/uv.lock" }}
          paths:
            - ~/.cache/uv
  docs-publish-sh:
    parameters:
      push:
        type: boolean
    steps:
      - checkout
      - run:
          command: |
            git config --global user.email "zreplbot@cschwarz.com"
            git config --global user.name "zrepl-github-io-ci"
      # Configure git to use the GitHub token for HTTPS authentication.
      # The token is stored in the 'zrepl-github-io-deploy' context.
      - when:
          condition: << parameters.push >>
          steps:
            - run:
                name: Configure git to use GitHub token for push
                # GITHUB_PAGES_TOKEN is from the 'zrepl-github-io-deploy' context.
                # CircleCI's secret masking automatically redacts context variables in logs.
                command: |
                  # Unset CircleCI's SSH URL rewriting that checkout step configured
                  git config --global --unset-all url."ssh://git@github.com".insteadOf || true
                  # Set up credential helper with GitHub token
                  git config --global credential.helper store
                  echo "https://x-access-token:${GITHUB_PAGES_TOKEN}@github.com" > ~/.git-credentials
                  chmod 600 ~/.git-credentials
      # 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
 parameters:
  do_ci:
    type: boolean
    default: true
  do_release:
    type: boolean
    default: false
 workflows:
  version: 2
-
+  build:
  ci:
    when: << pipeline.parameters.do_ci >>
    jobs:
-      - run-docs-publish-sh:
+      - build-1.11
-          name: quickcheck-docs
+      - build-1.12
-          push: false
+      - build-1.13
-      - quickcheck-go:
+      - build-1.14
-          name: quickcheck-go-amd64-linux-1.25.7
+      - build-latest
-          goversion: &latest-go-release "1.25.7"
+      - test-build-in-docker
          goos: linux
          goarch: amd64
      - test-go:
          goversion: *latest-go-release
      - quickcheck-go:
          requires:
            - quickcheck-go-amd64-linux-1.25.7 #quickcheck-go-smoketest.name
          matrix:
            alias: quickcheck-go-matrix
            parameters:
              goversion: [*latest-go-release, "1.24.13"]
              goos: ["linux", "freebsd"]
              goarch: ["amd64", "arm64"]
            exclude:
              # don't re-do quickcheck-go-smoketest
              - goversion: *latest-go-release
                goos: linux
                goarch: amd64
      - platformtest:
          matrix:
            parameters:
              goversion: [*latest-go-release]
              goos: ["linux"]
              goarch: ["amd64"]
              image: ["ubuntu-2204:current", "ubuntu-2404:current"]
          requires:
            - test-go
            - quickcheck-go-<< matrix.goarch >>-<< matrix.goos >>-<< matrix.goversion >>
  release:
    when: << pipeline.parameters.do_release >>
    jobs:
      - release-build
      - release-deb:
          requires:
            - release-build
      - release-rpm:
          requires:
            - release-build
      - release-upload:
          requires:
            - release-build
            - release-deb
            - release-rpm
  publish-zrepl.github.io:
    jobs:
      - run-docs-publish-sh:
          name: publish-zrepl.github.io
          push: true
          context:
            - zrepl-github-io-deploy
          filters:
            branches:
              only:
                - master
 jobs:
-  run-docs-publish-sh:
+
  # build-latest serves as the template
  # we use YAML anchors & aliases to exchange the docker image (and hence Go version used for the build)
  build-latest: &build-latest
    description: Builds zrepl
    parameters:
      push:
        type: boolean
    docker:
      - image: cimg/base:current
    steps:
      - checkout
      - install-docdep
      - docs-publish-sh:
          push: << parameters.push >>
      - save-uv-cache
  quickcheck-go:
    parameters:
      goversion:
        type: string
      goos:
        type: string
      goarch:
        type: string
    docker:
      - image: &cimg_with_modern_go cimg/go:1.25
    environment:
      GOOS: <<parameters.goos>>
      GOARCH: <<parameters.goarch>>
      GOTOOLCHAIN: "go<<parameters.goversion>>"
    steps:
      - checkout
      - go/load-cache:
          key: quickcheck-<<parameters.goversion>>
      - run: make build/install
      - run: go mod download
      - run: cd build && go mod download
      - go/save-cache:
          key: quickcheck-<<parameters.goversion>>
      # ensure all code has been generated
      - run: make generate
      - run: |
          if output=$(git status --porcelain) && [ -z "$output" ]; then
            echo "Working directory clean"
          else
            echo "Uncommitted changes"
            echo ""
            echo "$output"
            exit 1
          fi
      # other checks
      - run: make zrepl-bin test-platform-bin
      - run: make vet
      - run: make lint
      - store_artifacts:
          path: artifacts
      - persist_to_workspace:
          root: .
          paths: [.]
  platformtest:
    parameters:
      goversion:
        type: string
      goos:
        type: string
      goarch:
        type: string
      image:
-        type: string
+        description: "the docker image that the job should use"
    machine:
      image: <<parameters.image>>
    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"
  test-go:
    parameters:
      goversion:
        type: string
    docker:
-      - image: *cimg_with_modern_go
+      - image: circleci/golang:latest
    environment:
-      GOTOOLCHAIN: "go<<parameters.goversion>>"
+      # required by lazy.sh
      TERM: xterm
    working_directory: /go/src/github.com/zrepl/zrepl
    steps:
      - run:
          name: Setup environment variables
          command: |
            # used by pip (for docs)
            echo 'export PATH="$HOME/.local/bin:$PATH"' >> $BASH_ENV
            # we use modules
            echo 'export GO111MODULE=on' >> $BASH_ENV
      - restore_cache:
          keys:
            - source
            - protobuf
      - checkout
      - go/load-cache:
          key: make-test-go
      - run: make test-go
      - go/save-cache:
          key: make-test-go
-  release-build:
+      - save_cache:
-    machine:
+          key: source
      image: &release-vm-image "ubuntu-2404:current"
    resource_class: large
    steps:
      - checkout
      - run: make release-docker
      - persist_to_workspace:
          root: .
          paths: [.]
  release-deb:
    machine:
      image: *release-vm-image
    steps:
      - attach_workspace:
          at: .
      - run: make debs-docker
      - persist_to_workspace:
          root: .
          paths:
-            - "artifacts/*.deb"
+            - ".git"
-
+      
-  release-rpm:
+      # install deps
-    machine:
+      - run: wget https://github.com/protocolbuffers/protobuf/releases/download/v3.6.1/protoc-3.6.1-linux-x86_64.zip
-      image: *release-vm-image
+      - run: echo "6003de742ea3fcf703cfec1cd4a3380fd143081a2eb0e559065563496af27807  protoc-3.6.1-linux-x86_64.zip" | sha256sum -c
-    steps:
+      - run: sudo unzip -d /usr protoc-3.6.1-linux-x86_64.zip
-      - attach_workspace:
+      - save_cache:
-          at: .
+          key: protobuf
      - run: make rpms-docker
      - persist_to_workspace:
          root: .
          paths:
-            - "artifacts/*.rpm"
+            - "/usr/include/google/protobuf"
      - run: sudo apt update && sudo apt install python3 python3-pip libgirepository1.0-dev gawk
      - run: ./lazy.sh devsetup
      - run: make zrepl-bin
      - run: make vet
      - run: make test
      - run: make lint
      - run: make release
  release-upload:
    docker:
      - image: cimg/base:2024.09
    steps:
      - attach_workspace:
          at: .
      - run: make wrapup-and-checksum
      - store_artifacts:
-          path: artifacts/release
+          path: ./artifacts/release
          when: always
      - 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
            # Download and install minio
            curl -sSL https://dl.minio.io/client/mc/release/linux-amd64/mc -o ${GOPATH}/bin/mc
            chmod +x ${GOPATH}/bin/mc
            mc config host add --api s3v4 zrepl-minio https://minio.cschwarz.com ${MINIO_ACCESS_KEY} ${MINIO_SECRET_KEY}
            # Upload artifacts
            echo "$CIRCLE_BUILD_URL" > ./artifacts/release/cirlceci_build_url
            mc cp -r artifacts/release "zrepl-minio/zrepl-ci-artifacts/${CIRCLE_SHA1}/${CIRCLE_JOB}/"
            # Push Artifact Link to GitHub
            REPO="zrepl/zrepl"
            COMMIT="${CIRCLE_SHA1}"
            JOB_NAME="${CIRCLE_JOB}"
            curl "https://api.github.com/repos/$REPO/statuses/$COMMIT?access_token=$GITHUB_COMMIT_STATUS_TOKEN" \
              -H "Content-Type: application/json" \
              -X POST \
              -d '{"context":"zrepl/publish-ci-artifacts", "state": "success", "description":"CI Build Artifacts for '"$JOB_NAME"'", "target_url":"https://minio.cschwarz.com/minio/zrepl-ci-artifacts/'"$COMMIT"'/"}'
  build-1.11:
    <<: *build-latest
    docker:
    - image: circleci/golang:1.11
  build-1.12:
    <<: *build-latest
    docker:
    - image: circleci/golang:1.12
  build-1.13:
    <<: *build-latest
    docker:
    - image: circleci/golang:1.13
  build-1.14:
    <<: *build-latest
    docker:
    - image: circleci/golang:1.14
  # this job tries to mimic the build-in-docker instructions
  # given in docs/installation.rst
  #
  # However, CircleCI doesn't support volume mounts, so we have to copy
  # the source into the build-container by modifying the Dockerfile
  test-build-in-docker:
    description: Check that build-in-docker works
    docker:
      - image: circleci/golang:latest
    environment:
    working_directory: /go/src/github.com/zrepl/zrepl
    steps:
    - checkout
    - setup_remote_docker
    - run:
        name: (hacky) circleci doesn't allow volume mounts, so copy src to container
        command: echo "ADD . /src" >> build.Dockerfile
    - run:
        name: (hacky) commit modified Dockerfile to avoid failing git clean check in Makefile
        command: git -c user.name='circleci' -c user.email='circleci@localhost' commit -m 'CIRCLECI modified Dockerfile with zrepl src' --author 'autoauthor <circleci@localhost>' -- build.Dockerfile
    - run:
        name: build the build image (build deps)
        command: docker build -t zrepl_build -f build.Dockerfile .
    - run:
        name: try compiling
        command: docker run -it zrepl_build make release
@@ -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")
@@ -1,4 +1,3 @@
 github: problame
 patreon: zrepl
 liberapay: zrepl
 custom: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=R5QSXJVYHGX96
@@ -1,9 +0,0 @@
 version: 2
 updates:
  # Docs use Python only for static site generation.
  - package-ecosystem: "pip"
    directory: /docs
    schedule:
      interval: "weekly"
    ignore:
      - dependency-name: "*"
@@ -1,6 +1,5 @@
 # Build
 artifacts/
 build/install.tmp
 # Golang
 vendor/
@@ -1,42 +1,10 @@
 version: "2"
 linters:
  enable:
-    - revive
+  - goimports
-  settings:
+
-    revive:
+issues:
-      rules:
+  exclude-rules:
-        - name: time-equal
+    - path: _test\.go
-  exclusions:
+      linters:
-    generated: lax
+        - errcheck
-    presets:
+
      - comments
      - common-false-positives
      - legacy
      - std-error-handling
    rules:
      - linters:
          - errcheck
        path: _test\.go
      - linters:
          - staticcheck
        text: 'SA9003:'
      - linters:
          - staticcheck
        text: '(QF1001|QF1011|ST1012|QF1008|ST1005|ST1023|QF1003|ST1006|ST1001|QF1004):'
    paths:
      - third_party$
      - builtin$
      - examples$
 formatters:
  enable:
    - goimports
  settings:
    goimports:
      local-prefixes:
        - github.com/zrepl/zrepl
  exclusions:
    generated: lax
    paths:
      - third_party$
      - builtin$
      - examples$
@@ -0,0 +1,70 @@
 dist: xenial
 services:
 - docker
 env: # for allow_failures: https://docs.travis-ci.com/user/customizing-the-build/
 matrix:
  include:
  - language: go
    name: "Build in Docker (docs/installation.rst)"
    script:
    - sudo docker build -t zrepl_build -f build.Dockerfile .
    - |
      sudo docker run -it --rm \
        -v "${PWD}:/go/src/github.com/zrepl/zrepl" \
        --user "$(id -u):$(id -g)" \
        zrepl_build make vendordeps release
  - &zrepl_build_template
    language: go
    go_import_path: github.com/zrepl/zrepl
    before_install:
        - wget https://github.com/protocolbuffers/protobuf/releases/download/v3.6.1/protoc-3.6.1-linux-x86_64.zip
        - echo "6003de742ea3fcf703cfec1cd4a3380fd143081a2eb0e559065563496af27807  protoc-3.6.1-linux-x86_64.zip" | sha256sum -c
        - sudo unzip -d /usr protoc-3.6.1-linux-x86_64.zip
        - ./lazy.sh godep
        - make vendordeps
    script:
      - make
      - make vet
      - make test
      - make lint
      - make artifacts/zrepl-freebsd-amd64
      - make artifacts/zrepl-linux-amd64
      - make artifacts/zrepl-darwin-amd64
    go:
    - "1.11"
  - <<: *zrepl_build_template
    go:
    - "1.12"
  - <<: *zrepl_build_template
    go:
    - "master"
  - &zrepl_docs_template 
    language: python
    python:
    - "3.4"
    install:
    - sudo apt-get install libgirepository1.0-dev
    - pip install -r docs/requirements.txt
    script:
    - make docs
  - <<: *zrepl_docs_template
    python:
    - "3.5"
  - <<: *zrepl_docs_template
    python:
    - "3.6"
  - <<: *zrepl_docs_template
    python:
    - "3.7"
  allow_failures:
  - <<: *zrepl_build_template
    go:
    - "master"
@@ -1 +0,0 @@
 0.9.30
@@ -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,182 +14,65 @@ 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 := CGO_ENABLED=0
+GO_ENV_VARS := GO111MODULE=on
-GO_LDFLAGS := "-X github.com/zrepl/zrepl/internal/version.zreplVersion=$(_ZREPL_VERSION)"
+GO_LDFLAGS := "-X github.com/zrepl/zrepl/version.zreplVersion=$(_ZREPL_VERSION)"
 GO_MOD_READONLY := -mod=readonly
 GO_EXTRA_BUILDFLAGS :=
 GO_BUILDFLAGS := $(GO_MOD_READONLY) $(GO_EXTRA_BUILDFLAGS)
 GO_BUILD := $(GO_ENV_VARS) $(GO) build $(GO_BUILDFLAGS) -ldflags $(GO_LDFLAGS)
-GOCOVMERGE := gocovmerge
+GOLANGCI_LINT := golangci-lint
 RELEASE_GOVERSION ?= go1.25.7
 STRIPPED_GOVERSION := $(subst go,,$(RELEASE_GOVERSION))
 RELEASE_DOCKER_BASEIMAGE ?= golang:$(STRIPPED_GOVERSION)
 RELEASE_DOCKER_CACHEMOUNT :=
 ifneq ($(GOARM),)
 	ZREPL_TARGET_TUPLE := $(GOOS)-$(GOARCH)v$(GOARM)
 else
 	ZREPL_TARGET_TUPLE := $(GOOS)-$(GOARCH)
 endif
 .PHONY: printvars
 printvars:
 	@echo GOOS=$(GOOS)
 	@echo GOARCH=$(GOARCH)
 	@echo GOARM=$(GOARM)
 ifneq ($(RELEASE_DOCKER_CACHEMOUNT),)
 	_RELEASE_DOCKER_CACHEMOUNT := -v $(RELEASE_DOCKER_CACHEMOUNT)/mod:/go/pkg/mod -v $(RELEASE_DOCKER_CACHEMOUNT)/xdg-cache:/.cache/go-build
 .PHONY: release-docker-mkcachemount
 release-docker-mkcachemount:
 	mkdir -p $(RELEASE_DOCKER_CACHEMOUNT)
 	mkdir -p $(RELEASE_DOCKER_CACHEMOUNT)/mod
 	mkdir -p $(RELEASE_DOCKER_CACHEMOUNT)/xdg-cache
 else
 	_RELEASE_DOCKER_CACHEMOUNT :=
 .PHONY: release-docker-mkcachemount
 release-docker-mkcachemount:
 	# nothing to do
 endif
 ##################### PRODUCING A RELEASE #############
-.PHONY: release wrapup-and-checksum check-git-clean sign clean ensure-release-toolchain
+.PHONY: release wrapup-and-checksum check-git-clean sign clean
-ensure-release-toolchain:
+release: clean
-	# ensure the toolchain is actually the one we expect
+	# no cross-platform support for target test
-	test $(RELEASE_GOVERSION) = "$$($(GO_ENV_VARS) $(GO) env GOVERSION)"
+	$(MAKE) test
-
+	$(MAKE) bins-all
 release: ensure-release-toolchain
 	$(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) noarch
-
+	$(MAKE) wrapup-and-checksum
-release-docker: $(ARTIFACTDIR) release-docker-mkcachemount
+	$(MAKE) check-git-clean
-	sed 's/FROM.*!SUBSTITUTED_BY_MAKEFILE/FROM $(RELEASE_DOCKER_BASEIMAGE)/' build/build.Dockerfile > $(ARTIFACTDIR)/build.Dockerfile
+ifeq (SIGN, 1)
-	docker build -t zrepl_release --pull \
+	$(make) sign
 		--build-arg BUILD_UID=$$(id -u) \
 		--build-arg BUILD_GID=$$(id -g) \
 		-f $(ARTIFACTDIR)/build.Dockerfile .
 	docker run --rm -i$$(test -t 0 && echo t) \
 		$(_RELEASE_DOCKER_CACHEMOUNT) \
 		-v $(CURDIR):/src \
 		zrepl_release \
 		make release \
 			GOOS=$(GOOS) GOARCH=$(GOARCH) GOARM=$(GOARM) \
 			ZREPL_VERSION=$(ZREPL_VERSION) ZREPL_PACKAGE_RELEASE=$(ZREPL_PACKAGE_RELEASE) \
 			RELEASE_GOVERSION=$(RELEASE_GOVERSION)
 debs-docker:
 	$(MAKE) _debs_or_rpms_docker _DEB_OR_RPM=deb
 rpms-docker:
 	$(MAKE) _debs_or_rpms_docker _DEB_OR_RPM=rpm
 _debs_or_rpms_docker: # artifacts/_zrepl.zsh_completion artifacts/bash_completion docs zrepl-bin
 	$(MAKE) $(_DEB_OR_RPM)-docker GOOS=linux GOARCH=amd64
 	$(MAKE) $(_DEB_OR_RPM)-docker GOOS=linux GOARCH=arm64
 	$(MAKE) $(_DEB_OR_RPM)-docker GOOS=linux GOARCH=arm GOARM=7
 	$(MAKE) $(_DEB_OR_RPM)-docker GOOS=linux GOARCH=386
 rpm: $(ARTIFACTDIR) # artifacts/_zrepl.zsh_completion artifacts/bash_completion docs zrepl-bin
 	$(eval _ZREPL_RPM_VERSION := $(subst -,.,$(_ZREPL_VERSION)))
 	$(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
 	# see /usr/lib/rpm/platform
 ifeq ($(GOARCH),amd64)
 	$(eval _ZREPL_RPMBUILD_TARGET := x86_64)
 else ifeq ($(GOARCH), 386)
 	$(eval _ZREPL_RPMBUILD_TARGET := i386)
 else ifeq ($(GOARCH), arm64)
 	$(eval _ZREPL_RPMBUILD_TARGET := aarch64)
 else ifeq ($(GOARCH), arm)
 	$(eval _ZREPL_RPMBUILD_TARGET := armv7hl)
 else
 	$(eval _ZREPL_RPMBUILD_TARGET := $(GOARCH))
 endif
-	rpmbuild \
+	@echo "ZREPL RELEASE ARTIFACTS AVAILABLE IN artifacts/release"
 		--build-in-place \
 		--define "_sourcedir $(CURDIR)" \
 		--define "_topdir $(_ZREPL_RPM_TOPDIR_ABS)" \
 		--define "_zrepl_binary_filename zrepl-$(ZREPL_TARGET_TUPLE)" \
 		--target $(_ZREPL_RPMBUILD_TARGET) \
 		-bb "$(_ZREPL_RPM_TOPDIR_ABS)"/SPECS/zrepl.spec
 	cp "$(_ZREPL_RPM_TOPDIR_ABS)"/RPMS/$(_ZREPL_RPMBUILD_TARGET)/zrepl-$(_ZREPL_RPM_VERSION)*.rpm $(ARTIFACTDIR)/
-rpm-docker:
+# expects `release` target to have run before
 	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)
 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)"; \
 		export VERSION="$${VERSION#v}"; \
 		sed -i 's/VERSION/'"$$VERSION"'/' packaging/deb/debian/changelog
 ifeq ($(GOARCH), arm)
 	$(eval  DEB_HOST_ARCH := armhf)
 else ifeq ($(GOARCH), 386)
 	$(eval DEB_HOST_ARCH := i386)
 else
 	$(eval DEB_HOST_ARCH := $(GOARCH))
 endif
 	export ZREPL_DPKG_ZREPL_BINARY_FILENAME=zrepl-$(ZREPL_TARGET_TUPLE); \
 		dpkg-buildpackage -b --no-sign --host-arch $(DEB_HOST_ARCH)
 	cp ../*.deb artifacts/
 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)
 # expects `release`, `deb` & `rpm` targets to have run before
 NOARCH_TARBALL := $(ARTIFACTDIR)/zrepl-noarch.tar
 wrapup-and-checksum:
 	rm -f $(NOARCH_TARBALL)
 	tar --mtime='1970-01-01' --sort=name \
 		--transform 's/$(ARTIFACTDIR)/zrepl-$(_ZREPL_VERSION)-noarch/' \
 		--transform 's#dist#zrepl-$(_ZREPL_VERSION)-noarch/dist#' \
-		--transform 's#internal/config/samples#zrepl-$(_ZREPL_VERSION)-noarch/config#' \
+		--transform 's#config/samples#zrepl-$(_ZREPL_VERSION)-noarch/config#' \
 		-acf $(NOARCH_TARBALL) \
 		$(ARTIFACTDIR)/docs/html \
 		$(ARTIFACTDIR)/bash_completion \
 		$(ARTIFACTDIR)/_zrepl.zsh_completion \
 		$(ARTIFACTDIR)/go_env.txt \
 		dist \
-		internal/config/samples
+		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
@@ -207,142 +90,75 @@ 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:
+##################### BINARIES #####################
-	rm -rf "$(ARTIFACTDIR)"
+.PHONY: bins-all lint test vet zrepl-bin platformtest-bin
 	mkdir -p "$(ARTIFACTDIR)/release"
 	python3 .circleci/download_artifacts.py --prefix 'artifacts/release/' "$(BUILD_NUM)" "$(ARTIFACTDIR)/release"
-##################### MULTI-ARCH HELPERS #####################
+BINS_ALL_TARGETS := zrepl-bin platformtest-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"; }}')
-_run_make_foreach_target_tuple:
+bins-all:
-	if [ "$(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG)" = "" ]; then \
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=freebsd   GOARCH=amd64
-		echo "RUN_MAKE_FOREACH_TARGET_TUPLE_ARG must be set"; \
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=freebsd   GOARCH=386
-		exit 1; \
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=amd64
-	fi
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=arm64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=amd64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=arm     GOARM=7
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=386
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=linux     GOARCH=386
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=arm	  GOARM=7
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=darwin    GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=freebsd   GOARCH=arm64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=solaris   GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=amd64
+ifeq ($(GO_SUPPORTS_ILLUMOS), illumos)
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=arm64
+	$(MAKE) $(BINS_ALL_TARGETS) GOOS=illumos   GOARCH=amd64
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=arm     GOARM=7
+else ifeq ($(GO_SUPPORTS_ILLUMOS), noillumos)
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=linux     GOARCH=386
+	@echo "SKIPPING ILLUMOS BUILD BECAUSE GO VERSION DOESN'T SUPPORT IT"
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=darwin    GOARCH=amd64
+else
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=solaris   GOARCH=amd64
+	@echo "CANNOT DETERMINE WHETHER GO VERSION SUPPORTS GOOS=illumos"; exit 1
-	$(MAKE) $(RUN_MAKE_FOREACH_TARGET_TUPLE_ARG) GOOS=illumos   GOARCH=amd64
+endif
 ##################### REGULAR TARGETS #####################
 .PHONY: lint test-go test-platform cover-merge cover-html vet zrepl-bin test-platform-bin
 lint: build/install
 	$(GO_ENV_VARS) build/install/golangci_lint/golangci-lint run ./...
 lint:
 	$(GO_ENV_VARS) $(GOLANGCI_LINT) run ./...
 test:
 	$(GO_ENV_VARS) $(GO) test $(GO_BUILDFLAGS) ./...
 vet:
 	$(GO_ENV_VARS) $(GO) vet $(GO_BUILDFLAGS) ./...
 test-go: $(ARTIFACTDIR)
 	rm -f "$(ARTIFACTDIR)/gotest.cover"
 ifeq ($(COVER),1)
 	$(GO_ENV_VARS) $(GO) test $(GO_BUILDFLAGS) \
 		-coverpkg github.com/zrepl/zrepl/... \
 		-covermode atomic \
 		-coverprofile "$(ARTIFACTDIR)/gotest.cover" \
 		./...
 else
 	$(GO_ENV_VARS) $(GO) test $(GO_BUILDFLAGS) \
 		./...
 endif
 zrepl-bin:
 	$(GO_BUILD) -o "$(ARTIFACTDIR)/zrepl-$(ZREPL_TARGET_TUPLE)"
-COVER_PLATFORM_BIN_PATH := $(ARTIFACTDIR)/platformtest-cover-$(ZREPL_TARGET_TUPLE)
+platformtest-bin:
-cover-platform-bin:
+	$(GO_BUILD) -o "$(ARTIFACTDIR)/platformtest-$(ZREPL_TARGET_TUPLE)" ./platformtest/harness
 	$(GO_ENV_VARS) $(GO) test $(GO_BUILDFLAGS) \
 		-c -o "$(COVER_PLATFORM_BIN_PATH)" \
 		-covermode=atomic -cover -coverpkg github.com/zrepl/zrepl/... \
 		./internal/platformtest/harness
 cover-platform:
 	# do not track dependency on cover-platform-bin to allow build of binary outside of test VM
 	export _TEST_PLATFORM_CMD="$(COVER_PLATFORM_BIN_PATH) \
 		-test.coverprofile \"$(ARTIFACTDIR)/platformtest.cover\" \
 		-test.v \
 		__DEVEL--i-heard-you-like-tests"; \
 		$(MAKE) _test-or-cover-platform-impl
 TEST_PLATFORM_BIN_PATH := $(ARTIFACTDIR)/platformtest-$(ZREPL_TARGET_TUPLE)
 test-platform-bin:
 	$(GO_BUILD) -o "$(TEST_PLATFORM_BIN_PATH)" ./internal/platformtest/harness
 test-platform:
 	export _TEST_PLATFORM_CMD="\"$(TEST_PLATFORM_BIN_PATH)\""; \
 		$(MAKE) _test-or-cover-platform-impl
 ZREPL_PLATFORMTEST_ARGS :=
 _test-or-cover-platform-impl: $(ARTIFACTDIR)
 ifndef _TEST_PLATFORM_CMD
 	$(error _TEST_PLATFORM_CMD is undefined, caller 'cover-platform' or 'test-platform' should have defined it)
 endif
 	rm -f "$(ARTIFACTDIR)/platformtest.cover"
 	$(_TEST_PLATFORM_CMD) $(ZREPL_PLATFORMTEST_ARGS)
 cover-merge: $(ARTIFACTDIR)
 	$(GOCOVMERGE) $(ARTIFACTDIR)/platformtest.cover $(ARTIFACTDIR)/gotest.cover > $(ARTIFACTDIR)/merged.cover
 cover-html: cover-merge
 	$(GO) tool cover -html "$(ARTIFACTDIR)/merged.cover" -o "$(ARTIFACTDIR)/merged.cover.html"
 cover-full:
 	$(MAKE) test-go COVER=1
 	$(MAKE) cover-platform-bin
 	$(MAKE) cover-platform
 	$(MAKE) cover-html
 ##################### DEV TARGETS #####################
 # not part of the build, must do that manually
-.PHONY: generate format
+.PHONY: generate format platformtest
-build/install:
+generate:
-	rm -rf build/install.tmp
+	protoc -I=replication/logic/pdu --go_out=plugins=grpc:replication/logic/pdu replication/logic/pdu/pdu.proto
-	mkdir build/install.tmp
+	$(GO_ENV_VARS) $(GO) generate $(GO_BUILDFLAGS) -x ./...
-	-echo "installing protoc"
+format:
-	mkdir build/install.tmp/protoc
+	goimports -srcdir . -local 'github.com/zrepl/zrepl' -w $(shell find . -type f -name '*.go' -not -path "./vendor/*" -not -name '*.pb.go' -not -name '*_enumer.go')
 	bash -x build/get_protoc.bash build/install.tmp/protoc
-	-echo "installing golangci-lint"
+ZREPL_PLATFORMTEST_POOLNAME := zreplplatformtest
-	mkdir -p build/install.tmp/golangci_lint
+ZREPL_PLATFORMTEST_IMAGEPATH := /tmp/zreplplatformtest.pool.img
-	GOHOSTARCH=$(GOHOSTARCH) \
+ZREPL_PLATFORMTEST_MOUNTPOINT := /tmp/zreplplatformtest.pool
-		build/get_golangci_lint.bash build/install.tmp/golangci_lint
+ZREPL_PLATFORMTEST_ZFS_LOG := /tmp/zreplplatformtest.zfs.log
-
+# ZREPL_PLATFORMTEST_STOP_AND_KEEP := -failure.stop-and-keep-pool
-	-echo "installing go tools"
+ZREPL_PLATFORMTEST_ARGS := 
-	build/go_install_tools.bash build/install.tmp/gobin
+platformtest: # do not track dependency on platformtest-bin to allow build of platformtest outside of test VM
-
+	rm -f "$(ZREPL_PLATFORMTEST_ZFS_LOG)"
-	mv build/install.tmp build/install
+	platformtest/logmockzfs/logzfsenv "$(ZREPL_PLATFORMTEST_ZFS_LOG)" `which zfs` \
-
+	"$(ARTIFACTDIR)/platformtest-$(ZREPL_TARGET_TUPLE)" \
-
+		-poolname "$(ZREPL_PLATFORMTEST_POOLNAME)" \
-generate: build/install
+		-imagepath "$(ZREPL_PLATFORMTEST_IMAGEPATH)" \
-	# TODO: would be nice to run with a pure path here
+		-mountpoint "$(ZREPL_PLATFORMTEST_MOUNTPOINT)" \
-	PATH="$(CURDIR)/build/install/gobin:$(CURDIR)/build/install/protoc/bin:$$PATH" && \
+		$(ZREPL_PLATFORMTEST_STOP_AND_KEEP) \
-		build/install/protoc/bin/protoc -I=internal/replication/logic/pdu --go_out=internal/replication/logic/pdu --go-grpc_out=internal/replication/logic/pdu internal/replication/logic/pdu/pdu.proto && \
+		$(ZREPL_PLATFORMTEST_ARGS)
 		build/install/protoc/bin/protoc -I=internal/rpc/grpcclientidentity/example --go_out=internal/rpc/grpcclientidentity/example/pdu --go-grpc_out=internal/rpc/grpcclientidentity/example/pdu internal/rpc/grpcclientidentity/example/grpcauth.proto && \
 		$(GO) generate $(GO_BUILDFLAGS) -x ./... && \
 		true
 GOIMPORTS := goimports -srcdir . -local 'github.com/zrepl/zrepl'
 format: build/install
 	@ build/install/gobin/goimports -w -local 'github.com/zrepl/zrepl' $$(find . -type f -name '*.go' -not -path "./vendor/*" -not -name '*.pb.go' -not -name '*_enumer.go')
 ##################### NOARCH #####################
 .PHONY: noarch $(ARTIFACTDIR)/bash_completion $(ARTIFACTDIR)/_zrepl.zsh_completion $(ARTIFACTDIR)/go_env.txt docs docs-clean
@@ -366,13 +182,13 @@ $(ARTIFACTDIR)/_zrepl.zsh_completion:
 $(ARTIFACTDIR)/go_env.txt:
 	$(GO_ENV_VARS) $(GO) env > $@
 	$(GO) version >> $@
 docs: $(ARTIFACTDIR)/docs
-	# https://www.sphinx-doc.org/en/master/man/sphinx-build.html
+	make -C docs \
-	cd docs && uv sync --frozen
+		html \
-	cd docs && uv run sphinx-build -W --keep-going -n . ../artifacts/docs/html
+		BUILDDIR=../artifacts/docs \
 docs-clean:
-	rm -rf artifacts/docs
+	make -C docs \
-	rm -rf docs/.venv
+		clean \
 		BUILDDIR=../artifacts/docs
@@ -1,12 +1,10 @@
 [![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)
+[![Donate via Patreon](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.herokuapp.com%2Fzrepl%2Fpledges&style=flat&color=yellow)](https://www.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/receives/zrepl.svg?logo=liberapay)](https://liberapay.com/zrepl/donate)
 [![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.
@@ -22,180 +20,129 @@ zrepl is a one-stop ZFS backup & replication solution.
 ## Feature Requests
-1. Does your feature request require default values / some kind of configuration?
+1. Does you feature request require default values / some kind of configuration?
   If so, think of an expressive configuration example.
 2. Think of at least one use case that generalizes from your concrete application.
 3. Open an issue on GitHub with example conf & use case attached.
-4. **Optional**: [Contact Christian Schwarz](https://cschwarz.com) for contract work.
+4. **Optional**: [Post a bounty](https://www.bountysource.com/teams/zrepl) on the issue, or [contact Christian Schwarz](https://cschwarz.com) for contract work.
 The above does not apply if you already implemented everything.
 Check out the *Coding Workflow* section below for details.
-## Development
+## Package Maintainer Information
-zrepl is written in [Go](https://golang.org) and uses [Go modules](https://github.com/golang/go/wiki/Modules) to manage dependencies.
+* Follow the steps in `docs/installation.rst -> Compiling from Source` and read the Makefile / shell scripts used in this process.
-The documentation is written in [ReStructured Text](http://docutils.sourceforge.net/rst.html) using the [Sphinx](https://www.sphinx-doc.org) framework.
+* Make sure your distro is compatible with the paths in `docs/installation.rst`.
 ### Building
 #### Go Code
 Dependencies:
 * Go
 * GNU Make
 * Git
 * wget (`make generate`)
 * unzip (`make generate`)
 Some Go code is **generated**, and generated code is committed to the source tree.
 Therefore, building does not require having code generation tools set up.
 When making changes that require code to be (re-)generated, run `make generate`.
 I downloads and installs pinned versions of the code generation tools into `./build/install`.
 There is a CI check that ensures Git state is clean, i.e., code generation has been done by a PR and is deterministic.
 #### Docs
 Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then run `make docs`.
 uv automatically manages Python and dependencies.
 ### Testing
 The **test suite** is split into pure **Go tests** (`make test-go`) and **platform tests** that interact with ZFS and thus generally **require root privileges** (`sudo make test-platform`).
 Platform tests run on their own pool with the name `zreplplatformtest`, which is created using the file vdev in `/tmp`.
 For a full **code coverage** profile, run `make test-go COVER=1 && sudo make test-platform && make cover-merge`.
 An HTML report can be generated using `make cover-html`.
 ### Circle CI
 We use CircleCI for automated build & test pre- and post-merge.
 There are two workflows:
 * `ci` runs for every commit / branch / tag pushed to GitHub.
  It is supposed to run very fast (<5min and provides quick feedback to developers).
  It runs formatting checks, lints and tests on the most important OSes / architectures.
 * `release` runs
  * on manual triggers through the CircleCI API (in order to produce a release)
  * periodically on `master`
 Artifacts are stored in CircleCI.
 ### Releasing
 All zrepl releases are git-tagged and then published as a GitHub Release.
 There is a git tag for each zrepl release, usually `vMAJOR.MINOR.0`.
 We don't move git tags once the release has been published.
 The procedure to issue a release is as follows:
 * Prepare the release (as a PR to `master`):
  * Finalize `docs/changelog.rst` for the release.
  * Merge the PR. Docs are auto-published to zrepl.github.io on merge.
 * Tag the release:
  * Git tag the release on the `master` branch (e.g., `vMAJOR.MINOR.0`).
  * Push the tag.
 * Build and publish:
  * Run the `release` pipeline (trigger via CircleCI UI).
  * Download artifacts: `make download-circleci-release BUILD_NUM=<circleci-build-number>`
  * Create GitHub release and upload artifacts:
    ```bash
    gh release create vX.Y.Z --title "vX.Y.Z" --notes "See changelog" --draft
    gh release upload vX.Y.Z artifacts/release/*
    ```
  * Review the draft release, edit the changelog, then publish.
  * Add the .rpm and .deb files to the official zrepl repos.
    * Code for management of these repos: https://github.com/zrepl/package-repo-ops (private repo at this time)
 * Update docs version list:
  * Update `docs/_templates/versions.html` with the new release.
  * Verify the link to `zrepl-noarch.tar` in the GitHub release works.
  * Merge to `master` (docs auto-publish).
 #### Patch releases, Go toolchain updates, APT/RPM Package rebuilds
 `vMAJOR.MINOR.0` is typically a tagged commit on `master`, because development velocity isn't high
 and thus release branches for stabilization aren't necessary.
 Occasionally though there is a need for patch changes to a release, e.g.
 - security issue in a dependency
 - Go toolchain update (e.g. security issue in standard library)
 The procedure for this is the following
 - create a branch off the release tag we need to patch, named `releases/MAJOR.MINOR.X`
 - that branch will never be merged into `master`, it'll be a dead-end for this specific patch
 - make changes in that branch
 - make the final commit that bumps version numbers
 - create the git tag
 - follow general procedure for publishing the release (previous sectino
 For Go toolchain updates and package rebuilds with no source code changes, leverage the APT/RPM package revision field.
 Control via the `ZREPL_PACKAGE_RELEASE` Makefile variable, see `origin/releases/0.6.1-2` for an example.
 ### Updating Dependencies
 - Update the `go` directive and `toolchain` directive in `go.mod`
  - `go` is the minimum supported version
  - `toolchain` is the preferred toolchain version if `GOTOOLCHAIN` is not specified
 Run `go mod tidy` to ensure consistency.
 Update Go module dependencies:
 ```bash
 # Update all other dependencies
 go get -u -t ./...
 go mod tidy
 # Above might fail if there are version selection conflicts.
 # Figure out what's going on by updating packages from error messages first.
 # Example:
 go get -u google.golang.org/genproto google.golang.org/grpc google.golang.org/protobuf
 ```
 Update codegen & lint tools
 - `protoc` =>  `build/get_protoc.bash`
  - GH releases publish sha256 sums
 - `golangci-lint` => `build/get_golangci_lint.bash`
 - bump versions in `build/tools.go`
  - we use the tools.go trick:
  - `go get -tags tools -u example.com/tool ; go mod tidy`
  - review whether we're ready to switch to `go tool`: https://github.com/zrepl/zrepl/pull/909
 Now run `make generate`.
 Run `make lint` and `make vet`.
 Update the CI configuration `.circleci/config.yml`:
 - Update Go version references (we reference the minimum and max supported version)
 - Set `Makefile` `RELEASE_GOVERSION` to the new Go version
 Update docs build tooling:
 - Update `uv` version in `.circleci/config.yml` (search for `astral.sh/uv/` and cache keys containing the version)
 - Check if there's now a CircleCI orb for uv that we could use
 - Update Python version in `docs/.python-version`
 Update docs dependencies (Sphinx, sphinx-rtd-theme):
 - Check current versions in `docs/pyproject.toml`
 - Review upstream changelogs for breaking changes
 - Update version constraints in `pyproject.toml` and the `uv` lockfile (see [uv docs on dependencies](https://docs.astral.sh/uv/concepts/projects/dependencies/)):
 - Test locally with `make docs`
 Kick a full CI pipeline run (`do_ci=true` and `do_release=true`).
 Merge PR with merge commit.
 ## Notes to Distro Package Maintainers
 * The `Makefile` in this project is not suitable for builds in distros.
 * 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.
 * 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.
 * Ship other material provided in `./dist`, e.g. in `/usr/share/zrepl/`.
-* Have a look at the `Makefile`'s `ZREPL_VERSION` variable and how it passed to Go's `ldFlags`.
+* Use `make release ZREPL_VERSION='mydistro-1.2.3_1'`
-  This is how `zrepl version` knows what version number to show.
+    * Your distro's name and any versioning supplemental to zrepl's (e.g. package revision) should be in this string
-  Your build system should set the `ldFlags` flags appropriately and add a prefix or suffix that indicates that the given zrepl binary is a distro build, not an official one.
+* Use `make platformtest` **on a test system** to validate that zrepl's abstractions on top of ZFS work with the system ZFS.
 * Make sure you are informed about new zrepl versions, e.g. by subscribing to GitHub's release RSS feed.
 ## Developer Documentation
 zrepl is written in [Go](https://golang.org) and uses [Go modules](https://github.com/golang/go/wiki/Modules) to manage dependencies.
 The documentation is written in [ReStructured Text](http://docutils.sourceforge.net/rst.html) using the [Sphinx](https://www.sphinx-doc.org) framework.
 To get started, run `./lazy.sh devsetup` to easily install build dependencies and read `docs/installation.rst -> Compiling from Source`.
 `lazy.sh` uses `python3-pip` to fetch the build dependencies for the docs - you might want to use a [venv](https://docs.python.org/3/library/venv.html).
 If you just want to install the Go dependencies, run `./lazy.sh godep`.
 ### Project Structure
 ```
 ├── artifacts               # build artifcats generate by make
 ├── cli                     # wrapper around CLI package cobra
 ├── client                  # all subcommands that are not `daemon`
 ├── config                  # config data types (=> package yaml-config)
 │   └── samples
 ├── daemon                  # the implementation of `zrepl daemon` subcommand
 │   ├── filters
 │   ├── hooks               # snapshot hooks
 │   ├── job                 # job implementations
 │   ├── logging             # logging outlets + formatters
 │   ├── nethelpers
 │   ├── prometheus
 │   ├── pruner              # pruner implementation
 │   ├── snapper             # snapshotter implementation
 ├── dist                    # supplemental material for users & package maintainers
 ├── docs                    # sphinx-based documentation
 │   ├── **/*.rst            # documentation in reStructuredText
 │   ├── sphinxconf
 │   │   └── conf.py         # sphinx config (see commit 445a280 why its not in docs/)
 │   ├── requirements.txt    # pip3 requirements to build documentation
 │   ├── publish.sh          # shell script for automated rendering & deploy to zrepl.github.io repo
 │   └── public_git          # checkout of zrepl.github.io managed by above shell script
 ├── endpoint                # implementation of replication endpoints (=> package replication)
 ├── logger                  # our own logger package
 ├── platformtest            # test suite for our zfs abstractions (error classification, etc)
 ├── pruning                 # pruning rules (the logic, not the actual execution)
 │   └── retentiongrid
 ├── replication
 │   ├── driver              # the driver of the replication logic (status reporting, error handling)
 │   ├── logic               # planning & executing replication steps via rpc
 |   |   └── pdu             # the generated gRPC & protobuf code used in replication (and endpoints)
 │   └── report              # the JSON-serializable report datastructures exposed to the client
 ├── rpc                     # the hybrid gRPC + ./dataconn RPC client: connects to a remote replication.Endpoint
 │   ├── dataconn            # Bulk data-transfer RPC protocol
 │   ├── grpcclientidentity  # adaptor to inject package transport's 'client identity' concept into gRPC contexts
 │   ├── netadaptor          # adaptor to convert a package transport's Connecter and Listener into net.* primitives
 │   ├── transportmux        # TCP connecter and listener used to split control & data traffic
 │   └── versionhandshake    # replication protocol version handshake perfomed on newly established connections
 ├── tlsconf                 # abstraction for Go TLS server + client config
 ├── transport               # transport implementations
 │   ├── fromconfig
 │   ├── local
 │   ├── ssh
 │   ├── tcp
 │   └── tls
 ├── util
 ├── version                 # abstraction for versions (filled during build by Makefile)
 └── zfs                     # zfs(8) wrappers
 ```
 ### Coding Workflow
 * Open an issue when starting to hack on a new feature
 * Commits should reference the issue they are related to
 * Docs improvements not documenting new features do not require an issue.
 ### Breaking Changes
 Backward-incompatible changes must be documented in the git commit message and are listed in `docs/changelog.rst`.
 * Config-breaking changes must contain a line `BREAK CONFIG` in the commit message
 * Other breaking changes must contain a line `BREAK` in the commit message
 ### Glossary & Naming Inconsistencies
 In ZFS, *dataset* refers to the objects *filesystem*, *ZVOL* and *snapshot*. <br />
 However, we need a word for *filesystem* & *ZVOL* but not a snapshot, bookmark, etc.
 Toward the user, the following terminology is used:
 * **filesystem**: a ZFS filesystem or a ZVOL
 * **filesystem version**: a ZFS snapshot or a bookmark
 Sadly, the zrepl implementation is inconsistent in its use of these words:
 variables and types are often named *dataset* when they in fact refer to a *filesystem*.
 There will not be a big refactoring (an attempt was made, but it's destroying too much history without much gain).
 However, new contributions & patches should fix naming without further notice in the commit message.
 ### RPC debugging
 Optionally, there are various RPC-related environment variables, that if set to something != `""` will produce additional debug output on stderr:
 https://github.com/zrepl/zrepl/blob/master/rpc/rpc_debug.go#L11
 https://github.com/zrepl/zrepl/blob/master/rpc/dataconn/dataconn_debug.go#L11
 https://github.com/zrepl/zrepl/blob/master/rpc/dataconn/stream/stream_debug.go#L11
 https://github.com/zrepl/zrepl/blob/master/rpc/dataconn/heartbeatconn/heartbeatconn_debug.go#L11
@@ -0,0 +1,30 @@
 FROM golang:latest
 RUN apt-get update && apt-get install -y \
    python3-pip \
    unzip \
    gawk
 ADD build.installprotoc.bash ./
 RUN bash build.installprotoc.bash
 ADD lazy.sh /tmp/lazy.sh
 ADD docs/requirements.txt /tmp/requirements.txt
 ENV ZREPL_LAZY_DOCS_REQPATH=/tmp/requirements.txt
 RUN /tmp/lazy.sh docdep
 # prepare volume mount of git checkout to /zrepl
 RUN mkdir -p /src/github.com/zrepl/zrepl
 RUN mkdir -p /.cache && chmod -R 0777 /.cache
 # $GOPATH is /go
 # Go 1.12 doesn't use modules within GOPATH, but 1.13 and later do
 # => store source outside of GOPATH
 WORKDIR /src
 # Install build tools (e.g. protobuf generator, stringer) into $GOPATH/bin
 ADD build/ /tmp/build
 RUN /tmp/lazy.sh godep
 RUN chmod -R 0777 /go
@@ -0,0 +1,25 @@
 #!/usr/bin/env bash
 set -euo pipefail
 set -x
 MACH=$(uname -m)
 MACH="${MACH/aarch64/aarch_64}"
 VERSION=3.6.1
 FILENAME=protoc-"$VERSION"-linux-"$MACH".zip
 if [ -e "$FILENAME" ]; then
    echo "$FILENAME" already exists 1>&2
    exit 1
 fi
 wget https://github.com/protocolbuffers/protobuf/releases/download/v"$VERSION"/"$FILENAME"
 stat "$FILENAME"
 sha256sum -c --ignore-missing <<EOF
 6003de742ea3fcf703cfec1cd4a3380fd143081a2eb0e559065563496af27807  protoc-3.6.1-linux-x86_64.zip
 af8e5aaaf39ddec62ec8dd2be1b8d9602c6da66564883a16393ade5f71170922  protoc-3.6.1-linux-aarch_64.zip
 EOF
 unzip -d /usr "$FILENAME"
@@ -1 +0,0 @@
 install/
@@ -1,30 +0,0 @@
 FROM !SUBSTITUTED_BY_MAKEFILE
 ARG BUILD_UID=1000
 ARG BUILD_GID=1000
 RUN apt-get update && apt-get install -y \
    python3 \
    unzip \
    gawk \
    curl
 # Create build user with the host's UID/GID before installing uv
 RUN groupadd -g ${BUILD_GID} zrepl_build && \
    useradd -u ${BUILD_UID} -g ${BUILD_GID} -m zrepl_build
 # Go toolchain uses xdg-cache
 RUN mkdir -p /.cache && chmod -R 0777 /.cache
 # Install uv as the build user - version from .uv-version file
 ADD .uv-version /tmp/.uv-version
 USER zrepl_build
 RUN UV_VERSION=$(cat /tmp/.uv-version) && \
    curl -LsSf https://astral.sh/uv/${UV_VERSION}/install.sh | sh
 # Go devtools are managed by Makefile
 WORKDIR /src
 ENV PATH="/home/zrepl_build/.local/bin:$PATH" \
    GOCACHE="/.cache/go-build"
@@ -1,33 +0,0 @@
 #!/usr/bin/env bash
 set -euo pipefail
 set -x
 # golangci-lint recommends against using `go get` and friends to install it
 cd "$1"
 VERSION=2.8.0
 FILENAME=golangci-lint-"$VERSION"-linux-"$GOHOSTARCH".tar.gz
 if [ -e "$FILENAME" ]; then
    echo "$FILENAME" already exists 1>&2
    exit 1
 fi
 wget --continue https://github.com/golangci/golangci-lint/releases/download/v"$VERSION"/"$FILENAME"
 stat "$FILENAME"
 # Select the correct checksum for the downloaded architecture
 case "$GOHOSTARCH" in
    arm64) EXPECTED_SHA256="2a58388db8af5ab9330791cea0ebdd4100723cd05ad7185d92febaaee272ec9a" ;;
    amd64) EXPECTED_SHA256="7048bc6b25c9515ed092c83f9fa8709ca97937ead52d9ff317a143299ee97a50" ;;
    *)     echo "Unknown architecture: $GOHOSTARCH" >&2; exit 1 ;;
 esac
 # Verify checksum explicitly - fails if hash doesn't match
 echo "$EXPECTED_SHA256  $FILENAME" | sha256sum -c -
 tar -x  --strip-components=1 -f "$FILENAME"
 stat ./golangci-lint
@@ -1,32 +0,0 @@
 #!/usr/bin/env bash
 set -euo pipefail
 set -x
 cd "$1"
 MACH=$(uname -m)
 MACH="${MACH/aarch64/aarch_64}"
 VERSION=33.5
 FILENAME=protoc-"$VERSION"-linux-"$MACH".zip
 if [ -e "$FILENAME" ]; then
    echo "$FILENAME" already exists 1>&2
    exit 1
 fi
 wget --continue https://github.com/protocolbuffers/protobuf/releases/download/v"$VERSION"/"$FILENAME"
 stat "$FILENAME"
 # Select the correct checksum for the downloaded architecture
 case "$MACH" in
    aarch_64) EXPECTED_SHA256="2b0fcf9b2c32cbadccc0eb7a88b841fffecd4a06fc80acdba2b5be45e815c38a" ;;
    x86_64)   EXPECTED_SHA256="24e58fb231d50306ee28491f33a170301e99540f7e29ca461e0e80fd1239f8d1" ;;
    *)        echo "Unknown architecture: $MACH" >&2; exit 1 ;;
 esac
 # Verify checksum explicitly - fails if hash doesn't match
 echo "$EXPECTED_SHA256  $FILENAME" | sha256sum -c -
 unzip -d . "$FILENAME"
@@ -1,24 +1,51 @@
 module github.com/zrepl/zrepl/build
-go 1.24.13
+go 1.12
 toolchain go1.25.7
 require (
-	github.com/alvaroloes/enumer v1.1.2
+	github.com/OpenPeeDeeP/depguard v0.0.0-20181229194401-1f388ab2d810 // indirect
-	github.com/wadey/gocovmerge v0.0.0-20160331181800-b5bfa59ec0ad
+	github.com/alvaroloes/enumer v1.1.1
-	golang.org/x/tools v0.41.0
+	github.com/fatih/color v1.7.0 // indirect
-	google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.6.1
+	github.com/go-critic/go-critic v0.3.4 // indirect
-	google.golang.org/protobuf v1.36.11
+	github.com/gogo/protobuf v1.2.1 // indirect
 	github.com/golang/mock v1.2.0 // indirect
 	github.com/golang/protobuf v1.2.0
 	github.com/golangci/errcheck v0.0.0-20181223084120-ef45e06d44b6 // indirect
 	github.com/golangci/go-tools v0.0.0-20190124090046-35a9f45a5db0 // indirect
 	github.com/golangci/gocyclo v0.0.0-20180528144436-0a533e8fa43d // indirect
 	github.com/golangci/gofmt v0.0.0-20181222123516-0b8337e80d98 // indirect
 	github.com/golangci/golangci-lint v1.17.1
 	github.com/golangci/gosec v0.0.0-20180901114220-8afd9cbb6cfb // indirect
 	github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219 // indirect
 	github.com/golangci/misspell v0.3.4 // indirect
 	github.com/golangci/revgrep v0.0.0-20180812185044-276a5c0a1039 // indirect
 	github.com/google/go-cmp v0.3.0 // indirect
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/pkg/errors v0.8.1 // indirect
 	github.com/sirupsen/logrus v1.4.2 // indirect
 	github.com/spf13/afero v1.2.2 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/viper v1.3.2 // indirect
 	github.com/stretchr/testify v1.4.0 // indirect
 	golang.org/x/net v0.0.0-20190613194153-d28f0bde5980 // indirect
 	golang.org/x/sys v0.0.0-20191010194322-b09406accb47 // indirect
 	golang.org/x/tools v0.0.0-20190524210228-3d17549cdc6b
 	mvdan.cc/unparam v0.0.0-20190310220240-1b9ccfa71afe // indirect
 	sourcegraph.com/sqs/pbtypes v1.0.0 // indirect
 )
-require (
+// invalid dates in transitive dependencies (first validated in Go 1.13, didn't fail in earlier Go versions)
-	github.com/pascaldekloe/name v1.0.1 // indirect
+replace (
-	golang.org/x/mod v0.32.0 // indirect
+	github.com/go-critic/go-critic v0.0.0-20181204210945-1df300866540 => github.com/go-critic/go-critic v0.3.5-0.20190526074819-1df300866540
-	golang.org/x/sync v0.19.0 // indirect
+	github.com/go-critic/go-critic v0.0.0-20181204210945-ee9bf5809ead => github.com/go-critic/go-critic v0.3.5-0.20190210220443-ee9bf5809ead
-	golang.org/x/sys v0.41.0 // indirect
+	github.com/golangci/errcheck v0.0.0-20181003203344-ef45e06d44b6 => github.com/golangci/errcheck v0.0.0-20181223084120-ef45e06d44b6
-	golang.org/x/telemetry v0.0.0-20260205145544-86a5c4bf3c8d // indirect
+	github.com/golangci/go-tools v0.0.0-20180109140146-35a9f45a5db0 => github.com/golangci/go-tools v0.0.0-20190124090046-35a9f45a5db0
-	golang.org/x/text v0.31.0 // indirect
+	github.com/golangci/go-tools v0.0.0-20180109140146-af6baa5dc196 => github.com/golangci/go-tools v0.0.0-20190318060251-af6baa5dc196
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250818200422-3122310a409c // indirect
+	github.com/golangci/gofmt v0.0.0-20181105071733-0b8337e80d98 => github.com/golangci/gofmt v0.0.0-20181222123516-0b8337e80d98
-	google.golang.org/grpc v1.75.0 // indirect
+	github.com/golangci/gosec v0.0.0-20180901114220-66fb7fc33547 => github.com/golangci/gosec v0.0.0-20190211064107-66fb7fc33547
 	github.com/golangci/ineffassign v0.0.0-20180808204949-42439a7714cc => github.com/golangci/ineffassign v0.0.0-20190609212857-42439a7714cc
 	github.com/golangci/lint-1 v0.0.0-20180610141402-ee948d087217 => github.com/golangci/lint-1 v0.0.0-20190420132249-ee948d087217
 	golang.org/x/tools v0.0.0-20190125232054-379209517ffe => golang.org/x/tools v0.0.0-20190205201329-379209517ffe
 	mvdan.cc/unparam v0.0.0-20190124213536-fbb59629db34 => mvdan.cc/unparam v0.0.0-20190209190245-fbb59629db34
 )
@@ -1,37 +1,280 @@
-github.com/alvaroloes/enumer v1.1.2 h1:5khqHB33TZy1GWCO/lZwcroBFh7u+0j40T83VUbfAMY=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/alvaroloes/enumer v1.1.2/go.mod h1:FxrjvuXoDAx9isTJrv4c+T410zFi0DtXIT0m65DJ+Wo=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/OpenPeeDeeP/depguard v0.0.0-20180806142446-a69c782687b2/go.mod h1:7/4sitnI9YlQgTLLk734QlzXT8DuHVnAyztLplQjk+o=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/OpenPeeDeeP/depguard v0.0.0-20181229194401-1f388ab2d810 h1:pFks+oaqVWDFq0KsLQZFB2pQGB5Us0HfMSBENtieXOs=
 github.com/OpenPeeDeeP/depguard v0.0.0-20181229194401-1f388ab2d810/go.mod h1:7/4sitnI9YlQgTLLk734QlzXT8DuHVnAyztLplQjk+o=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
 github.com/alvaroloes/enumer v1.1.1 h1:v+1scNqEhSFAPb9tLwblQegeTXJhnw8hf9O0amTbOvQ=
 github.com/alvaroloes/enumer v1.1.1/go.mod h1:FxrjvuXoDAx9isTJrv4c+T410zFi0DtXIT0m65DJ+Wo=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fatih/color v1.6.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/go-critic/go-critic v0.3.4 h1:FYaiaLjX0Nqei80KPhm4CyFQUBbmJwSrHxQ73taaGBc=
 github.com/go-critic/go-critic v0.3.4/go.mod h1:AHR42Lk/E/aOznsrYdMYeIQS5RH10HZHSqP+rD6AJrc=
 github.com/go-critic/go-critic v0.3.5-0.20190526074819-1df300866540/go.mod h1:+sE8vrLDS2M0pZkBk0wy6+nLdKexVDrl/jBqQOTDThA=
 github.com/go-lintpack/lintpack v0.5.1/go.mod h1:NwZuYi2nUHho8XEIZ6SIxihrnPoqBTDqfpXvXAN0sXM=
 github.com/go-lintpack/lintpack v0.5.2 h1:DI5mA3+eKdWeJ40nU4d6Wc26qmdG8RCi/btYq0TuRN0=
 github.com/go-lintpack/lintpack v0.5.2/go.mod h1:NwZuYi2nUHho8XEIZ6SIxihrnPoqBTDqfpXvXAN0sXM=
 github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
 github.com/go-toolsmith/astcast v0.0.0-20181028201508-b7a89ed70af1/go.mod h1:TEo3Ghaj7PsZawQHxT/oBvo4HK/sl1RcuUHDKTTju+o=
 github.com/go-toolsmith/astcast v1.0.0 h1:JojxlmI6STnFVG9yOImLeGREv8W2ocNUM+iOhR6jE7g=
 github.com/go-toolsmith/astcast v1.0.0/go.mod h1:mt2OdQTeAQcY4DQgPSArJjHCcOwlX+Wl/kwN+LbLGQ4=
 github.com/go-toolsmith/astcopy v0.0.0-20180903214859-79b422d080c4/go.mod h1:c9CPdq2AzM8oPomdlPniEfPAC6g1s7NqZzODt8y6ib8=
 github.com/go-toolsmith/astcopy v1.0.0 h1:OMgl1b1MEpjFQ1m5ztEO06rz5CUd3oBv9RF7+DyvdG8=
 github.com/go-toolsmith/astcopy v1.0.0/go.mod h1:vrgyG+5Bxrnz4MZWPF+pI4R8h3qKRjjyvV/DSez4WVQ=
 github.com/go-toolsmith/astequal v0.0.0-20180903214952-dcb477bfacd6/go.mod h1:H+xSiq0+LtiDC11+h1G32h7Of5O3CYFJ99GVbS5lDKY=
 github.com/go-toolsmith/astequal v1.0.0 h1:4zxD8j3JRFNyLN46lodQuqz3xdKSrur7U/sr0SDS/gQ=
 github.com/go-toolsmith/astequal v1.0.0/go.mod h1:H+xSiq0+LtiDC11+h1G32h7Of5O3CYFJ99GVbS5lDKY=
 github.com/go-toolsmith/astfmt v0.0.0-20180903215011-8f8ee99c3086/go.mod h1:mP93XdblcopXwlyN4X4uodxXQhldPGZbcEJIimQHrkg=
 github.com/go-toolsmith/astfmt v1.0.0 h1:A0vDDXt+vsvLEdbMFJAUBI/uTbRw1ffOPnxsILnFL6k=
 github.com/go-toolsmith/astfmt v1.0.0/go.mod h1:cnWmsOAuq4jJY6Ct5YWlVLmcmLMn1JUPuQIHCY7CJDw=
 github.com/go-toolsmith/astinfo v0.0.0-20180906194353-9809ff7efb21/go.mod h1:dDStQCHtmZpYOmjRP/8gHHnCCch3Zz3oEgCdZVdtweU=
 github.com/go-toolsmith/astp v0.0.0-20180903215135-0af7e3c24f30/go.mod h1:SV2ur98SGypH1UjcPpCatrV5hPazG6+IfNHbkDXBRrk=
 github.com/go-toolsmith/astp v1.0.0 h1:alXE75TXgcmupDsMK1fRAy0YUzLzqPVvBKoyWV+KPXg=
 github.com/go-toolsmith/astp v1.0.0/go.mod h1:RSyrtpVlfTFGDYRbrjyWP1pYu//tSFcvdYrA8meBmLI=
 github.com/go-toolsmith/pkgload v0.0.0-20181119091011-e9e65178eee8 h1:vVouagbdmqTVlCIAxpyYsNNTbkKZ3V66VpKOLU/s6W4=
 github.com/go-toolsmith/pkgload v0.0.0-20181119091011-e9e65178eee8/go.mod h1:WoMrjiy4zvdS+Bg6z9jZH82QXwkcgCBX6nOfnmdaHks=
 github.com/go-toolsmith/pkgload v1.0.0 h1:4DFWWMXVfbcN5So1sBNW9+yeiMqLFGl1wFLTL5R0Tgg=
 github.com/go-toolsmith/pkgload v1.0.0/go.mod h1:5eFArkbO80v7Z0kdngIxsRXRMTaX4Ilcwuh3clNrQJc=
 github.com/go-toolsmith/strparse v0.0.0-20180903215201-830b6daa1241/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8=
 github.com/go-toolsmith/strparse v1.0.0 h1:Vcw78DnpCAKlM20kSbAyO4mPfJn/lyYA4BJUDxe2Jb4=
 github.com/go-toolsmith/strparse v1.0.0/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8=
 github.com/go-toolsmith/typep v0.0.0-20181030061450-d63dc7650676/go.mod h1:JSQCQMUPdRlMZFswiq3TGpNp1GMktqkR2Ns5AIQkATU=
 github.com/go-toolsmith/typep v1.0.0 h1:zKymWyA1TRYvqYrYDrfEMZULyrhcnGY3x7LDKU2XQaA=
 github.com/go-toolsmith/typep v1.0.0/go.mod h1:JSQCQMUPdRlMZFswiq3TGpNp1GMktqkR2Ns5AIQkATU=
 github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang/mock v1.0.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0 h1:28o5sBqPkBsMGnC6b4MvE2TzSr5/AT4c/1fLqVGIwlk=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2 h1:23T5iq8rbUYlhpt5DB4XJkc6BU31uODLD1o1gKvZmD0=
 github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2/go.mod h1:k9Qvh+8juN+UKMCS/3jFtGICgW8O96FVaZsaxdzDkR4=
 github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a h1:w8hkcTqaFpzKqonE9uMCefW1WDie15eSP/4MssdenaM=
 github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk=
 github.com/golangci/errcheck v0.0.0-20181223084120-ef45e06d44b6 h1:YYWNAGTKWhKpcLLt7aSj/odlKrSrelQwlovBpDuf19w=
 github.com/golangci/errcheck v0.0.0-20181223084120-ef45e06d44b6/go.mod h1:DbHgvLiFKX1Sh2T1w8Q/h4NAI8MHIpzCdnBUDTXU3I0=
 github.com/golangci/go-misc v0.0.0-20180628070357-927a3d87b613 h1:9kfjN3AdxcbsZBf8NjltjWihK2QfBBBZuv91cMFfDHw=
 github.com/golangci/go-misc v0.0.0-20180628070357-927a3d87b613/go.mod h1:SyvUF2NxV+sN8upjjeVYr5W7tyxaT1JVtvhKhOn2ii8=
 github.com/golangci/go-tools v0.0.0-20190124090046-35a9f45a5db0 h1:MRhC9XbUjE6XDOInSJ8pwHuPagqsyO89QDU9IdVhe3o=
 github.com/golangci/go-tools v0.0.0-20190124090046-35a9f45a5db0/go.mod h1:unzUULGw35sjyOYjUt0jMTXqHlZPpPc6e+xfO4cd6mM=
 github.com/golangci/go-tools v0.0.0-20190318060251-af6baa5dc196/go.mod h1:unzUULGw35sjyOYjUt0jMTXqHlZPpPc6e+xfO4cd6mM=
 github.com/golangci/goconst v0.0.0-20180610141641-041c5f2b40f3 h1:pe9JHs3cHHDQgOFXJJdYkK6fLz2PWyYtP4hthoCMvs8=
 github.com/golangci/goconst v0.0.0-20180610141641-041c5f2b40f3/go.mod h1:JXrF4TWy4tXYn62/9x8Wm/K/dm06p8tCKwFRDPZG/1o=
 github.com/golangci/gocyclo v0.0.0-20180528134321-2becd97e67ee/go.mod h1:ozx7R9SIwqmqf5pRP90DhR2Oay2UIjGuKheCBCNwAYU=
 github.com/golangci/gocyclo v0.0.0-20180528144436-0a533e8fa43d h1:pXTK/gkVNs7Zyy7WKgLXmpQ5bHTrq5GDsp8R9Qs67g0=
 github.com/golangci/gocyclo v0.0.0-20180528144436-0a533e8fa43d/go.mod h1:ozx7R9SIwqmqf5pRP90DhR2Oay2UIjGuKheCBCNwAYU=
 github.com/golangci/gofmt v0.0.0-20181222123516-0b8337e80d98 h1:0OkFarm1Zy2CjCiDKfK9XHgmc2wbDlRMD2hD8anAJHU=
 github.com/golangci/gofmt v0.0.0-20181222123516-0b8337e80d98/go.mod h1:9qCChq59u/eW8im404Q2WWTrnBUQKjpNYKMbU4M7EFU=
 github.com/golangci/golangci-lint v1.17.1 h1:lc8Hf9GPCjIr0hg3S/xhvFT1+Hydass8F1xchr8jkME=
 github.com/golangci/golangci-lint v1.17.1/go.mod h1:+5sJSl2h3aly+fpmL2meSP8CaSKua2E4Twi9LPy7b1g=
 github.com/golangci/gosec v0.0.0-20180901114220-8afd9cbb6cfb h1:Bi7BYmZVg4C+mKGi8LeohcP2GGUl2XJD4xCkJoZSaYc=
 github.com/golangci/gosec v0.0.0-20180901114220-8afd9cbb6cfb/go.mod h1:ON/c2UR0VAAv6ZEAFKhjCLplESSmRFfZcDLASbI1GWo=
 github.com/golangci/gosec v0.0.0-20190211064107-66fb7fc33547/go.mod h1:0qUabqiIQgfmlAmulqxyiGkkyF6/tOGSnY2cnPVwrzU=
 github.com/golangci/ineffassign v0.0.0-20190609212857-42439a7714cc h1:gLLhTLMk2/SutryVJ6D4VZCU3CUqr8YloG7FPIBWFpI=
 github.com/golangci/ineffassign v0.0.0-20190609212857-42439a7714cc/go.mod h1:e5tpTHCfVze+7EpLEozzMB3eafxo2KT5veNg1k6byQU=
 github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219 h1:utua3L2IbQJmauC5IXdEA547bcoU5dozgQAfc8Onsg4=
 github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y=
 github.com/golangci/lint-1 v0.0.0-20190420132249-ee948d087217/go.mod h1:66R6K6P6VWk9I95jvqGxkqJxVWGFy9XlDwLwVz1RCFg=
 github.com/golangci/maligned v0.0.0-20180506175553-b1d89398deca h1:kNY3/svz5T29MYHubXix4aDDuE3RWHkPvopM/EDv/MA=
 github.com/golangci/maligned v0.0.0-20180506175553-b1d89398deca/go.mod h1:tvlJhZqDe4LMs4ZHD0oMUlt9G2LWuDGoisJTBzLMV9o=
 github.com/golangci/misspell v0.0.0-20180809174111-950f5d19e770/go.mod h1:dEbvlSfYbMQDtrpRMQU675gSDLDNa8sCPPChZ7PhiVA=
 github.com/golangci/misspell v0.3.4 h1:kAD5J0611Zo2VirUn9KFP15RjEqkmfEfnFxyIVxZCYg=
 github.com/golangci/misspell v0.3.4/go.mod h1:dEbvlSfYbMQDtrpRMQU675gSDLDNa8sCPPChZ7PhiVA=
 github.com/golangci/prealloc v0.0.0-20180630174525-215b22d4de21 h1:leSNB7iYzLYSSx3J/s5sVf4Drkc68W2wm4Ixh/mr0us=
 github.com/golangci/prealloc v0.0.0-20180630174525-215b22d4de21/go.mod h1:tf5+bzsHdTM0bsB7+8mt0GUMvjCgwLpTapNZHU8AajI=
 github.com/golangci/revgrep v0.0.0-20180526074752-d9c87f5ffaf0/go.mod h1:qOQCunEYvmd/TLamH+7LlVccLvUH5kZNhbCgTHoBbp4=
 github.com/golangci/revgrep v0.0.0-20180812185044-276a5c0a1039 h1:XQKc8IYQOeRwVs36tDrEmTgDgP88d5iEURwpmtiAlOM=
 github.com/golangci/revgrep v0.0.0-20180812185044-276a5c0a1039/go.mod h1:qOQCunEYvmd/TLamH+7LlVccLvUH5kZNhbCgTHoBbp4=
 github.com/golangci/unconvert v0.0.0-20180507085042-28b1c447d1f4 h1:zwtduBRr5SSWhqsYNgcuWO2kFlpdOZbP0+yRjmvPGys=
 github.com/golangci/unconvert v0.0.0-20180507085042-28b1c447d1f4/go.mod h1:Izgrg8RkN3rCIMLGE9CyYmU9pY2Jer6DgANEnZ/L/cQ=
 github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/gostaticanalysis/analysisutil v0.0.0-20190318220348-4088753ea4d3 h1:JVnpOZS+qxli+rgVl98ILOXVNbW+kb5wcxeGx8ShUIw=
 github.com/gostaticanalysis/analysisutil v0.0.0-20190318220348-4088753ea4d3/go.mod h1:eEOZF4jCKGi+aprrirO9e7WKB3beBRtWgqGunKl6pKE=
 github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v0.0.0-20161130080628-0de1eaf82fa3/go.mod h1:jxZFDH7ILpTPQTk+E2s+z4CUas9lVNjIuKR4c5/zKgM=
 github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
 github.com/magiconair/properties v1.7.6/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-ps v0.0.0-20170309133038-4fdf99ab2936/go.mod h1:r1VsdOzOPt1ZSrGZWFoNhsAedKnEd6r9Np1+5blZCWk=
 github.com/mitchellh/mapstructure v0.0.0-20180220230111-00c29f56e238/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mozilla/tls-observatory v0.0.0-20180409132520-8791a200eb40/go.mod h1:SrKMQvPiws7F7iqYp8/TX+IhxCYhzr6N/1yb8cwHsGk=
 github.com/nbutton23/zxcvbn-go v0.0.0-20160627004424-a22cb81b2ecd/go.mod h1:o96djdrsSGy3AWPyBgZMAGfxZNfgntdJG+11KU4QvbU=
 github.com/nbutton23/zxcvbn-go v0.0.0-20171102151520-eafdab6b0663 h1:Ri1EhipkbhWsffPJ3IPlrb4SkTOPa2PfRXp3jchBczw=
 github.com/nbutton23/zxcvbn-go v0.0.0-20171102151520-eafdab6b0663/go.mod h1:o96djdrsSGy3AWPyBgZMAGfxZNfgntdJG+11KU4QvbU=
 github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.2 h1:3mYCb7aPxS/RU7TI1y4rkEn1oKmPRjNJLNEXgw7MH2I=
 github.com/onsi/gomega v1.4.2/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/pascaldekloe/name v0.0.0-20180628100202-0fd16699aae1 h1:/I3lTljEEDNYLho3/FUB7iD/oc2cEFgVmbHzV+O0PtU=
 github.com/pascaldekloe/name v0.0.0-20180628100202-0fd16699aae1/go.mod h1:eD5JxqMiuNYyFNmyY9rkJ/slN8y59oEu4Ei7F8OoKWQ=
-github.com/pascaldekloe/name v1.0.1 h1:9lnXOHeqeHHnWLbKfH6X98+4+ETVqFqxN09UXSjcMb0=
+github.com/pelletier/go-toml v1.1.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pascaldekloe/name v1.0.1/go.mod h1:Z//MfYJnH4jVpQ9wkclwu2I2MkHmXTlT9wR5UZScttM=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
-github.com/wadey/gocovmerge v0.0.0-20160331181800-b5bfa59ec0ad h1:W0LEBv82YCGEtcmPA3uNZBI33/qF//HAAs3MawDjRa0=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/wadey/gocovmerge v0.0.0-20160331181800-b5bfa59ec0ad/go.mod h1:Hy8o65+MXnS6EwGElrSRjUzQDLXreJlzYLlWiHtt8hM=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/quasilyte/go-consistent v0.0.0-20190521200055-c6f3937de18c/go.mod h1:5STLWrekHfjyYwxBRVRXNOSewLJ3PWfDJd1VyTS21fI=
 github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.2.1/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=
 github.com/shirou/gopsutil v0.0.0-20180427012116-c95755e4bcd7/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc=
 github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e h1:MZM7FHLqUHYI0Y/mQAt3d2aYa0SiNms/hFqC9qJYolM=
 github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
 github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041 h1:llrF3Fs4018ePo4+G/HV/uQUqEI1HMDjCeOf2V6puPc=
 github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
 github.com/sirupsen/logrus v1.0.5/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sourcegraph/go-diff v0.5.1 h1:gO6i5zugwzo1RVTvgvfwCOSVegNuvnNi6bAD1QCmkHs=
 github.com/sourcegraph/go-diff v0.5.1/go.mod h1:j2dHj3m8aZgQO8lMTcTnBcXkRRRqi34cd2MNlA9u1mE=
 github.com/spf13/afero v1.1.0/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc=
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cast v1.2.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
 github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cobra v0.0.2 h1:NfkwRbgViGoyjBKsLI0QMDcuMnhM+SBg3T0cGfpvKDE=
 github.com/spf13/cobra v0.0.2/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/jwalterweatherman v0.0.0-20180109140146-7c0cea34c8ec/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
 github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/viper v1.0.2/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
 github.com/spf13/viper v1.3.2 h1:VUFqw5KcqRf7i70GOzW7N+Q7+gxVBkSSqiXB12+JQ4M=
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/timakin/bodyclose v0.0.0-20190407043127-4a873e97b2bb h1:lI9ufgFfvuqRctP9Ny8lDDLbSWCMxBPletcSqrnyFYM=
 github.com/timakin/bodyclose v0.0.0-20190407043127-4a873e97b2bb/go.mod h1:Qimiffbc6q9tBWlVV6x0P9sat/ao1xEkREYPPj9hphk=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasthttp v1.2.0/go.mod h1:4vX61m6KN+xDduDNwXrhIAVZaZaZiQ1luJk8LWSxF3s=
 github.com/valyala/quicktemplate v1.1.1/go.mod h1:EH+4AkTd43SvgIbQHYu59/cJyxDoOVRUAfrukLPuGJ4=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/net v0.0.0-20170915142106-8351a756f30f/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180911220305-26e67e76b6c3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.0.0-20190313220215-9f648a60d977 h1:actzWV6iWn3GLqN8dZjzsB+CLt+gaV2+wsxroxiQI8I=
-golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980 h1:dfGZHvZk057jK2MCeWus/TowKpJ8y4AmooUzdBSR9GU=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sys v0.0.0-20171026204733-164713f0dfce/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/telemetry v0.0.0-20260205145544-86a5c4bf3c8d h1:xjbyaj6khjO0ocYYa7k9sQLbdi4R1KwHnsS1QGijbsM=
+golang.org/x/sys v0.0.0-20191010194322-b09406accb47 h1:/XfQ9z7ib8eEJX2hdgFTZJ/ntt0swNk5oYBziWeTCvY=
-golang.org/x/telemetry v0.0.0-20260205145544-86a5c4bf3c8d/go.mod h1:b7fPSJ0pKZ3ccUh8gnTONJxhn3c/PS6tyzQvyqw4iA8=
+golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.0.0-20170915090833-1cbadb444a80/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/tools v0.0.0-20170915040203-e531a2a1c15f/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181117154741-2ddaf7f79a09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181205014116-22934f0fdb62/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190110163146-51295c7ec13a/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190121143147-24cd39ecf745/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190213192042-740235f6c0d8 h1:b0PLhFjEMqrIqsD4rS5sp0YxBYgdqKzX0KkkGGKLV8I=
 golang.org/x/tools v0.0.0-20190213192042-740235f6c0d8/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190311215038-5c2858a9cfe5/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190322203728-c1a832b0ad89/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190521203540-521d6ed310dd/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190524210228-3d17549cdc6b h1:iEAPfYPbYbxG/2lNN4cMOHkmgKNsCuUwkxlDCK46UlU=
 golang.org/x/tools v0.0.0-20190524210228-3d17549cdc6b/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
-golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250818200422-3122310a409c h1:qXWI/sQtv5UKboZ/zUk7h+mrf/lXORyI+n9DKDAusdg=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250818200422-3122310a409c/go.mod h1:gw1tLEfykwDz2ET4a12jcXt4couGAm7IwsVaTy0Sflo=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
-google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.6.1 h1:/WILD1UcXj/ujCxgoL/DvRgt2CP3txG8+FwkUbb9110=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.6.1/go.mod h1:YNKnb2OAApgYn2oYY47Rn7alMr1zWjb2U8Q0aoGWiNc=
+gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed h1:WX1yoOaKQfddO/mLzdV4wptyWgoH/6hwLs7QHTixo0I=
 mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed/go.mod h1:Xkxe497xwlCKkIaQYRfC7CSLworTXY9RMqwhhCm+8Nc=
 mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b h1:DxJ5nJdkhDlLok9K6qO+5290kphDJbHOQO1DFFFTeBo=
 mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b/go.mod h1:2odslEg/xrtNQqCYg2/jCoyKnw3vv5biOc3JnIcYfL4=
 mvdan.cc/unparam v0.0.0-20190209190245-fbb59629db34/go.mod h1:H6SUd1XjIs+qQCyskXg5OFSrilMRUkD8ePJpHKDPaeY=
 mvdan.cc/unparam v0.0.0-20190310220240-1b9ccfa71afe h1:Ekmnp+NcP2joadI9pbK4Bva87QKZSeY7le//oiMrc9g=
 mvdan.cc/unparam v0.0.0-20190310220240-1b9ccfa71afe/go.mod h1:BnhuWBAqxH3+J5bDybdxgw5ZfS+DsVd4iylsKQePN8o=
 sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0=
 sourcegraph.com/sqs/pbtypes v1.0.0 h1:f7lAwqviDEGvON4kRv0o5V7FT/IQK+tbkF664XMbP3o=
 sourcegraph.com/sqs/pbtypes v1.0.0/go.mod h1:3AciMUv4qUuRHRHhOG4TZOB+72GdPVz5k+c648qsFS4=
@@ -1,6 +0,0 @@
 export GO111MODULE=on # otherwise, a checkout of this repo in GOPATH will disable modules on Go 1.12 and earlier
 source <(go env)
 # build tools for the host platform
 export GOOS="$GOHOSTOS"
 export GOARCH="$GOHOSTARCH"
 # TODO GOARM=$GOHOSTARM?
@@ -1,19 +0,0 @@
 #!/usr/bin/env bash
 set -euo pipefail
 set -x
 OUTDIR="$(readlink -f "$1")"
 if [ -e "$OUTDIR" ]; then
    echo "$OUTDIR" already exists 1>&2
    exit 1
 fi
 # go install command below will install tools to $GOBIN
 export GOBIN="$OUTDIR"
 cd "$(dirname "$0")"
 source ./go_install_host_tool.source
 cat tools.go | grep _ | awk -F'"' '{print $2}' | tee | xargs -tI '{}' go install '{}'
@@ -1,14 +1,11 @@
 //go:build tools
 // +build tools
 package main
 // the lines are parsed by lazy.sh, do not edit
 import (
 	_ "github.com/alvaroloes/enumer"
-	_ "github.com/wadey/gocovmerge"
+	_ "github.com/golang/protobuf/protoc-gen-go"
 	_ "github.com/golangci/golangci-lint/cmd/golangci-lint"
 	_ "golang.org/x/tools/cmd/goimports"
 	_ "golang.org/x/tools/cmd/stringer"
 	_ "google.golang.org/grpc/cmd/protoc-gen-go-grpc"
 	_ "google.golang.org/protobuf/cmd/protoc-gen-go"
 )
@@ -7,10 +7,9 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/internal/config"
 )
 var rootArgs struct {
@@ -11,17 +11,16 @@ import (
 	"github.com/spf13/pflag"
 	"github.com/zrepl/yaml-config"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon/job"
+	"github.com/zrepl/zrepl/daemon/job"
-	"github.com/zrepl/zrepl/internal/daemon/logging"
+	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
 )
 var configcheckArgs struct {
-	format        string
+	format string
-	what          string
+	what   string
 	skipCertCheck bool
 }
 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" {
@@ -9,12 +9,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/daemon/job"
+	"github.com/zrepl/zrepl/daemon/job"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
 )
 var (
@@ -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")
@@ -1,6 +1,6 @@
 package client
-import "github.com/zrepl/zrepl/internal/cli"
+import "github.com/zrepl/zrepl/cli"
 var PprofCmd = &cli.Subcommand{
 	Use: "pprof",
@@ -8,7 +8,7 @@ import (
 	"golang.org/x/net/websocket"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
 )
 var pprofActivityTraceCmd = &cli.Subcommand{
@@ -6,9 +6,9 @@ import (
 	"log"
 	"os"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon"
+	"github.com/zrepl/zrepl/daemon"
 )
 var pprofListenCmd struct {
@@ -5,9 +5,9 @@ import (
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon"
+	"github.com/zrepl/zrepl/daemon"
 )
 var SignalCmd = &cli.Subcommand{
@@ -0,0 +1,811 @@
 package client
 import (
 	"context"
 	"fmt"
 	"io"
 	"math"
 	"net/http"
 	"os"
 	"sort"
 	"strings"
 	"sync"
 	"time"
 	// tcell is the termbox-compatible library for abstracting away escape sequences, etc.
 	// as of tcell#252, the number of default distributed terminals is relatively limited
 	// additional terminal definitions can be included via side-effect import
 	// See https://github.com/gdamore/tcell/blob/master/terminfo/base/base.go
 	// See https://github.com/gdamore/tcell/issues/252#issuecomment-533836078
 	"github.com/gdamore/tcell/termbox"
 	_ "github.com/gdamore/tcell/terminfo/s/screen" // tmux on FreeBSD 11 & 12 without ncurses
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
 	"github.com/zrepl/yaml-config"
 	"github.com/zrepl/zrepl/cli"
 	"github.com/zrepl/zrepl/daemon"
 	"github.com/zrepl/zrepl/daemon/job"
 	"github.com/zrepl/zrepl/daemon/pruner"
 	"github.com/zrepl/zrepl/daemon/snapper"
 	"github.com/zrepl/zrepl/replication/report"
 )
 type byteProgressMeasurement struct {
 	time time.Time
 	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 int64) (bytesPerSecondAvg int64, changeCount int) {
 	if p.last == nil {
 		p.last = &byteProgressMeasurement{
 			time: time.Now(),
 			val:  currentVal,
 		}
 		return 0, 0
 	}
 	if p.last.val != currentVal {
 		p.changeCount++
 		p.lastChange = time.Now()
 	}
 	if time.Since(p.lastChange) > 3*time.Second {
 		p.last = nil
 		return 0, 0
 	}
 	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(p.bpsAvg), p.changeCount
 }
 type tui struct {
 	x, y   int
 	indent int
 	lock   sync.Mutex //For report and error
 	report map[string]*job.Status
 	err    error
 	jobFilter string
 	replicationProgress map[string]*bytesProgressHistory // by job name
 }
 func newTui() tui {
 	return tui{
 		replicationProgress: make(map[string]*bytesProgressHistory),
 	}
 }
 const INDENT_MULTIPLIER = 4
 func (t *tui) moveLine(dl int, col int) {
 	t.y += dl
 	t.x = t.indent*INDENT_MULTIPLIER + col
 }
 func (t *tui) write(text string) {
 	for _, c := range text {
 		if c == '\n' {
 			t.newline()
 			continue
 		}
 		termbox.SetCell(t.x, t.y, c, termbox.ColorDefault, termbox.ColorDefault)
 		t.x += 1
 	}
 }
 func (t *tui) printf(text string, a ...interface{}) {
 	t.write(fmt.Sprintf(text, a...))
 }
 func wrap(s string, width int) string {
 	var b strings.Builder
 	for len(s) > 0 {
 		rem := width
 		if rem > len(s) {
 			rem = len(s)
 		}
 		if idx := strings.IndexAny(s, "\n\r"); idx != -1 && idx < rem {
 			rem = idx + 1
 		}
 		untilNewline := strings.TrimRight(s[:rem], "\n\r")
 		s = s[rem:]
 		if len(untilNewline) == 0 {
 			continue
 		}
 		b.WriteString(untilNewline)
 		b.WriteString("\n")
 	}
 	return strings.TrimRight(b.String(), "\n\r")
 }
 func (t *tui) printfDrawIndentedAndWrappedIfMultiline(format string, a ...interface{}) {
 	whole := fmt.Sprintf(format, a...)
 	width, _ := termbox.Size()
 	if !strings.ContainsAny(whole, "\n\r") && t.x+len(whole) <= width {
 		t.printf(format, a...)
 	} else {
 		t.addIndent(1)
 		t.newline()
 		t.write(wrap(whole, width-INDENT_MULTIPLIER*t.indent))
 		t.addIndent(-1)
 	}
 }
 func (t *tui) newline() {
 	t.moveLine(1, 0)
 }
 func (t *tui) setIndent(indent int) {
 	t.indent = indent
 	t.moveLine(0, 0)
 }
 func (t *tui) addIndent(indent int) {
 	t.indent += indent
 	t.moveLine(0, 0)
 }
 var statusFlags struct {
 	Raw bool
 	Job string
 }
 var StatusCmd = &cli.Subcommand{
 	Use:   "status",
 	Short: "show job activity or dump as JSON for monitoring",
 	SetupFlags: func(f *pflag.FlagSet) {
 		f.BoolVar(&statusFlags.Raw, "raw", false, "dump raw status description from zrepl daemon")
 		f.StringVar(&statusFlags.Job, "job", "", "only dump specified job")
 	},
 	Run: runStatus,
 }
 func runStatus(ctx context.Context, s *cli.Subcommand, args []string) error {
 	httpc, err := controlHttpClient(s.Config().Global.Control.SockPath)
 	if err != nil {
 		return err
 	}
 	if statusFlags.Raw {
 		resp, err := httpc.Get("http://unix" + daemon.ControlJobEndpointStatus)
 		if err != nil {
 			return err
 		}
 		defer resp.Body.Close()
 		if resp.StatusCode != http.StatusOK {
 			fmt.Fprintf(os.Stderr, "Received error response:\n")
 			_, err := io.CopyN(os.Stderr, resp.Body, 4096)
 			if err != nil {
 				return err
 			}
 			return errors.Errorf("exit")
 		}
 		if _, err := io.Copy(os.Stdout, resp.Body); err != nil {
 			return err
 		}
 		return nil
 	}
 	t := newTui()
 	t.lock.Lock()
 	t.err = errors.New("Got no report yet")
 	t.lock.Unlock()
 	t.jobFilter = statusFlags.Job
 	err = termbox.Init()
 	if err != nil {
 		return err
 	}
 	defer termbox.Close()
 	update := func() {
 		var m daemon.Status
 		err2 := jsonRequestResponse(httpc, daemon.ControlJobEndpointStatus,
 			struct{}{},
 			&m,
 		)
 		t.lock.Lock()
 		t.err = err2
 		t.report = m.Jobs
 		t.lock.Unlock()
 		t.draw()
 	}
 	update()
 	ticker := time.NewTicker(500 * time.Millisecond)
 	defer ticker.Stop()
 	go func() {
 		for range ticker.C {
 			update()
 		}
 	}()
 	termbox.HideCursor()
 	termbox.Clear(termbox.ColorDefault, termbox.ColorDefault)
 loop:
 	for {
 		switch ev := termbox.PollEvent(); ev.Type {
 		case termbox.EventKey:
 			switch ev.Key {
 			case termbox.KeyEsc:
 				break loop
 			case termbox.KeyCtrlC:
 				break loop
 			}
 		case termbox.EventResize:
 			t.draw()
 		}
 	}
 	return nil
 }
 func (t *tui) getReplicationProgressHistory(jobName string) *bytesProgressHistory {
 	p, ok := t.replicationProgress[jobName]
 	if !ok {
 		p = &bytesProgressHistory{}
 		t.replicationProgress[jobName] = p
 	}
 	return p
 }
 func (t *tui) draw() {
 	t.lock.Lock()
 	defer t.lock.Unlock()
 	termbox.Clear(termbox.ColorDefault, termbox.ColorDefault)
 	t.x = 0
 	t.y = 0
 	t.indent = 0
 	if t.err != nil {
 		t.write(t.err.Error())
 	} else {
 		//Iterate over map in alphabetical order
 		keys := make([]string, 0, len(t.report))
 		for k := range t.report {
 			if len(k) == 0 || daemon.IsInternalJobName(k) { //Internal job
 				continue
 			}
 			if t.jobFilter != "" && k != t.jobFilter {
 				continue
 			}
 			keys = append(keys, k)
 		}
 		sort.Strings(keys)
 		if len(keys) == 0 {
 			t.setIndent(0)
 			t.printf("no jobs to display")
 			t.newline()
 			termbox.Flush()
 			return
 		}
 		for _, k := range keys {
 			v := t.report[k]
 			t.setIndent(0)
 			t.printf("Job: %s", k)
 			t.setIndent(1)
 			t.newline()
 			t.printf("Type: %s", v.Type)
 			t.setIndent(1)
 			t.newline()
 			if v.Type == job.TypePush || v.Type == job.TypePull {
 				activeStatus, ok := v.JobSpecific.(*job.ActiveSideStatus)
 				if !ok || activeStatus == nil {
 					t.printf("ActiveSideStatus is null")
 					t.newline()
 					continue
 				}
 				t.printf("Replication:")
 				t.newline()
 				t.addIndent(1)
 				t.renderReplicationReport(activeStatus.Replication, t.getReplicationProgressHistory(k))
 				t.addIndent(-1)
 				t.printf("Pruning Sender:")
 				t.newline()
 				t.addIndent(1)
 				t.renderPrunerReport(activeStatus.PruningSender)
 				t.addIndent(-1)
 				t.printf("Pruning Receiver:")
 				t.newline()
 				t.addIndent(1)
 				t.renderPrunerReport(activeStatus.PruningReceiver)
 				t.addIndent(-1)
 				if v.Type == job.TypePush {
 					t.printf("Snapshotting:")
 					t.newline()
 					t.addIndent(1)
 					t.renderSnapperReport(activeStatus.Snapshotting)
 					t.addIndent(-1)
 				}
 			} else if v.Type == job.TypeSnap {
 				snapStatus, ok := v.JobSpecific.(*job.SnapJobStatus)
 				if !ok || snapStatus == nil {
 					t.printf("SnapJobStatus is null")
 					t.newline()
 					continue
 				}
 				t.printf("Pruning snapshots:")
 				t.newline()
 				t.addIndent(1)
 				t.renderPrunerReport(snapStatus.Pruning)
 				t.addIndent(-1)
 				t.printf("Snapshotting:")
 				t.newline()
 				t.addIndent(1)
 				t.renderSnapperReport(snapStatus.Snapshotting)
 				t.addIndent(-1)
 			} else if v.Type == job.TypeSource {
 				st := v.JobSpecific.(*job.PassiveStatus)
 				t.printf("Snapshotting:\n")
 				t.addIndent(1)
 				t.renderSnapperReport(st.Snapper)
 				t.addIndent(-1)
 			} else {
 				t.printf("No status representation for job type '%s', dumping as YAML", v.Type)
 				t.newline()
 				asYaml, err := yaml.Marshal(v.JobSpecific)
 				if err != nil {
 					t.printf("Error marshaling status to YAML: %s", err)
 					t.newline()
 					continue
 				}
 				t.write(string(asYaml))
 				t.newline()
 				continue
 			}
 		}
 	}
 	termbox.Flush()
 }
 func (t *tui) renderReplicationReport(rep *report.Report, history *bytesProgressHistory) {
 	if rep == nil {
 		t.printf("...\n")
 		return
 	}
 	if rep.WaitReconnectError != nil {
 		t.printfDrawIndentedAndWrappedIfMultiline("Connectivity: %s", rep.WaitReconnectError)
 		t.newline()
 	}
 	if !rep.WaitReconnectSince.IsZero() {
 		delta := time.Until(rep.WaitReconnectUntil).Round(time.Second)
 		if rep.WaitReconnectUntil.IsZero() || delta > 0 {
 			var until string
 			if rep.WaitReconnectUntil.IsZero() {
 				until = "waiting indefinitely"
 			} else {
 				until = fmt.Sprintf("hard fail in %s @ %s", delta, rep.WaitReconnectUntil)
 			}
 			t.printfDrawIndentedAndWrappedIfMultiline("Connectivity: reconnecting with exponential backoff (since %s) (%s)",
 				rep.WaitReconnectSince, until)
 		} else {
 			t.printfDrawIndentedAndWrappedIfMultiline("Connectivity: reconnects reached hard-fail timeout @ %s", rep.WaitReconnectUntil)
 		}
 		t.newline()
 	}
 	// TODO visualize more than the latest attempt by folding all attempts into one
 	if len(rep.Attempts) == 0 {
 		t.printf("no attempts made yet")
 		return
 	} else {
 		t.printf("Attempt #%d", len(rep.Attempts))
 		if len(rep.Attempts) > 1 {
 			t.printf(". Previous attempts failed with the following statuses:")
 			t.newline()
 			t.addIndent(1)
 			for i, a := range rep.Attempts[:len(rep.Attempts)-1] {
 				t.printfDrawIndentedAndWrappedIfMultiline("#%d: %s (failed at %s) (ran %s)", i+1, a.State, a.FinishAt, a.FinishAt.Sub(a.StartAt))
 				t.newline()
 			}
 			t.addIndent(-1)
 		} else {
 			t.newline()
 		}
 	}
 	latest := rep.Attempts[len(rep.Attempts)-1]
 	sort.Slice(latest.Filesystems, func(i, j int) bool {
 		return latest.Filesystems[i].Info.Name < latest.Filesystems[j].Info.Name
 	})
 	t.printf("Status: %s", latest.State)
 	t.newline()
 	if latest.State == report.AttemptPlanningError {
 		t.printf("Problem: ")
 		t.printfDrawIndentedAndWrappedIfMultiline("%s", latest.PlanError)
 		t.newline()
 	} else if latest.State == report.AttemptFanOutError {
 		t.printf("Problem: one or more of the filesystems encountered errors")
 		t.newline()
 	}
 	if latest.State != report.AttemptPlanning && latest.State != report.AttemptPlanningError {
 		// Draw global progress bar
 		// Progress: [---------------]
 		expected, replicated, containsInvalidSizeEstimates := latest.BytesSum()
 		rate, changeCount := history.Update(replicated)
 		eta := time.Duration(0)
 		if rate > 0 {
 			eta = time.Duration((expected-replicated)/rate) * time.Second
 		}
 		t.write("Progress: ")
 		t.drawBar(50, replicated, expected, changeCount)
 		t.write(fmt.Sprintf(" %s / %s @ %s/s", ByteCountBinary(replicated), ByteCountBinary(expected), ByteCountBinary(rate)))
 		if eta != 0 {
 			t.write(fmt.Sprintf(" (%s remaining)", humanizeDuration(eta)))
 		}
 		t.newline()
 		if containsInvalidSizeEstimates {
 			t.write("NOTE: not all steps could be size-estimated, total estimate is likely imprecise!")
 			t.newline()
 		}
 		var maxFSLen int
 		for _, fs := range latest.Filesystems {
 			if len(fs.Info.Name) > maxFSLen {
 				maxFSLen = len(fs.Info.Name)
 			}
 		}
 		for _, fs := range latest.Filesystems {
 			t.printFilesystemStatus(fs, false, maxFSLen) // FIXME bring 'active' flag back
 		}
 	}
 }
 func (t *tui) renderPrunerReport(r *pruner.Report) {
 	if r == nil {
 		t.printf("...\n")
 		return
 	}
 	state, err := pruner.StateString(r.State)
 	if err != nil {
 		t.printf("Status: %q (parse error: %q)\n", r.State, err)
 		return
 	}
 	t.printf("Status: %s", state)
 	t.newline()
 	if r.Error != "" {
 		t.printf("Error: %s\n", r.Error)
 	}
 	type commonFS struct {
 		*pruner.FSReport
 		completed bool
 	}
 	all := make([]commonFS, 0, len(r.Pending)+len(r.Completed))
 	for i := range r.Pending {
 		all = append(all, commonFS{&r.Pending[i], false})
 	}
 	for i := range r.Completed {
 		all = append(all, commonFS{&r.Completed[i], true})
 	}
 	switch state {
 	case pruner.Plan:
 		fallthrough
 	case pruner.PlanErr:
 		return
 	}
 	if len(all) == 0 {
 		t.printf("nothing to do\n")
 		return
 	}
 	var totalDestroyCount, completedDestroyCount int
 	var maxFSname int
 	for _, fs := range all {
 		totalDestroyCount += len(fs.DestroyList)
 		if fs.completed {
 			completedDestroyCount += len(fs.DestroyList)
 		}
 		if maxFSname < len(fs.Filesystem) {
 			maxFSname = len(fs.Filesystem)
 		}
 	}
 	// global progress bar
 	progress := int(math.Round(80 * float64(completedDestroyCount) / float64(totalDestroyCount)))
 	t.write("Progress: ")
 	t.write("[")
 	t.write(times("=", progress))
 	t.write(">")
 	t.write(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
 	})
 	// Draw a table-like representation of 'all'
 	for _, fs := range all {
 		t.write(rightPad(fs.Filesystem, maxFSname, " "))
 		t.write(" ")
 		if !fs.SkipReason.NotSkipped() {
 			t.printf("skipped: %s\n", fs.SkipReason)
 			continue
 		}
 		if fs.LastError != "" {
 			if strings.ContainsAny(fs.LastError, "\r\n") {
 				t.printf("ERROR:")
 				t.printfDrawIndentedAndWrappedIfMultiline("%s\n", fs.LastError)
 			} else {
 				t.printfDrawIndentedAndWrappedIfMultiline("ERROR: %s\n", fs.LastError)
 			}
 			t.newline()
 			continue
 		}
 		pruneRuleActionStr := fmt.Sprintf("(destroy %d of %d snapshots)",
 			len(fs.DestroyList), len(fs.SnapshotList))
 		if fs.completed {
 			t.printf("Completed  %s\n", pruneRuleActionStr)
 			continue
 		}
 		t.write("Pending    ") // whitespace is padding 10
 		if len(fs.DestroyList) == 1 {
 			t.write(fs.DestroyList[0].Name)
 		} else {
 			t.write(pruneRuleActionStr)
 		}
 		t.newline()
 	}
 }
 func (t *tui) renderSnapperReport(r *snapper.Report) {
 	if r == nil {
 		t.printf("<snapshot type does not have a report>\n")
 		return
 	}
 	t.printf("Status: %s", r.State)
 	t.newline()
 	if r.Error != "" {
 		t.printf("Error: %s\n", r.Error)
 	}
 	if !r.SleepUntil.IsZero() {
 		t.printf("Sleep until: %s\n", r.SleepUntil)
 	}
 	sort.Slice(r.Progress, func(i, j int) bool {
 		return strings.Compare(r.Progress[i].Path, r.Progress[j].Path) == -1
 	})
 	t.addIndent(1)
 	defer t.addIndent(-1)
 	dur := func(d time.Duration) string {
 		return d.Round(100 * time.Millisecond).String()
 	}
 	type row struct {
 		path, state, duration, remainder, hookReport string
 	}
 	var widths struct {
 		path, state, duration int
 	}
 	rows := make([]*row, len(r.Progress))
 	for i, fs := range r.Progress {
 		r := &row{
 			path:  fs.Path,
 			state: fs.State.String(),
 		}
 		if fs.HooksHadError {
 			r.hookReport = fs.Hooks // FIXME render here, not in daemon
 		}
 		switch fs.State {
 		case snapper.SnapPending:
 			r.duration = "..."
 			r.remainder = ""
 		case snapper.SnapStarted:
 			r.duration = dur(time.Since(fs.StartAt))
 			r.remainder = fmt.Sprintf("snap name: %q", fs.SnapName)
 		case snapper.SnapDone:
 			fallthrough
 		case snapper.SnapError:
 			r.duration = dur(fs.DoneAt.Sub(fs.StartAt))
 			r.remainder = fmt.Sprintf("snap name: %q", fs.SnapName)
 		}
 		rows[i] = r
 		if len(r.path) > widths.path {
 			widths.path = len(r.path)
 		}
 		if len(r.state) > widths.state {
 			widths.state = len(r.state)
 		}
 		if len(r.duration) > widths.duration {
 			widths.duration = len(r.duration)
 		}
 	}
 	for _, r := range rows {
 		path := rightPad(r.path, widths.path, " ")
 		state := rightPad(r.state, widths.state, " ")
 		duration := rightPad(r.duration, widths.duration, " ")
 		t.printf("%s %s %s", path, state, duration)
 		t.printfDrawIndentedAndWrappedIfMultiline(" %s", r.remainder)
 		if r.hookReport != "" {
 			t.printfDrawIndentedAndWrappedIfMultiline("%s", r.hookReport)
 		}
 		t.newline()
 	}
 }
 func times(str string, n int) (out string) {
 	for i := 0; i < n; i++ {
 		out += str
 	}
 	return
 }
 func rightPad(str string, length int, pad string) string {
 	if len(str) > length {
 		return str[:length]
 	}
 	return str + strings.Repeat(pad, length-len(str))
 }
 var arrowPositions = `>\|/`
 // changeCount = 0 indicates stall / no progress
 func (t *tui) drawBar(length int, bytes, totalBytes int64, changeCount int) {
 	var completedLength int
 	if totalBytes > 0 {
 		completedLength = int(int64(length) * bytes / totalBytes)
 		if completedLength > length {
 			completedLength = length
 		}
 	} else if totalBytes == bytes {
 		completedLength = length
 	}
 	t.write("[")
 	t.write(times("=", completedLength))
 	t.write(string(arrowPositions[changeCount%len(arrowPositions)]))
 	t.write(times("-", length-completedLength))
 	t.write("]")
 }
 func (t *tui) printFilesystemStatus(rep *report.FilesystemReport, active bool, maxFS int) {
 	expected, replicated, containsInvalidSizeEstimates := rep.BytesSum()
 	sizeEstimationImpreciseNotice := ""
 	if containsInvalidSizeEstimates {
 		sizeEstimationImpreciseNotice = " (some steps lack size estimation)"
 	}
 	if rep.CurrentStep < len(rep.Steps) && rep.Steps[rep.CurrentStep].Info.BytesExpected == 0 {
 		sizeEstimationImpreciseNotice = " (step lacks size estimation)"
 	}
 	status := fmt.Sprintf("%s (step %d/%d, %s/%s)%s",
 		strings.ToUpper(string(rep.State)),
 		rep.CurrentStep, len(rep.Steps),
 		ByteCountBinary(replicated), ByteCountBinary(expected),
 		sizeEstimationImpreciseNotice,
 	)
 	activeIndicator := " "
 	if active {
 		activeIndicator = "*"
 	}
 	t.printf("%s %s %s ",
 		activeIndicator,
 		rightPad(rep.Info.Name, maxFS, " "),
 		status)
 	next := ""
 	if err := rep.Error(); err != nil {
 		next = err.Err
 	} else if rep.State != report.FilesystemDone {
 		if nextStep := rep.NextStep(); nextStep != nil {
 			if nextStep.IsIncremental() {
 				next = fmt.Sprintf("next: %s => %s", nextStep.Info.From, nextStep.Info.To)
 			} else {
 				next = fmt.Sprintf("next: full send %s", nextStep.Info.To)
 			}
 			attribs := []string{}
 			if nextStep.Info.Resumed {
 				attribs = append(attribs, "resumed")
 			}
 			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
 		}
 	}
 	t.printfDrawIndentedAndWrappedIfMultiline("%s", next)
 	t.newline()
 }
 func ByteCountBinary(b int64) string {
 	const unit = 1024
 	if b < unit {
 		return fmt.Sprintf("%d B", b)
 	}
 	div, exp := int64(unit), 0
 	for n := b / unit; n >= unit; n /= unit {
 		div *= unit
 		exp++
 	}
 	return fmt.Sprintf("%.1f %ciB", float64(b)/float64(div), "KMGTPE"[exp])
 }
 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, " ")
 }
@@ -5,8 +5,8 @@ import (
 	"github.com/problame/go-netssh"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
 	"context"
 	"errors"
@@ -9,10 +9,10 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 var TestCmd = &cli.Subcommand{
@@ -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 {
+			panic("placeholder state inconsistent: filesystem " + ph.FS + " must exist in this context")
 				return errors.Errorf("filesystem %q does not exist", ph.FS)
 			} else {
 				// got deleted between ZFSList and ZFSGetFilesystemPlaceholderState
 				continue
 			}
 		}
 		is := "yes"
 		if !ph.IsPlaceholder {
@@ -7,10 +7,10 @@ import (
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon"
+	"github.com/zrepl/zrepl/daemon"
-	"github.com/zrepl/zrepl/internal/version"
+	"github.com/zrepl/zrepl/version"
 )
 var versionArgs struct {
@@ -7,10 +7,10 @@ import (
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 var (
@@ -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))
@@ -1,6 +1,6 @@
 package client
-import "github.com/zrepl/zrepl/internal/cli"
+import "github.com/zrepl/zrepl/cli"
 var zabsCmdCreate = &cli.Subcommand{
 	Use:             "create",
@@ -7,9 +7,9 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 var zabsCreateStepHoldFlags struct {
@@ -11,9 +11,9 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/util/chainlock"
+	"github.com/zrepl/zrepl/util/chainlock"
 )
 var zabsListFlags struct {
@@ -44,18 +44,17 @@ 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
 	defer wg.Wait()
 	wg.Add(1)
 	// print results
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		enc := json.NewEncoder(os.Stdout)
@@ -64,7 +63,7 @@ func doZabsList(ctx context.Context, sc *cli.Subcommand, args []string) error {
 				defer line.Lock().Unlock()
 				if zabsListFlags.Json {
 					enc.SetIndent("", "  ")
-					if err := enc.Encode(a); err != nil {
+					if err := enc.Encode(abstractions); err != nil {
 						panic(err)
 					}
 					fmt.Println()
@@ -10,8 +10,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
-	"github.com/zrepl/zrepl/internal/cli"
+	"github.com/zrepl/zrepl/cli"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
 )
 // shared between release-all and release-step
@@ -2,32 +2,21 @@ package config
 import (
 	"fmt"
 	"io/ioutil"
 	"log/syslog"
 	"os"
-	pathpkg "path"
+	"reflect"
-	"path/filepath"
+	"regexp"
-	"strings"
+	"strconv"
 	"time"
 	"github.com/pkg/errors"
 	"github.com/robfig/cron/v3"
 	"github.com/zrepl/yaml-config"
 	"github.com/zrepl/zrepl/internal/util/datasizeunit"
 	zfsprop "github.com/zrepl/zrepl/internal/zfs/property"
 )
 type ParseFlags uint
 const (
 	ParseFlagsNone        ParseFlags = 0
 	ParseFlagsNoCertCheck ParseFlags = 1 << iota
 )
 type Config struct {
-	Jobs    []JobEnum `yaml:"jobs,optional"`
+	Jobs   []JobEnum `yaml:"jobs"`
-	Global  *Global   `yaml:"global,optional,fromdefaults"`
+	Global *Global   `yaml:"global,optional,fromdefaults"`
 	Include []string  `yaml:"include,optional"`
 }
 func (c *Config) Job(name string) (*JobEnum, error) {
@@ -63,87 +52,51 @@ func (j JobEnum) Name() string {
 }
 type ActiveJob struct {
-	Type               string                `yaml:"type"`
+	Type    string                `yaml:"type"`
-	Name               string                `yaml:"name"`
+	Name    string                `yaml:"name"`
-	Connect            ConnectEnum           `yaml:"connect"`
+	Connect ConnectEnum           `yaml:"connect"`
-	Pruning            PruningSenderReceiver `yaml:"pruning"`
+	Pruning PruningSenderReceiver `yaml:"pruning"`
-	Replication        *Replication          `yaml:"replication,optional,fromdefaults"`
+	Debug   JobDebugSettings      `yaml:"debug,optional"`
 	ConflictResolution *ConflictResolution   `yaml:"conflict_resolution,optional,fromdefaults"`
 }
 type ConflictResolution struct {
 	InitialReplication string `yaml:"initial_replication,optional,default=most_recent"`
 }
 type PassiveJob struct {
-	Type  string    `yaml:"type"`
+	Type  string           `yaml:"type"`
-	Name  string    `yaml:"name"`
+	Name  string           `yaml:"name"`
-	Serve ServeEnum `yaml:"serve"`
+	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"`
 }
 type SendOptions struct {
-	Encrypted        bool `yaml:"encrypted,optional,default=false"`
+	Encrypted bool `yaml:"encrypted"`
-	Raw              bool `yaml:"raw,optional,default=false"`
+}
 	SendProperties   bool `yaml:"send_properties,optional,default=false"`
 	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"`
 	Saved            bool `yaml:"saved,optional,default=false"`
-	BandwidthLimit *BandwidthLimit `yaml:"bandwidth_limit,optional,fromdefaults"`
+var _ yaml.Defaulter = (*SendOptions)(nil)
 func (l *SendOptions) SetDefault() {
 	*l = SendOptions{Encrypted: false}
 }
 type RecvOptions struct {
 	// Note: we cannot enforce encrypted recv as the ZFS cli doesn't provide a mechanism for it
 	// Encrypted bool `yaml:"may_encrypted"`
 	// Future:
 	// 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{}
+var _ yaml.Defaulter = (*RecvOptions)(nil)
-type BandwidthLimit struct {
+func (l *RecvOptions) SetDefault() {
-	Max            datasizeunit.Bits `yaml:"max,default=-1 B"`
+	*l = RecvOptions{}
 	BucketCapacity datasizeunit.Bits `yaml:"bucket_capacity,default=128 KiB"`
 }
 type Replication struct {
 	Protection  *ReplicationOptionsProtection  `yaml:"protection,optional,fromdefaults"`
 	Concurrency *ReplicationOptionsConcurrency `yaml:"concurrency,optional,fromdefaults"`
 }
 type ReplicationOptionsProtection struct {
 	Initial     string `yaml:"initial,optional,default=guarantee_resumability"`
 	Incremental string `yaml:"incremental,optional,default=guarantee_resumability"`
 }
 type ReplicationOptionsConcurrency struct {
 	Steps         int `yaml:"steps,optional,default=1"`
 	SizeEstimates int `yaml:"size_estimates,optional,default=4"`
 }
 type PropertyRecvOptions struct {
 	Inherit  []zfsprop.Property          `yaml:"inherit,optional"`
 	Override map[zfsprop.Property]string `yaml:"override,optional"`
 }
 type PlaceholderRecvOptions struct {
 	Encryption string `yaml:"encryption,default=unspecified"`
 }
 type PushJob struct {
@@ -153,9 +106,6 @@ type PushJob struct {
 	Send         *SendOptions      `yaml:"send,fromdefaults,optional"`
 }
 func (j *PushJob) GetFilesystems() FilesystemsFilter { return j.Filesystems }
 func (j *PushJob) GetSendOptions() *SendOptions      { return j.Send }
 type PullJob struct {
 	ActiveJob `yaml:",inline"`
 	RootFS    string                   `yaml:"root_fs"`
@@ -163,10 +113,6 @@ type PullJob struct {
 	Recv      *RecvOptions             `yaml:"recv,fromdefaults,optional"`
 }
 func (j *PullJob) GetRootFS() string             { return j.RootFS }
 func (j *PullJob) GetAppendClientIdentity() bool { return false }
 func (j *PullJob) GetRecvOptions() *RecvOptions  { return j.Recv }
 type PositiveDurationOrManual struct {
 	Interval time.Duration
 	Manual   bool
@@ -187,10 +133,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
 }
@@ -201,10 +150,6 @@ type SinkJob struct {
 	Recv       *RecvOptions `yaml:"recv,optional,fromdefaults"`
 }
 func (j *SinkJob) GetRootFS() string             { return j.RootFS }
 func (j *SinkJob) GetAppendClientIdentity() bool { return true }
 func (j *SinkJob) GetRecvOptions() *RecvOptions  { return j.Recv }
 type SourceJob struct {
 	PassiveJob   `yaml:",inline"`
 	Snapshotting SnapshottingEnum  `yaml:"snapshotting"`
@@ -212,9 +157,6 @@ type SourceJob struct {
 	Send         *SendOptions      `yaml:"send,optional,fromdefaults"`
 }
 func (j *SourceJob) GetFilesystems() FilesystemsFilter { return j.Filesystems }
 func (j *SourceJob) GetSendOptions() *SendOptions      { return j.Send }
 type FilesystemsFilter map[string]bool
 type SnapshottingEnum struct {
@@ -222,49 +164,10 @@ type SnapshottingEnum struct {
 }
 type SnapshottingPeriodic struct {
-	Type                    string            `yaml:"type"`
+	Type     string        `yaml:"type"`
-	Prefix                  string            `yaml:"prefix"`
+	Prefix   string        `yaml:"prefix"`
-	Interval                *PositiveDuration `yaml:"interval"`
+	Interval time.Duration `yaml:"interval,positive"`
-	Hooks                   HookList          `yaml:"hooks,optional"`
+	Hooks    HookList      `yaml:"hooks,optional"`
 	TimestampFormattingSpec `yaml:",inline"`
 }
 type TimestampFormattingSpec struct {
 	TimestampFormat   string `yaml:"timestamp_format,optional,default=dense"`
 	TimestampLocation string `yaml:"timestamp_location,optional,default=UTC"`
 }
 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"`
 	TimestampFormattingSpec `yaml:",inline"`
 }
 type SnapshottingManual struct {
@@ -306,6 +209,18 @@ type Global struct {
 	Serve      *GlobalServe           `yaml:"serve,optional,fromdefaults"`
 }
 func Default(i interface{}) {
 	v := reflect.ValueOf(i)
 	if v.Kind() != reflect.Ptr {
 		panic(v)
 	}
 	y := `{}`
 	err := yaml.Unmarshal([]byte(y), v.Interface())
 	if err != nil {
 		panic(err)
 	}
 }
 type ConnectEnum struct {
 	Ret interface{}
 }
@@ -397,7 +312,6 @@ type PruneKeepNotReplicated struct {
 type PruneKeepLastN struct {
 	Type  string `yaml:"type"`
 	Count int    `yaml:"count"`
 	Regex string `yaml:"regex,optional"`
 }
 type PruneKeepRegex struct { // FIXME rename to KeepRegex
@@ -472,6 +386,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 {
@@ -570,7 +492,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
 }
@@ -659,9 +580,8 @@ var ConfigFileDefaultLocations = []string{
 	"/usr/local/etc/zrepl/zrepl.yml",
 }
-func ParseConfig(path string) (rootConfig *Config, err error) {
+func ParseConfig(path string) (i *Config, err error) {
 	// Parse main configuration file
 	if path == "" {
 		// Try default locations
 		for _, l := range ConfigFileDefaultLocations {
@@ -680,94 +600,11 @@ func ParseConfig(path string) (rootConfig *Config, err error) {
 	var bytes []byte
-	if bytes, err = os.ReadFile(path); err != nil {
+	if bytes, err = ioutil.ReadFile(path); err != nil {
 		return
 	}
-	rootConfig, err = ParseConfigBytes(bytes)
+	return ParseConfigBytes(bytes)
 	if err != nil {
 		return nil, err
 	}
 	err = expandConfigInclude(path, rootConfig)
 	if err != nil {
 		return nil, err
 	}
 	if err = validateJobNames(rootConfig); err != nil {
 		return nil, err
 	}
 	return rootConfig, err
 }
 func IsInternalJobName(s string) bool {
 	return strings.HasPrefix(s, "_")
 }
 func validateJobNames(config *Config) error {
 	seen := make(map[string]struct{})
 	for _, job := range config.Jobs {
 		name := job.Name()
 		if IsInternalJobName(name) {
 			return errors.Errorf("job name %q is reserved for internal use (starts with _)", name)
 		}
 		if _, ok := seen[name]; ok {
 			return errors.Errorf("duplicate job name %q", name)
 		}
 		seen[name] = struct{}{}
 	}
 	return nil
 }
 func expandConfigInclude(configPath string, config *Config) (err error) {
 	var includeConfigPaths []string
 	for _, path := range config.Include {
 		if !pathpkg.IsAbs(configPath) {
 			path = pathpkg.Join(pathpkg.Dir(configPath), path)
 		}
 		stat, statErr := os.Stat(path)
 		if statErr != nil {
 			return errors.Wrapf(statErr, "stat path %q", path)
 		}
 		if stat.Mode().IsDir() {
 			directoryPaths, err := filepath.Glob(path + "/*.yml")
 			if err != nil {
 				return err
 			}
 			includeConfigPaths = append(includeConfigPaths, directoryPaths...)
 		} else if stat.Mode().IsRegular() {
 			if extention := filepath.Ext(path); extention != ".yml" {
 				return fmt.Errorf("include config files must end with `.yml`: %s", path)
 			}
 			includeConfigPaths = append(includeConfigPaths, path)
 		} else {
 			return fmt.Errorf("not a file or directory: %s", path)
 		}
 	}
 	for _, path := range includeConfigPaths {
 		var bytes []byte
 		if bytes, err = os.ReadFile(path); err != nil {
 			return errors.Wrapf(err, "read file: %q", path)
 		}
 		includedConfig, err := ParseConfigBytes(bytes)
 		if err != nil {
 			return err
 		}
 		if len(includedConfig.Include) > 0 {
 			return errors.Errorf("included configuration files must not include other files: %s", path)
 		}
 		config.Jobs = append(config.Jobs, includedConfig.Jobs...)
 	}
 	return nil
 }
 func ParseConfigBytes(bytes []byte) (*Config, error) {
@@ -775,16 +612,46 @@ func ParseConfigBytes(bytes []byte) (*Config, error) {
 	if err := yaml.UnmarshalStrict(bytes, &c); err != nil {
 		return nil, err
 	}
 	if c != nil {
 		return c, nil
 	}
 	// There was no yaml document in the file, deserialize from default.
 	// => See TestFromdefaultsEmptyDoc in yaml-config package.
 	if err := yaml.UnmarshalStrict([]byte("{}"), &c); err != nil {
 		return nil, err
 	}
 	if c == nil {
-		panic("the fallback to deserialize from `{}` should work")
+		return nil, fmt.Errorf("config is empty or only consists of comments")
 	}
 	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
 }
@@ -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) {
@@ -2,8 +2,16 @@ package config
 import (
 	"testing"
 	"github.com/stretchr/testify/assert"
 )
 func TestConfigEmptyFails(t *testing.T) {
 	conf, err := testConfig(t, "\n")
 	assert.Nil(t, conf)
 	assert.Error(t, err)
 }
 func TestJobsOnlyWorks(t *testing.T) {
 	testValidConfig(t, `
 jobs:
@@ -26,7 +34,7 @@ jobs:
    keep_sender:
    - type: not_replicated
    keep_receiver:
-    - type: last_n
+    - type: last_n 
      count: 1
 `)
 }
@@ -0,0 +1,74 @@
 package config
 import (
 	"fmt"
 	"testing"
 	"github.com/stretchr/testify/assert"
 )
 func TestSendOptions(t *testing.T) {
 	tmpl := `
 jobs:
 - name: foo
  type: push
  connect:
    type: local
    listener_name: foo
    client_identity: bar
  filesystems: {"<": true}
  %s
  snapshotting:
    type: manual
  pruning:
    keep_sender:
    - type: last_n
      count: 10
    keep_receiver:
    - type: last_n
      count: 10
 `
 	encrypted_false := `
  send:
    encrypted: false
 `
 	encrypted_true := `
  send:
    encrypted: true
 `
 	encrypted_unspecified := `
  send: {}
 `
 	send_not_specified := `
 `
 	fill := func(s string) string { return fmt.Sprintf(tmpl, s) }
 	var c *Config
 	t.Run("encrypted_false", func(t *testing.T) {
 		c = testValidConfig(t, fill(encrypted_false))
 		encrypted := c.Jobs[0].Ret.(*PushJob).Send.Encrypted
 		assert.Equal(t, false, encrypted)
 	})
 	t.Run("encrypted_true", func(t *testing.T) {
 		c = testValidConfig(t, fill(encrypted_true))
 		encrypted := c.Jobs[0].Ret.(*PushJob).Send.Encrypted
 		assert.Equal(t, true, encrypted)
 	})
 	t.Run("encrypted_unspecified", func(t *testing.T) {
 		c, err := testConfig(t, fill(encrypted_unspecified))
 		assert.Error(t, err)
 		assert.Nil(t, c)
 	})
 	t.Run("send_not_specified", func(t *testing.T) {
 		c, err := testConfig(t, fill(send_not_specified))
 		assert.NoError(t, err)
 		assert.NotNil(t, c)
 	})
 }
@@ -0,0 +1,90 @@
 package config
 import (
 	"fmt"
 	"testing"
 	"time"
 	"github.com/stretchr/testify/assert"
 )
 func TestSnapshotting(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
 `
 	manual := `
  snapshotting:
    type: manual
 `
 	periodic := `
  snapshotting:
    type: periodic
    prefix: zrepl_
    interval: 10m
 `
 	hooks := `
  snapshotting:
    type: periodic
    prefix: zrepl_
    interval: 10m
    hooks:
    - type: command
      path: /tmp/path/to/command
    - type: command
      path: /tmp/path/to/command
      filesystems: { "zroot<": true, "<": false }
    - type: postgres-checkpoint
      dsn: "host=localhost port=5432 user=postgres sslmode=disable"
      filesystems: {
          "tank/postgres/data11": true
      }
    - type: mysql-lock-tables
      dsn: "root@tcp(localhost)/"
      filesystems: {
        "tank/mysql": true
      }
 `
 	fillSnapshotting := func(s string) string { return fmt.Sprintf(tmpl, s) }
 	var c *Config
 	t.Run("manual", func(t *testing.T) {
 		c = testValidConfig(t, fillSnapshotting(manual))
 		snm := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingManual)
 		assert.Equal(t, "manual", snm.Type)
 	})
 	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)
 		assert.Equal(t, "zrepl_", snp.Prefix)
 	})
 	t.Run("hooks", func(t *testing.T) {
 		c = testValidConfig(t, fillSnapshotting(hooks))
 		hs := c.Jobs[0].Ret.(*PushJob).Snapshotting.Ret.(*SnapshottingPeriodic).Hooks
 		assert.Equal(t, hs[0].Ret.(*HookCommand).Filesystems["<"], true)
 		assert.Equal(t, hs[1].Ret.(*HookCommand).Filesystems["zroot<"], true)
 		assert.Equal(t, hs[2].Ret.(*HookPostgresCheckpoint).Filesystems["tank/postgres/data11"], true)
 		assert.Equal(t, hs[3].Ret.(*HookMySQLLockTables).Filesystems["tank/mysql"], true)
 	})
 }
@@ -0,0 +1,88 @@
 package config
 import (
 	"bufio"
 	"bytes"
 	"fmt"
 	"path"
 	"path/filepath"
 	"strings"
 	"testing"
 	"text/template"
 	"github.com/kr/pretty"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 func TestSampleConfigsAreParsedWithoutErrors(t *testing.T) {
 	paths, err := filepath.Glob("./samples/*")
 	if err != nil {
 		t.Errorf("glob failed: %+v", err)
 	}
 	for _, p := range paths {
 		if path.Ext(p) != ".yml" {
 			t.Logf("skipping file %s", p)
 			continue
 		}
 		t.Run(p, func(t *testing.T) {
 			c, err := ParseConfig(p)
 			if err != nil {
 				t.Errorf("error parsing %s:\n%+v", p, err)
 			}
 			t.Logf("file: %s", p)
 			t.Log(pretty.Sprint(c))
 		})
 	}
 }
 // template must be a template/text template with a single '{{ . }}' as placeholder for val
 //nolint[:deadcode,unused]
 func testValidConfigTemplate(t *testing.T, tmpl string, val string) *Config {
 	tmp, err := template.New("master").Parse(tmpl)
 	if err != nil {
 		panic(err)
 	}
 	var buf bytes.Buffer
 	err = tmp.Execute(&buf, val)
 	if err != nil {
 		panic(err)
 	}
 	return testValidConfig(t, buf.String())
 }
 func testValidConfig(t *testing.T, input string) *Config {
 	t.Helper()
 	conf, err := testConfig(t, input)
 	require.NoError(t, err)
 	require.NotNil(t, conf)
 	return conf
 }
 func testConfig(t *testing.T, input string) (*Config, error) {
 	t.Helper()
 	return ParseConfigBytes([]byte(input))
 }
 func trimSpaceEachLineAndPad(s, pad string) string {
 	var out strings.Builder
 	scan := bufio.NewScanner(strings.NewReader(s))
 	for scan.Scan() {
 		fmt.Fprintf(&out, "%s%s\n", pad, bytes.TrimSpace(scan.Bytes()))
 	}
 	return out.String()
 }
 func TestTrimSpaceEachLineAndPad(t *testing.T) {
 	foo := `
 	foo
 	bar baz 
 	`
 	assert.Equal(t, "  \n  foo\n  bar baz\n  \n", trimSpaceEachLineAndPad(foo, "  "))
 }
@@ -37,7 +37,7 @@ func (t *RetentionIntervalList) UnmarshalYAML(u func(interface{}, bool) error) (
 		return err
 	}
-	intervals, err := ParseRetentionIntervalSpec(in)
+	intervals, err := parseRetentionGridIntervalsString(in)
 	if err != nil {
 		return err
 	}
@@ -102,7 +102,7 @@ func parseRetentionGridIntervalString(e string) (intervals []RetentionInterval,
 }
-func ParseRetentionIntervalSpec(s string) (intervals []RetentionInterval, err error) {
+func parseRetentionGridIntervalsString(s string) (intervals []RetentionInterval, err error) {
 	ges := strings.Split(s, "|")
 	intervals = make([]RetentionInterval, 0, 7*len(ges))
@@ -5,11 +5,7 @@ jobs:
    type: tcp
    listen: "0.0.0.0:8888"
    clients: {
-      "192.168.122.123" :               "mysql01",
+      "192.168.122.123" : "client1"
      "192.168.122.42" :                "mx01",
      "2001:0db8:85a3::8a2e:0370:7334": "gateway",
      "10.23.42.0/24":       "cluster-*",
      "fde4:8dba:82e1::/64": "san-*",
    }
  filesystems: {
    "<": true,
@@ -8,20 +8,19 @@ import (
 	"io"
 	"net"
 	"net/http"
 	"os"
 	"time"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/zrepl/zrepl/internal/daemon/job"
+	"github.com/zrepl/zrepl/daemon/job"
-	"github.com/zrepl/zrepl/internal/daemon/nethelpers"
+	"github.com/zrepl/zrepl/daemon/nethelpers"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/util/envconst"
-	"github.com/zrepl/zrepl/internal/version"
+	"github.com/zrepl/zrepl/version"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
-	"github.com/zrepl/zrepl/internal/zfs/zfscmd"
+	"github.com/zrepl/zrepl/zfs/zfscmd"
 )
 type controlJob struct {
@@ -121,14 +120,7 @@ func (j *controlJob) Run(ctx context.Context) {
 		jsonResponder{log, func() (interface{}, error) {
 			jobs := j.jobs.status()
 			globalZFS := zfscmd.GetReport()
-			envconstReport := envconst.GetReport()
+			s := Status{Jobs: jobs, Global: GlobalStatus{ZFSCmds: globalZFS}}
 			s := Status{
 				Jobs: jobs,
 				Global: GlobalStatus{
 					ZFSCmds:   globalZFS,
 					Envconst:  envconstReport,
 					OsEnviron: os.Environ(),
 				}}
 			return s, nil
 		}})
@@ -158,8 +150,8 @@ func (j *controlJob) Run(ctx context.Context) {
 	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),
+		WriteTimeout: 1 * time.Second,
-		ReadTimeout:  envconst.Duration("ZREPL_DAEMON_CONTROL_SERVER_READ_TIMEOUT", 1*time.Second),
+		ReadTimeout:  1 * time.Second,
 	}
 outer:
@@ -5,25 +5,23 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
 	"strings"
 	"sync"
 	"syscall"
 	"time"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/daemon/job"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/daemon/job/reset"
-
+	"github.com/zrepl/zrepl/daemon/job/wakeup"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/internal/daemon/job"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/daemon/job/reset"
+	"github.com/zrepl/zrepl/version"
-	"github.com/zrepl/zrepl/internal/daemon/job/wakeup"
+	"github.com/zrepl/zrepl/zfs/zfscmd"
 	"github.com/zrepl/zrepl/internal/daemon/logging"
 	"github.com/zrepl/zrepl/internal/logger"
 	"github.com/zrepl/zrepl/internal/version"
 	"github.com/zrepl/zrepl/internal/zfs/zfscmd"
 )
 func Run(ctx context.Context, conf *config.Config) error {
@@ -43,7 +41,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")
 	}
@@ -52,18 +50,9 @@ func Run(ctx context.Context, conf *config.Config) error {
 	log.Info(version.NewZreplVersionInformation().String())
 	ctx = logging.WithLoggers(ctx, logging.SubsystemLoggersWithUniversalLogger(log))
 	trace.RegisterCallback(trace.Callback{
 		OnBegin: func(ctx context.Context) { logging.GetLogger(ctx, logging.SubsysTraceData).Debug("begin span") },
 		OnEnd: func(ctx context.Context, spanInfo trace.SpanInfo) {
 			logging.
 				GetLogger(ctx, logging.SubsysTraceData).
 				WithField("duration_s", spanInfo.EndedAt().Sub(spanInfo.StartedAt()).Seconds()).
 				Debug("finished span " + spanInfo.TaskAndSpanStack(trace.SpanStackKindAnnotation))
 		},
 	})
 	for _, job := range confJobs {
-		if config.IsInternalJobName(job.Name()) {
+		if IsInternalJobName(job.Name()) {
 			panic(fmt.Sprintf("internal job name used for config job '%s'", job.Name())) //FIXME
 		}
 	}
@@ -95,10 +84,8 @@ func Run(ctx context.Context, conf *config.Config) error {
 	}
 	// register global (=non job-local) metrics
 	version.PrometheusRegister(prometheus.DefaultRegisterer)
 	zfscmd.RegisterMetrics(prometheus.DefaultRegisterer)
 	trace.RegisterMetrics(prometheus.DefaultRegisterer)
 	endpoint.RegisterMetrics(prometheus.DefaultRegisterer)
 	log.Info("starting daemon")
@@ -152,9 +139,7 @@ type Status struct {
 }
 type GlobalStatus struct {
-	ZFSCmds   *zfscmd.Report
+	ZFSCmds *zfscmd.Report
 	Envconst  *envconst.Report
 	OsEnviron []string
 }
 func (s *jobs) status() map[string]*job.Status {
@@ -210,6 +195,10 @@ const (
 	jobNameControl    = "_control"
 )
 func IsInternalJobName(s string) bool {
 	return strings.HasPrefix(s, "_")
 }
 func (s *jobs) start(ctx context.Context, j job.Job, internal bool) {
 	s.m.Lock()
 	defer s.m.Unlock()
@@ -217,12 +206,10 @@ func (s *jobs) start(ctx context.Context, j job.Job, internal bool) {
 	ctx = logging.WithInjectedField(ctx, logging.JobField, j.Name())
 	jobName := j.Name()
-
+	if !internal && IsInternalJobName(jobName) {
 	// package `config` enforces these with clean errors, these are just assertions
 	if !internal && config.IsInternalJobName(jobName) {
 		panic(fmt.Sprintf("internal job name used for non-internal job %s", jobName))
 	}
-	if internal && !config.IsInternalJobName(jobName) {
+	if internal && !IsInternalJobName(jobName) {
 		panic(fmt.Sprintf("internal job does not use internal job name %s", jobName))
 	}
 	if _, ok := s.jobs[jobName]; ok {
@@ -6,8 +6,8 @@ import (
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 type DatasetMapFilter struct {
@@ -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) {
@@ -3,7 +3,7 @@ package filters
 import (
 	"testing"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 func TestDatasetMapFilter(t *testing.T) {
@@ -3,8 +3,8 @@ package hooks
 import (
 	"fmt"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 type List []Hook
@@ -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
@@ -7,7 +7,7 @@ import (
 	"sync"
 	"time"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 // Re-export type here so that
@@ -6,9 +6,9 @@ import (
 	"context"
 	"sync"
-	"github.com/zrepl/zrepl/internal/daemon/logging"
+	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/util/envconst"
 )
 type Logger = logger.Logger
@@ -4,8 +4,8 @@ import (
 	"context"
 	"fmt"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 type HookJobCallback func(ctx context.Context) error
@@ -12,11 +12,11 @@ import (
 	"sync"
 	"time"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/util/circlog"
+	"github.com/zrepl/zrepl/util/circlog"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/util/envconst"
 )
 type HookEnvVar string
@@ -93,14 +93,7 @@ func (r *CommandHookReport) String() string {
 		cmdLine.WriteString(fmt.Sprintf("%s'%s'", sep, a))
 	}
-	var msg string
+	return fmt.Sprintf("command hook invocation: \"%s\"", cmdLine.String()) // no %q to make copy-pastable
 	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
 }
 func (r *CommandHookReport) Error() string {
 	if r.Err == nil {
@@ -12,27 +12,24 @@ import (
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"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 a client program, execute FLUSH TABLES WITH READ LOCK.
-//	   	From another shell, execute mount vxfs snapshot.
+//    	From another shell, execute mount vxfs snapshot.
-//	   	From the first client, execute UNLOCK TABLES.
+//    	From the first client, execute UNLOCK TABLES.
-//	   	Copy files from the snapshot.
+//    	Copy files from the snapshot.
-//	   	Unmount 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
@@ -10,9 +10,9 @@ import (
 	"github.com/lib/pq"
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 type PgChkptHook struct {
@@ -10,14 +10,13 @@ import (
 	"text/template"
 	"github.com/stretchr/testify/require"
 	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/config"
-
+	"github.com/zrepl/zrepl/daemon/hooks"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/internal/daemon/hooks"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/daemon/logging"
+	"github.com/zrepl/zrepl/zfs"
 	"github.com/zrepl/zrepl/internal/logger"
 	"github.com/zrepl/zrepl/internal/zfs"
 )
 type comparisonAssertionFunc func(require.TestingT, interface{}, interface{}, ...interface{})
@@ -161,7 +160,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 +184,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 +233,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 +266,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 +294,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{
@@ -1,5 +1,6 @@
 // Code generated by "enumer -type=StepStatus -trimprefix=Step"; DO NOT EDIT.
 //
 package hooks
 import (
@@ -8,24 +8,24 @@ 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/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/daemon/filters"
-
+	"github.com/zrepl/zrepl/daemon/job/reset"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/daemon/job/wakeup"
-	"github.com/zrepl/zrepl/internal/daemon/job/reset"
+	"github.com/zrepl/zrepl/daemon/pruner"
-	"github.com/zrepl/zrepl/internal/daemon/job/wakeup"
+	"github.com/zrepl/zrepl/daemon/snapper"
-	"github.com/zrepl/zrepl/internal/daemon/pruner"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/daemon/snapper"
+	"github.com/zrepl/zrepl/replication"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/replication/driver"
-	"github.com/zrepl/zrepl/internal/replication"
+	"github.com/zrepl/zrepl/replication/logic"
-	"github.com/zrepl/zrepl/internal/replication/driver"
+	"github.com/zrepl/zrepl/replication/report"
-	"github.com/zrepl/zrepl/internal/replication/logic"
+	"github.com/zrepl/zrepl/rpc"
-	"github.com/zrepl/zrepl/internal/replication/report"
+	"github.com/zrepl/zrepl/transport"
-	"github.com/zrepl/zrepl/internal/rpc"
+	"github.com/zrepl/zrepl/transport/fromconfig"
-	"github.com/zrepl/zrepl/internal/transport"
+	"github.com/zrepl/zrepl/zfs"
 	"github.com/zrepl/zrepl/internal/transport/fromconfig"
 	"github.com/zrepl/zrepl/internal/zfs"
 )
 type ActiveSide struct {
@@ -33,15 +33,11 @@ type ActiveSide struct {
 	name      endpoint.JobID
 	connecter transport.Connecter
 	replicationDriverConfig driver.Config
 	prunerFactory *pruner.PrunerFactory
-	promRepStateSecs      *prometheus.HistogramVec // labels: state
+	promRepStateSecs    *prometheus.HistogramVec // labels: state
-	promPruneSecs         *prometheus.HistogramVec // labels: prune_side
+	promPruneSecs       *prometheus.HistogramVec // labels: prune_side
-	promBytesReplicated   *prometheus.CounterVec   // labels: filesystem
+	promBytesReplicated *prometheus.CounterVec   // labels: filesystem
 	promReplicationErrors prometheus.Gauge
 	promLastSuccessful    prometheus.Gauge
 	tasksMtx sync.Mutex
 	tasks    activeSideTasks
@@ -100,7 +96,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) {
@@ -136,8 +132,7 @@ func (m *modePush) RunPeriodic(ctx context.Context, wakeUpCommon chan<- struct{}
 }
 func (m *modePush) SnapperReport() *snapper.Report {
-	r := m.snapper.Report()
+	return m.snapper.Report()
 	return &r
 }
 func (m *modePush) ResetConnectBackoff() {
@@ -150,33 +145,22 @@ func (m *modePush) ResetConnectBackoff() {
 func modePushFromConfig(g *config.Global, in *config.PushJob, jobID endpoint.JobID) (*modePush, error) {
 	m := &modePush{}
 	var err error
-	m.senderConfig, err = buildSenderConfig(in, jobID)
+	fsf, err := filters.DatasetMapFilterFromConfig(in.Filesystems)
 	if err != nil {
-		return nil, errors.Wrap(err, "sender config")
+		return nil, errors.Wrap(err, "cannot build filesystem filter")
 	}
-	replicationConfig, err := logic.ReplicationConfigFromConfig(in.Replication)
+	m.senderConfig = &endpoint.SenderConfig{
-	if err != nil {
+		FSF:     fsf,
-		return nil, errors.Wrap(err, "field `replication`")
+		Encrypt: &zfs.NilBool{B: in.Send.Encrypted},
 		JobID:   jobID,
 	}
 	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,
 	}
 	if err := m.plannerPolicy.Validate(); err != nil {
 		return nil, errors.Wrap(err, "cannot build planner policy")
 	}
-	if m.snapper, err = snapper.FromConfig(g, m.senderConfig.FSF, in.Snapshotting); err != nil {
+	if m.snapper, err = snapper.FromConfig(g, fsf, in.Snapshotting); err != nil {
 		return nil, errors.Wrap(err, "cannot build snapper")
 	}
@@ -188,6 +172,7 @@ type modePull struct {
 	receiver       *endpoint.Receiver
 	receiverConfig endpoint.ReceiverConfig
 	sender         *rpc.Client
 	rootFS         *zfs.DatasetPath
 	plannerPolicy  *logic.PlannerPolicy
 	interval       config.PositiveDurationOrManual
 }
@@ -261,44 +246,32 @@ func modePullFromConfig(g *config.Global, in *config.PullJob, jobID endpoint.Job
 	m = &modePull{}
 	m.interval = in.Interval
-	replicationConfig, err := logic.ReplicationConfigFromConfig(in.Replication)
+	m.rootFS, err = zfs.NewDatasetPath(in.RootFS)
 	if err != nil {
-		return nil, errors.Wrap(err, "field `replication`")
+		return nil, errors.New("RootFS is not a valid zfs filesystem path")
 	}
-
+	if m.rootFS.Length() <= 0 {
-	conflictResolution, err := logic.ConflictResolutionFromConfig(in.ConflictResolution)
+		return nil, errors.New("RootFS must not be empty") // duplicates error check of receiver
 	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,
 	}
 	if err := m.plannerPolicy.Validate(); err != nil {
 		return nil, errors.Wrap(err, "cannot build planner policy")
 	}
-	m.receiverConfig, err = buildReceiverConfig(in, jobID)
+	m.receiverConfig = endpoint.ReceiverConfig{
-	if err != nil {
+		JobID:                      jobID,
-		return nil, err
+		RootWithoutClientComponent: m.rootFS,
 		AppendClientIdentity:       false, // !
 		UpdateLastReceivedHold:     true,
 	}
 	if err := m.receiverConfig.Validate(); err != nil {
 		return nil, errors.Wrap(err, "cannot build receiver config")
 	}
 	return m, nil
 }
-func replicationDriverConfigFromConfig(in *config.Replication) (c driver.Config, err error) {
+func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}) (j *ActiveSide, err error) {
 	c = driver.Config{
 		StepQueueConcurrency:     in.Concurrency.Steps,
 		MaxAttempts:              envconst.Int("ZREPL_REPLICATION_MAX_ATTEMPTS", 3),
 		ReconnectHardFailTimeout: envconst.Duration("ZREPL_REPLICATION_RECONNECT_HARD_FAIL_TIMEOUT", 10*time.Minute),
 	}
 	err = c.Validate()
 	return c, err
 }
 func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}, parseFlags config.ParseFlags) (j *ActiveSide, err error) {
 	j = &ActiveSide{}
 	j.name, err = endpoint.MakeJobID(in.Name)
@@ -332,22 +305,8 @@ 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",
 		Name:        "filesystem_errors",
 		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")
 	}
@@ -364,11 +323,6 @@ func activeSide(g *config.Global, in *config.ActiveJob, configJob interface{}, p
 		return nil, err
 	}
 	j.replicationDriverConfig, err = replicationDriverConfigFromConfig(in.Replication)
 	if err != nil {
 		return nil, errors.Wrap(err, "cannot build replication driver config")
 	}
 	return j, nil
 }
@@ -376,8 +330,6 @@ func (j *ActiveSide) RegisterMetrics(registerer prometheus.Registerer) {
 	registerer.MustRegister(j.promRepStateSecs)
 	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() }
@@ -412,7 +364,7 @@ func (j *ActiveSide) OwnedDatasetSubtreeRoot() (rfs *zfs.DatasetPath, ok bool) {
 		_ = j.mode.(*modePush) // make sure we didn't introduce a new job type
 		return nil, false
 	}
-	return pull.receiverConfig.RootWithoutClientComponent.Copy(), true
+	return pull.rootFS.Copy(), true
 }
 func (j *ActiveSide) SenderConfig() *endpoint.SenderConfig {
@@ -424,21 +376,9 @@ func (j *ActiveSide) SenderConfig() *endpoint.SenderConfig {
 	return push.senderConfig
 }
 // The active side of a replication uses one end (sender or receiver)
 // directly by method invocation, without going through a transport that
 // provides a client identity.
 // However, in order to avoid the need to distinguish between direct-method-invocating
 // clients and RPC client, we use an invalid client identity as a sentinel value.
 func FakeActiveSideDirectMethodInvocationClientIdentity(jobId endpoint.JobID) string {
 	return fmt.Sprintf("<local><active><job><client><identity><job=%q>", jobId.String())
 }
 func (j *ActiveSide) Run(ctx context.Context) {
 	ctx, endTask := trace.WithTaskAndSpan(ctx, "active-side-job", j.Name())
 	defer endTask()
 	ctx = context.WithValue(ctx, endpoint.ClientIdentityKey, FakeActiveSideDirectMethodInvocationClientIdentity(j.name))
 	log := GetLogger(ctx)
 	defer log.Info("job exiting")
@@ -481,7 +421,7 @@ func (j *ActiveSide) do(ctx context.Context) {
 	go func() {
 		select {
 		case <-reset.Wait(ctx):
-			GetLogger(ctx).Info("reset received, cancelling current invocation")
+			log.Info("reset received, cancelling current invocation")
 			cancelThisRun()
 		case <-ctx.Done():
 		}
@@ -503,21 +443,13 @@ func (j *ActiveSide) do(ctx context.Context) {
 			*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()),
+				ctx, 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()
 		var numErrors = replicationReport.GetFailedFilesystemsCountInLatestAttempt()
 		j.promReplicationErrors.Set(float64(numErrors))
 		if numErrors == 0 {
 			j.promLastSuccessful.SetToCurrentTime()
 		}
 		endSpan()
 	}
@@ -1,5 +1,6 @@
 // Code generated by "enumer -type=ActiveSideState"; DO NOT EDIT.
 //
 package job
 import (
@@ -7,14 +7,13 @@ import (
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/internal/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
 }
@@ -0,0 +1,110 @@
 package job
 import (
 	"fmt"
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/zrepl/zrepl/config"
 )
 func TestValidateReceivingSidesDoNotOverlap(t *testing.T) {
 	type testCase struct {
 		err   bool
 		input []string
 	}
 	tcs := []testCase{
 		{false, nil},
 		{false, []string{}},
 		{false, []string{""}}, // not our job to determine valid paths
 		{false, []string{"a"}},
 		{false, []string{"some/path"}},
 		{false, []string{"zroot/sink1", "zroot/sink2", "zroot/sink3"}},
 		{false, []string{"zroot/foo", "zroot/foobar"}},
 		{true, []string{"zroot/b", "zroot/b"}},
 		{true, []string{"zroot/foo", "zroot/foo/bar", "zroot/baz"}},
 		{false, []string{"a/x", "b/x"}},
 		{false, []string{"a", "b"}},
 		{true, []string{"a", "a"}},
 		{true, []string{"a/x/y", "a/x"}},
 		{true, []string{"a/x", "a/x/y"}},
 		{true, []string{"a/x", "b/x", "a/x/y"}},
 		{true, []string{"a", "a/b", "a/c", "a/b"}},
 		{true, []string{"a/b", "a/c", "a/b", "a/d", "a/c"}},
 	}
 	for _, tc := range tcs {
 		t.Logf("input: %v", tc.input)
 		err := validateReceivingSidesDoNotOverlap(tc.input)
 		if tc.err {
 			assert.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 		}
 	}
 }
 func TestJobIDErrorHandling(t *testing.T) {
 	tmpl := `
 jobs:
 - name: %s
  type: push
  connect:
    type: local
    listener_name: foo
    client_identity: bar
  filesystems: {"<": true}
  snapshotting:
    type: manual
  pruning:
    keep_sender:
    - type: last_n
      count: 10
    keep_receiver:
    - type: last_n
      count: 10
 `
 	fill := func(s string) string { return fmt.Sprintf(tmpl, s) }
 	type Case struct {
 		jobName string
 		valid   bool
 	}
 	cases := []Case{
 		{"validjobname", true},
 		{"valid with spaces", true},
 		{"invalid\twith\ttabs", false},
 		{"invalid#withdelimiter", false},
 		{"invalid@withdelimiter", false},
 		{"withnewline\\nmiddle", false},
 		{"withnewline\\n", false},
 		{"withslash/", false},
 		{"withslash/inthemiddle", false},
 		{"/", false},
 	}
 	for i := range cases {
 		t.Run(cases[i].jobName, func(t *testing.T) {
 			c := cases[i]
 			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)
 			if c.valid {
 				assert.NoError(t, err)
 				require.Len(t, jobs, 1)
 				assert.Equal(t, c.jobName, jobs[0].Name())
 			} else {
 				t.Logf("error: %s", err)
 				assert.Error(t, err)
 				assert.Nil(t, jobs)
 			}
 		})
 	}
 }
@@ -7,10 +7,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/zrepl/zrepl/internal/daemon/logging"
+	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/zfs"
+	"github.com/zrepl/zrepl/zfs"
 )
 type Logger = logger.Logger
@@ -6,17 +6,17 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/config"
-
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/internal/daemon/logging"
+	"github.com/zrepl/zrepl/daemon/snapper"
-	"github.com/zrepl/zrepl/internal/daemon/snapper"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/endpoint"
+	"github.com/zrepl/zrepl/rpc"
-	"github.com/zrepl/zrepl/internal/rpc"
+	"github.com/zrepl/zrepl/transport"
-	"github.com/zrepl/zrepl/internal/transport"
+	"github.com/zrepl/zrepl/transport/fromconfig"
-	"github.com/zrepl/zrepl/internal/transport/fromconfig"
+	"github.com/zrepl/zrepl/zfs"
 	"github.com/zrepl/zrepl/internal/zfs"
 )
 type PassiveSide struct {
@@ -48,9 +48,19 @@ func (m *modeSink) SnapperReport() *snapper.Report { return nil }
 func modeSinkFromConfig(g *config.Global, in *config.SinkJob, jobID endpoint.JobID) (m *modeSink, err error) {
 	m = &modeSink{}
-	m.receiverConfig, err = buildReceiverConfig(in, jobID)
+	rootDataset, err := zfs.NewDatasetPath(in.RootFS)
 	if err != nil {
-		return nil, err
+		return nil, errors.New("root dataset is not a valid zfs filesystem path")
 	}
 	m.receiverConfig = endpoint.ReceiverConfig{
 		JobID:                      jobID,
 		RootWithoutClientComponent: rootDataset,
 		AppendClientIdentity:       true, // !
 		UpdateLastReceivedHold:     true,
 	}
 	if err := m.receiverConfig.Validate(); err != nil {
 		return nil, errors.Wrap(err, "cannot build receiver config")
 	}
 	return m, nil
@@ -58,19 +68,23 @@ 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) {
 	// FIXME exact dedup of modePush
 	m = &modeSource{}
-
+	fsf, err := filters.DatasetMapFilterFromConfig(in.Filesystems)
 	m.senderConfig, err = buildSenderConfig(in, jobID)
 	if err != nil {
-		return nil, errors.Wrap(err, "send options")
+		return nil, errors.Wrap(err, "cannot build filesystem filter")
 	}
 	m.senderConfig = &endpoint.SenderConfig{
 		FSF:     fsf,
 		Encrypt: &zfs.NilBool{B: in.Send.Encrypted},
 		JobID:   jobID,
 	}
-	if m.snapper, err = snapper.FromConfig(g, m.senderConfig.FSF, in.Snapshotting); err != nil {
+	if m.snapper, err = snapper.FromConfig(g, fsf, in.Snapshotting); err != nil {
 		return nil, errors.Wrap(err, "cannot build snapper")
 	}
@@ -88,11 +102,10 @@ func (m *modeSource) RunPeriodic(ctx context.Context) {
 }
 func (m *modeSource) SnapperReport() *snapper.Report {
-	r := m.snapper.Report()
+	return m.snapper.Report()
 	return &r
 }
-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 +124,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")
 	}
@@ -4,36 +4,31 @@ import (
 	"context"
 	"fmt"
 	"sort"
 	"sync"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/util/bandwidthlimit"
+	"github.com/zrepl/zrepl/daemon/filters"
-	"github.com/zrepl/zrepl/internal/util/nodefault"
+	"github.com/zrepl/zrepl/daemon/job/wakeup"
-
+	"github.com/zrepl/zrepl/daemon/pruner"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/daemon/snapper"
-	"github.com/zrepl/zrepl/internal/daemon/filters"
+	"github.com/zrepl/zrepl/endpoint"
-	"github.com/zrepl/zrepl/internal/daemon/job/wakeup"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
-	"github.com/zrepl/zrepl/internal/daemon/pruner"
+	"github.com/zrepl/zrepl/zfs"
 	"github.com/zrepl/zrepl/internal/daemon/snapper"
 	"github.com/zrepl/zrepl/internal/endpoint"
 	"github.com/zrepl/zrepl/internal/replication/logic/pdu"
 	"github.com/zrepl/zrepl/internal/zfs"
 )
 type SnapJob struct {
 	name     endpoint.JobID
 	fsfilter zfs.DatasetFilter
-	snapper  snapper.Snapper
+	snapper  *snapper.PeriodicOrManual
 	prunerFactory *pruner.LocalPrunerFactory
 	promPruneSecs *prometheus.HistogramVec // labels: prune_side
-	prunerMtx sync.Mutex
+	pruner *pruner.Pruner
 	pruner    *pruner.Pruner
 }
 func (j *SnapJob) Name() string { return j.name.String() }
@@ -81,13 +76,10 @@ type SnapJobStatus struct {
 func (j *SnapJob) Status() *Status {
 	s := &SnapJobStatus{}
 	t := j.Type()
 	j.prunerMtx.Lock()
 	if j.pruner != nil {
 		s.Pruning = j.pruner.Report()
 	}
-	j.prunerMtx.Unlock()
+	s.Snapshotting = j.snapper.Report()
 	r := j.snapper.Report()
 	s.Snapshotting = &r
 	return &Status{Type: t, JobSpecific: s}
 }
@@ -138,7 +130,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
@@ -148,7 +140,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{
@@ -181,15 +173,10 @@ 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
+		// FIXME encryption setting is irrelevant for SnapJob because the endpoint is only used as pruner.Target
-		// because the endpoint is only used as pruner.Target.
+		Encrypt: &zfs.NilBool{B: true},
 		// However, the implementation requires them to be set.
 		Encrypt:        &nodefault.Bool{B: true},
 		BandwidthLimit: bandwidthlimit.NoLimitConfig(),
 	})
 	j.prunerMtx.Lock()
 	j.pruner = j.prunerFactory.BuildLocalPruner(ctx, sender, alwaysUpToDateReplicationCursorHistory{sender})
 	j.prunerMtx.Unlock()
 	log.Info("start pruning")
 	j.pruner.Prune()
 	log.Info("finished pruning")
@@ -9,11 +9,10 @@ import (
 	"github.com/mattn/go-isatty"
 	"github.com/pkg/errors"
-
+	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/internal/config"
+	"github.com/zrepl/zrepl/daemon/logging/trace"
-	"github.com/zrepl/zrepl/internal/daemon/logging/trace"
+	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/tlsconf"
 	"github.com/zrepl/zrepl/internal/tlsconf"
 )
 func OutletsFromConfig(in config.LoggingOutletEnumList) (*logger.Outlets, error) {
@@ -74,8 +73,6 @@ const (
 	SubsysRPCControl   Subsystem = "rpc.ctrl"
 	SubsysRPCData      Subsystem = "rpc.data"
 	SubsysZFSCmd       Subsystem = "zfs.cmd"
 	SubsysTraceData    Subsystem = "trace.data"
 	SubsysPlatformtest Subsystem = "platformtest"
 )
 var AllSubsystems = []Subsystem{
@@ -92,8 +89,6 @@ var AllSubsystems = []Subsystem{
 	SubsysRPCControl,
 	SubsysRPCData,
 	SubsysZFSCmd,
 	SubsysTraceData,
 	SubsysPlatformtest,
 }
 type injectedField struct {
@@ -162,7 +157,7 @@ func getLoggerImpl(ctx context.Context, subsys Subsystem, panicIfEnded bool) log
 	l = l.WithField(SubsysField, subsys)
-	l = l.WithField(SpanField, trace.GetSpanStackOrDefault(ctx, *trace.StackKindId, "NOSPAN"))
+	l = l.WithField(SpanField, trace.GetSpanStackOrDefault(ctx, "NOSPAN"))
 	fields := make(logger.Fields)
 	iterInjectedFields(ctx, func(field string, value interface{}) {
@@ -10,7 +10,7 @@ import (
 	"github.com/go-logfmt/logfmt"
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
 )
 const (
@@ -11,7 +11,7 @@ import (
 	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/internal/logger"
+	"github.com/zrepl/zrepl/logger"
 )
 type EntryFormatter interface {
@@ -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).
+//  - Neither task nor span is really tangible but instead contained within the context.Context tree
-// - Spans represent a semantic stack trace within a task.
+//  - 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) {
+//   go func(ctx context.Context) {
-//	  ctx, endTask = WithTask(ctx, "what-happens-inside-the-child-task")
+//     ctx, endTask = WithTask(ctx, "what-happens-inside-the-child-task")
-//	  defer endTask()
+//     defer endTask()
-//	  // ...
+//     // ...
-//	}(ctx)
+//   }(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")
+//  ctx, endSpan = WithSpan(ctx, "copy-dir")
-//	defer endSpan()
+//  defer endSpan()
-//	for _, f := range dir.Files() {
+//  for _, f := range dir.Files() {
-//	  func() {
+//    func() {
-//	    ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
+//      ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
-//	    defer endspan()
+//      defer endspan()
-//	    b, _ := ioutil.ReadFile(f)
+//      b, _ := ioutil.ReadFile(f)
-//	    _ = ioutil.WriteFile(f + ".copy", b, 0600)
+//      _ = ioutil.WriteFile(f + ".copy", b, 0600)
-//	  }()
+//    }()
-//	}
+//  }
 //
 // In combination:
-//
+//  ctx, endTask = WithTask(ctx, "copy-dirs")
-//	ctx, endTask = WithTask(ctx, "copy-dirs")
+//  defer endTask()
-//	defer endTask()
+//  for i := range dirs {
-//	for i := range dirs {
+//    go func(dir string) {
-//	  go func(dir string) {
+//      ctx, endTask := WithTask(ctx, "copy-dir")
-//	    ctx, endTask := WithTask(ctx, "copy-dir")
+//      defer endTask()
-//	    defer endTask()
+//      for _, f := range filesIn(dir) {
-//	    for _, f := range filesIn(dir) {
+//        func() {
-//	      func() {
+//          ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
-//	        ctx, endSpan := WithSpan(ctx, fmt.Sprintf("copy-file %q", f))
+//          defer endspan()
-//	        defer endspan()
+//          b, _ := ioutil.ReadFile(f)
-//	        b, _ := ioutil.ReadFile(f)
+//          _ = ioutil.WriteFile(f + ".copy", b, 0600)
-//	        _ = 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 .
@@ -90,22 +93,18 @@ package trace
 import (
 	"context"
 	"fmt"
 	"os"
 	runtimedebug "runtime/debug"
 	"strings"
 	"time"
 	"github.com/kr/pretty"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
-
+	"github.com/zrepl/zrepl/util/chainlock"
 	"github.com/zrepl/zrepl/internal/util/chainlock"
 )
 var metrics struct {
-	activeTasks prometheus.Gauge
+	activeTasks                          prometheus.Gauge
 	uniqueConcurrentTaskNameBitvecLength *prometheus.GaugeVec
 }
 var taskNamer *uniqueConcurrentTaskNamer = newUniqueTaskNamer()
 func init() {
 	metrics.activeTasks = prometheus.NewGauge(prometheus.GaugeOpts{
@@ -114,42 +113,36 @@ func init() {
 		Name:      "active_tasks",
 		Help:      "number of active (tracing-level) tasks in the daemon",
 	})
 	metrics.uniqueConcurrentTaskNameBitvecLength = prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Namespace: "zrepl",
 		Subsystem: "trace",
 		Name:      "unique_concurrent_task_name_bitvec_length",
 		Help:      "length of the bitvec used to find unique names for concurrent tasks",
 	}, []string{"task_name"})
 }
 func RegisterMetrics(r prometheus.Registerer) {
 	r.MustRegister(metrics.activeTasks)
 	r.MustRegister(metrics.uniqueConcurrentTaskNameBitvecLength)
 }
-type traceNode struct {
+var taskNamer = newUniqueTaskNamer(metrics.uniqueConcurrentTaskNameBitvecLength)
 	// NOTE: members with prefix debug are only valid if the package variable debugEnabled is true.
-	id                 string
+type traceNode struct {
-	annotation         string
+	id         string
-	parentTask         *traceNode
+	annotation string
-	debugCreationStack string // debug: stack trace of when the traceNode was created
+	parentTask *traceNode
 	mtx chainlock.L
-	activeChildTasks      int32               // only for task nodes, insignificant for span nodes
+	activeChildTasks int32 // only for task nodes, insignificant for span nodes
-	debugActiveChildTasks map[*traceNode]bool // debug: set of active child tasks
+	parentSpan       *traceNode
-	parentSpan            *traceNode
+	activeChildSpan  *traceNode // nil if task or span doesn't have an active child span
 	activeChildSpan       *traceNode // nil if task or span doesn't have an active child span
 	startedAt time.Time
 	endedAt   time.Time
 }
 func (s *traceNode) StartedAt() time.Time { return s.startedAt }
 func (s *traceNode) EndedAt() time.Time   { return s.endedAt }
 // caller must hold mtx
 func (s *traceNode) debugString() string {
 	if !debugEnabled {
 		return "<debugEnabled=false>"
 	}
 	return pretty.Sprint(s)
 }
 // Returned from WithTask or WithSpan.
 // Must be called once the task or span ends.
 // See package-level docs for nesting rules.
@@ -157,6 +150,7 @@ func (s *traceNode) debugString() string {
 type DoneFunc func()
 var ErrTaskStillHasActiveChildTasks = fmt.Errorf("end task: task still has active child tasks")
 var ErrParentTaskAlreadyEnded = fmt.Errorf("create task: parent task already ended")
 // Start a new root task or create a child task of an existing task.
 //
@@ -180,20 +174,6 @@ func WithTask(ctx context.Context, taskName string) (context.Context, DoneFunc)
 			parentTask = node
 		}
 	}
 	// find the first ancestor that hasn't ended yet (nil if need be)
 	if parentTask != nil {
 		parentTask.mtx.Lock()
 	}
 	for parentTask != nil && !parentTask.endedAt.IsZero() {
 		thisParent := parentTask
 		parentTask = parentTask.parentTask
 		// lock parent first such that it isn't modified by other callers to thisParent
 		if parentTask != nil {
 			parentTask.mtx.Lock()
 		}
 		thisParent.mtx.Unlock()
 	}
 	// invariant: either parentTask != nil and we hold the lock on parentTask, or parentTask is nil
 	taskName, taskNameDone := taskNamer.UniqueConcurrentTaskName(taskName)
@@ -209,17 +189,13 @@ func WithTask(ctx context.Context, taskName string) (context.Context, DoneFunc)
 		endedAt:   time.Time{},
 	}
-	if debugEnabled {
+	if this.parentTask != nil {
-		this.debugCreationStack = string(runtimedebug.Stack())
+		this.parentTask.mtx.HoldWhile(func() {
-		this.debugActiveChildTasks = map[*traceNode]bool{}
+			if !this.parentTask.endedAt.IsZero() {
-	}
+				panic(ErrParentTaskAlreadyEnded)
-
+			}
-	if parentTask != nil {
+			this.parentTask.activeChildTasks++
-		this.parentTask.activeChildTasks++
+		})
 		if debugEnabled {
 			this.parentTask.debugActiveChildTasks[this] = true
 		}
 		parentTask.mtx.Unlock()
 	}
 	ctx = context.WithValue(ctx, contextKeyTraceNode, this)
@@ -239,11 +215,7 @@ func WithTask(ctx context.Context, taskName string) (context.Context, DoneFunc)
 			defer this.mtx.Lock().Unlock()
 			if this.activeChildTasks != 0 {
-				if debugEnabled {
+				panic(errors.Wrapf(ErrTaskStillHasActiveChildTasks, "end task: %v active child tasks", this.activeChildSpan))
 					// 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))
 			}
 			// support idempotent task ends
@@ -254,15 +226,8 @@ func WithTask(ctx context.Context, taskName string) (context.Context, DoneFunc)
 			if this.parentTask != nil {
 				this.parentTask.activeChildTasks--
 				if debugEnabled {
 					delete(this.parentTask.debugActiveChildTasks, this)
 				}
 				if this.parentTask.activeChildTasks < 0 {
-					if debugEnabled {
+					panic("impl error: parent task with negative activeChildTasks count")
 						// the debugString can be quite long and panic won't print it completely
 						fmt.Fprintf(os.Stderr, "going to panic due to activeChildTasks < 0:\n%s\n", this.parentTask.debugString())
 					}
 					panic(fmt.Sprintf("impl error: parent task with negative activeChildTasks count: %v", this.parentTask.activeChildTasks))
 				}
 			}
 			return false
@@ -311,10 +276,6 @@ func WithSpan(ctx context.Context, annotation string) (context.Context, DoneFunc
 		endedAt:   time.Time{},
 	}
 	if debugEnabled {
 		this.debugCreationStack = string(runtimedebug.Stack())
 	}
 	parentSpan.mtx.HoldWhile(func() {
 		if parentSpan.activeChildSpan != nil {
 			panic(ErrAlreadyActiveChildSpan)
@@ -324,7 +285,6 @@ func WithSpan(ctx context.Context, annotation string) (context.Context, DoneFunc
 	ctx = context.WithValue(ctx, contextKeyTraceNode, this)
 	chrometraceBeginSpan(this)
 	callbackEndSpan := callbackBeginSpan(ctx)
 	endTaskFunc := func() {
@@ -346,47 +306,17 @@ func WithSpan(ctx context.Context, annotation string) (context.Context, DoneFunc
 		this.endedAt = time.Now()
 		chrometraceEndSpan(this)
 		callbackEndSpan(this)
 	}
 	return ctx, endTaskFunc
 }
-type StackKind struct {
+func currentTaskNameAndSpanStack(this *traceNode) (taskName string, spanIdStack string) {
 	symbolizeTask func(t *traceNode) string
 	symbolizeSpan func(s *traceNode) string
 }
-var (
+	task := this.parentTask
-	StackKindId = &StackKind{
+	if this.parentSpan == nil {
-		symbolizeTask: func(t *traceNode) string { return t.id },
+		task = this
 		symbolizeSpan: func(s *traceNode) string { return s.id },
 	}
 	SpanStackKindCombined = &StackKind{
 		symbolizeTask: func(t *traceNode) string { return fmt.Sprintf("(%s %q)", t.id, t.annotation) },
 		symbolizeSpan: func(s *traceNode) string { return fmt.Sprintf("(%s %q)", s.id, s.annotation) },
 	}
 	SpanStackKindAnnotation = &StackKind{
 		symbolizeTask: func(t *traceNode) string { return t.annotation },
 		symbolizeSpan: func(s *traceNode) string { return s.annotation },
 	}
 )
 func (n *traceNode) task() *traceNode {
 	task := n.parentTask
 	if n.parentSpan == nil {
 		task = n
 	}
 	return task
 }
 func (n *traceNode) TaskName() string {
 	task := n.task()
 	return task.annotation
 }
 func (this *traceNode) TaskAndSpanStack(kind *StackKind) (spanIdStack string) {
 	task := this.task()
 	var spansInTask []*traceNode
 	for s := this; s != nil; s = s.parentSpan {
@@ -400,22 +330,25 @@ func (this *traceNode) TaskAndSpanStack(kind *StackKind) (spanIdStack string) {
 	var taskIdsRev []string
 	for i := len(tasks) - 1; i >= 0; i-- {
-		taskIdsRev = append(taskIdsRev, kind.symbolizeTask(tasks[i]))
+		taskIdsRev = append(taskIdsRev, tasks[i].id)
 	}
 	var spanIdsRev []string
 	for i := len(spansInTask) - 1; i >= 0; i-- {
-		spanIdsRev = append(spanIdsRev, kind.symbolizeSpan(spansInTask[i]))
+		spanIdsRev = append(spanIdsRev, spansInTask[i].id)
 	}
 	taskStack := strings.Join(taskIdsRev, "$")
-	return fmt.Sprintf("%s$%s", taskStack, strings.Join(spanIdsRev, "."))
+	spanIdStack = fmt.Sprintf("%s$%s", taskStack, strings.Join(spanIdsRev, "."))
 	return task.annotation, spanIdStack
 }
-func GetSpanStackOrDefault(ctx context.Context, kind StackKind, def string) string {
+func GetSpanStackOrDefault(ctx context.Context, def string) string {
 	if nI := ctx.Value(contextKeyTraceNode); nI != nil {
 		n := nI.(*traceNode)
-		return n.TaskAndSpanStack(StackKindId)
+		_, spanStack := currentTaskNameAndSpanStack(n)
 		return spanStack
 	} else {
 		return def
 	}
@@ -24,7 +24,7 @@ import (
 	"golang.org/x/net/websocket"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/util/envconst"
 )
 var chrometracePID string
@@ -51,7 +51,7 @@ type chrometraceEvent struct {
 }
 func chrometraceBeginSpan(s *traceNode) {
-	taskName := s.TaskName()
+	taskName, _ := currentTaskNameAndSpanStack(s)
 	chrometraceWrite(chrometraceEvent{
 		Name:                      s.annotation,
 		Phase:                     "B",
@@ -62,7 +62,7 @@ func chrometraceBeginSpan(s *traceNode) {
 }
 func chrometraceEndSpan(s *traceNode) {
-	taskName := s.TaskName()
+	taskName, _ := currentTaskNameAndSpanStack(s)
 	chrometraceWrite(chrometraceEvent{
 		Name:                      s.annotation,
 		Phase:                     "E",
@@ -86,7 +86,7 @@ func chrometraceBeginTask(s *traceNode) {
 	flowId := atomic.AddUint64(&chrometraceFlowId, 1)
 	flowIdStr := fmt.Sprintf("%x", flowId)
-	parentTask := s.parentTask.TaskName()
+	parentTask, _ := currentTaskNameAndSpanStack(s.parentTask)
 	chrometraceWrite(chrometraceEvent{
 		Cat:                       "task", // seems to be necessary, otherwise the GUI shows some `indexOf` JS error
 		Name:                      "child-task",
@@ -97,7 +97,7 @@ func chrometraceBeginTask(s *traceNode) {
 		Id:                        flowIdStr,
 	})
-	childTask := s.TaskName()
+	childTask, _ := currentTaskNameAndSpanStack(s)
 	if parentTask == childTask {
 		panic(parentTask)
 	}
@@ -11,6 +11,8 @@ import (
 // use like this:
 //
 //	defer WithSpanFromStackUpdateCtx(&existingCtx)()
 //
 //
 func WithSpanFromStackUpdateCtx(ctx *context.Context) DoneFunc {
 	childSpanCtx, end := WithSpan(*ctx, getMyCallerOrPanic())
 	*ctx = childSpanCtx
@@ -41,19 +43,15 @@ func WithTaskAndSpan(ctx context.Context, task string, span string) (context.Con
 }
 // create a span during which several child tasks are spawned using the `add` function
 //
 // IMPORTANT FOR USERS: Caller must ensure that the capturing behavior is correct, the Go linter doesn't catch this.
 func WithTaskGroup(ctx context.Context, taskGroup string) (_ context.Context, add func(f func(context.Context)), waitEnd DoneFunc) {
 	var wg sync.WaitGroup
 	ctx, endSpan := WithSpan(ctx, taskGroup)
 	add = func(f func(context.Context)) {
 		wg.Add(1)
-		go func() {
+		defer wg.Done()
-			defer wg.Done()
+		ctx, endTask := WithTask(ctx, taskGroup)
-			ctx, endTask := WithTask(ctx, taskGroup)
+		defer endTask()
-			defer endTask()
+		f(ctx)
 			f(ctx)
 		}()
 	}
 	waitEnd = func() {
 		wg.Wait()
@@ -0,0 +1,16 @@
 package trace
 import (
 	"testing"
 	"github.com/stretchr/testify/assert"
 )
 func TestGetCallerOrPanic(t *testing.T) {
 	withStackFromCtxMock := func() string {
 		return getMyCallerOrPanic()
 	}
 	ret := withStackFromCtxMock()
 	// zrepl prefix is stripped
 	assert.Equal(t, "daemon/logging/trace.TestGetCallerOrPanic", ret)
 }
@@ -3,13 +3,9 @@ package trace
 import (
 	"fmt"
 	"os"
 	"github.com/zrepl/zrepl/internal/util/envconst"
 )
-const debugEnabledEnvVar = "ZREPL_TRACE_DEBUG_ENABLED"
+const debugEnabled = false
 var debugEnabled = envconst.Bool(debugEnabledEnvVar, false)
 func debug(format string, args ...interface{}) {
 	if !debugEnabled {
@@ -1,13 +1,22 @@
 package trace
 import (
 	"crypto/rand"
 	"encoding/base64"
 	"math/rand"
 	"os"
 	"strings"
 	"time"
-	"github.com/zrepl/zrepl/internal/util/envconst"
+	"github.com/zrepl/zrepl/util/envconst"
 )
 var genIdPRNG = rand.New(rand.NewSource(1))
 func init() {
 	genIdPRNG.Seed(time.Now().UnixNano())
 	genIdPRNG.Seed(int64(os.Getpid()))
 }
 var genIdNumBytes = envconst.Int("ZREPL_TRACE_ID_NUM_BYTES", 3)
 func init() {
@@ -20,9 +29,12 @@ func genID() string {
 	var out strings.Builder
 	enc := base64.NewEncoder(base64.RawStdEncoding, &out)
 	buf := make([]byte, genIdNumBytes)
-	_, err := rand.Read(buf)
+	for i := 0; i < len(buf); {
-	if err != nil {
+		n, err := genIdPRNG.Read(buf[i:])
-		panic(err)
+		if err != nil {
 			panic(err)
 		}
 		i += n
 	}
 	n, err := enc.Write(buf[:])
 	if err != nil || n != len(buf) {
@@ -112,6 +112,12 @@ func TestIdempotentEndTask(t *testing.T) {
 	require.NotPanics(t, func() { end() })
 }
 func TestCannotReuseEndedTask(t *testing.T) {
 	root, end := WithTask(context.Background(), "root")
 	end()
 	require.PanicsWithValue(t, ErrParentTaskAlreadyEnded, func() { WithTask(root, "child-after-parent-ended") })
 }
 func TestSpansPanicIfNoParentTask(t *testing.T) {
 	require.Panics(t, func() { WithSpan(context.Background(), "taskless-span") })
 }
@@ -164,42 +170,3 @@ func TestWhiteboxHierachy(t *testing.T) {
 	e4()
 	e1()
 }
 func TestOrphanTasksBecomeNewRootWhenAllAncestorsAreDead(t *testing.T) {
 	parent, e1 := WithTask(context.Background(), "parent")
 	_ = logAndGetTraceNode(t, "parent-task", parent)
 	e1()
 	var child context.Context
 	var e2 DoneFunc
 	require.NotPanics(t, func() {
 		child, e2 = WithTask(parent, "child")
 	})
 	childN := logAndGetTraceNode(t, "child-task", child)
 	assert.Nil(t, childN.parentTask)
 	grandchild, _ := WithTask(child, "grandchild")
 	grandchildN := logAndGetTraceNode(t, "grandchild-task", grandchild)
 	assert.Equal(t, childN, grandchildN.parentTask)
 	require.Panics(t, func() { e2() }, "if the parent was alive at creation of child task, wrong termination order remains a panicable offense though")
 }
 func TestOrphanTaskBecomesChildToNearestLiveAncestor(t *testing.T) {
 	parent, e1 := WithTask(context.Background(), "parent")
 	parentN := logAndGetTraceNode(t, "parent-task", parent)
 	child, e2 := WithTask(parent, "child")
 	childN := logAndGetTraceNode(t, "child-task", child)
 	assert.Equal(t, parentN, childN.parentTask)
 	e2()
 	grandchild, e3 := WithTask(child, "grandchild")
 	grandchildN := logAndGetTraceNode(t, "grandchild-task", grandchild)
 	assert.Equal(t, parentN, grandchildN.parentTask) // child is already dead
 	require.NotPanics(t, func() {
 		e3()
 		e1()
 	})
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Christian Schwarz	eaedd17c81	trace: test for main API, fix bugs discovered by them	2020-05-15 19:13:49 +02:00
Christian Schwarz	c5b530669e	endpoint.ListAbstractionsError: fix stack overflow in .Error() fixes #320 refs #318	2020-05-09 11:59:25 +02:00
Christian Schwarz	456dc7925b	endpoint.Receiver.ListFilesystems: early-exit if root_fs is not imported - discovered during investigation of #316 - this is not the fix for #316, as a malicious receiver who doesn't implement the behavior added by this patch could still cause leakage of step holds on the sender refs #316	2020-05-03 17:50:24 +02:00
Christian Schwarz	600b6b3215	fixup `e0b5bd7`: crash on endpoint.ListStale if replication-cursor-v1 bookmark present ``` cs@cstp:[~/zrepl/zrepl]: artifacts/zrepl-linux-amd64 zfs-abstraction release-stale --dry-run panic: runtime error: invalid memory address or nil pointer dereference [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x9de971] goroutine 1 [running]: github.com/zrepl/zrepl/endpoint.listStaleFiltering(0xc00012b700, 0x5, 0x8, 0x0, 0x13ccb58) /endpoint/endpoint_zfs_abstraction.go:736 +0x281 github.com/zrepl/zrepl/endpoint.ListStale(0xe3ae20, 0xc00026b740, 0x0, 0xe27c60, 0x13ccb58, 0xc0001d8690, 0x0, 0x0, 0x0, 0x1, ...) /endpoint/endpoint_zfs_abstraction.go:698 +0x3fd github.com/zrepl/zrepl/client.doZabsReleaseStale(0xe3ae20, 0xc00026b740, 0x13a28a0, 0xc000151be0, 0x0, 0x1, 0x5705b4, 0xc0002686e0) /client/zfsabstractions_release.go:83 +0x1a0 github.com/zrepl/zrepl/cli.(Subcommand).run(0x13a28a0, 0xc000264c80, 0xc000151be0, 0x0, 0x1) /cli/cli.go:104 +0xf5 github.com/spf13/cobra.(Command).execute(0xc000264c80, 0xc000151bd0, 0x1, 0x1, 0xc000264c80, 0xc000151bd0) GOROOT/pkg/mod/github.com/spf13/cobra@v0.0.2/command.go:760 +0x2aa github.com/spf13/cobra.(Command).ExecuteC(0x13a43c0, 0x0, 0x0, 0x0) GOROOT/pkg/mod/github.com/spf13/cobra@v0.0.2/command.go:846 +0x2ea github.com/spf13/cobra.(Command).Execute(...) GOROOT/pkg/mod/github.com/spf13/cobra@v0.0.2/command.go:794 github.com/zrepl/zrepl/cli.Run() /cli/cli.go:151 +0x2d main.main() /main.go:24 +0x20 ```	2020-05-01 23:39:06 +02:00
Christian Schwarz	08424c521d	fixup: panic: already has active child span goroutine 114 [running]: github.com/zrepl/zrepl/daemon/logging/trace.WithSpan(0x19d4b20, 0xc00033cf30, 0x1df10f7, 0x1b, 0x0, 0x0, 0x0) /private/tmp/zrepl-20200501-50335-10bkfxv/gopath/src/github.com/zrepl/zrepl/daemon/logging/trace/trace.go:252 +0x32b github.com/zrepl/zrepl/daemon/logging/trace.WithSpanFromStackUpdateCtx(0xc000288f08, 0x0) /private/tmp/zrepl-20200501-50335-10bkfxv/gopath/src/github.com/zrepl/zrepl/daemon/logging/trace/trace_convenience.go:17 +0x53 github.com/zrepl/zrepl/util/semaphore.(*S).Acquire(0xc00009a038, 0x19d4b20, 0xc00033cf30, 0x0, 0x0, 0x0) /private/tmp/zrepl-20200501-50335-10bkfxv/gopath/src/github.com/zrepl/zrepl/util/semaphore/semaphore.go:25 +0x51 github.com/zrepl/zrepl/endpoint.ListAbstractionsStreamed.func3.1(0xc00035c950, 0xc00009a038, 0x19d4b20, 0xc00033cf30, 0xc000098440, 0xc000080400, 0x3d, 0x3d, 0xc000295300, 0xc000092c40, ...) /private/tmp/zrepl-20200501-50335-10bkfxv/gopath/src/github.com/zrepl/zrepl/endpoint/endpoint_zfs_abstraction.go:541 +0x77 created by github.com/zrepl/zrepl/endpoint.ListAbstractionsStreamed.func3 /private/tmp/zrepl-20200501-50335-10bkfxv/gopath/src/github.com/zrepl/zrepl/endpoint/endpoint_zfs_abstraction.go:539 +0x18c	2020-05-01 22:46:24 +02:00
Christian Schwarz	fc9dbdf449	[WIP] factor out trace functionality into separate package and add Go docs	2020-04-25 12:49:04 +02:00
Christian Schwarz	1ae087bfcf	[WIP] add and use tracing API as part of package logging - make `logging.GetLogger(ctx, Subsys)` the authoritative `logger.Logger` factory function - the context carries a linked list of injected fields which `logging.GetLogger` adds to the logger it returns - introduce the concept of tasks and spans, also tracked as linked list within ctx - [ ] TODO automatic logging of span begins and ends, with a unique ID stack that makes it easy to follow a series of log entries in concurrent code - ability to produce a chrome://tracing-compatible trace file, either via an env variable or a `zrepl pprof` subcommand - this is not a CPU profile, we already have go pprof for that - but it is very useful to visually inspect where the replication / snapshotter / pruner spends its time ( fixes #307 )	2020-04-25 11:16:59 +02:00
Christian Schwarz	3d91686350	rpc: proper handling of context cancellation for transportmux + dataconn - prior to this patch, context cancellation would leave rpc.Server open - did not make problems because context was only cancelled by SIGINT, which was immediately followed by os.Exit	2020-04-25 10:44:17 +02:00
Christian Schwarz	28e66ca78f	replication/logic: log filesystem during replication steps	2020-04-25 10:44:17 +02:00
Christian Schwarz	42ffca09db	endpoint: Receiver.Receive: save a peek of recv stream to a temporary dataset if placeholder + encryption recv -F error is detected	2020-04-25 10:43:59 +02:00
Christian Schwarz	05a39eaddf	endpont: Receiver.Receive: error message explaining problem with placeholders and encryption	2020-04-25 10:40:53 +02:00
Christian Schwarz	347d0f1aa2	endpoint: Receiver.Receive: better logging + placeholder state error early exit	2020-04-25 10:40:42 +02:00
Christian Schwarz	5aaac49382	rpc + zfs: drop zfs.StreamCopier, use io.ReadCloser instead	2020-04-25 10:40:05 +02:00
Christian Schwarz	c1c9d99a6f	fixup "replication/driver: enforce ordering during initial replication in order to support encrypted send": correctly propagate non-inital parent failures	2020-04-25 10:39:50 +02:00
Christian Schwarz	d59b64df86	replication/driver: enforce ordering during initial replication in order to support encrypted send fixes #277	2020-04-25 10:06:18 +02:00
Christian Schwarz	1540a478b0	replication/driver: fs.debug() helper that automatically prefixes with fs name	2020-04-25 10:06:18 +02:00
Christian Schwarz	15715b1e2a	replication/driver: rename receiver variable (fs fs) to (f fs)	2020-04-25 10:06:18 +02:00
Christian Schwarz	afab031b7d	replication/driver: envconst for experimental parallel replication refs #140 refs #302	2020-04-25 10:06:18 +02:00
Christian Schwarz	d52acfe10b	endpoint: log %#v recv options	2020-04-25 10:06:18 +02:00
Christian Schwarz	07ae6f2aad	build: Makefile: GO_EXTRA_BUILDFLAGS	2020-04-25 10:06:18 +02:00