docs: adjust publish.sh script

closes #153

.circleci/config.yml

@@ -0,0 +1,79 @@
+version: 2.0
+workflows:
+  version: 2
+  build:
+    jobs:
+      - build-1.11
+      - build-1.12
+      - build-latest
+jobs:
+  # 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:
+      image:
+        description: "the docker image that the job should use"
+        type: string
+    docker:
+      - image: circleci/golang:latest
+    environment:
+      # 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
+
+      - restore_cache:
+          keys:
+            - source
+            - vendor
+            - protobuf
+
+      - checkout
+
+      - save_cache:
+          key: source
+          paths:
+            - ".git"
+      
+      # install deps
+      - run: wget https://github.com/protocolbuffers/protobuf/releases/download/v3.6.1/protoc-3.6.1-linux-x86_64.zip
+      - run: echo "6003de742ea3fcf703cfec1cd4a3380fd143081a2eb0e559065563496af27807  protoc-3.6.1-linux-x86_64.zip" | sha256sum -c
+      - run: sudo unzip -d /usr protoc-3.6.1-linux-x86_64.zip
+      - save_cache:
+          key: protobuf
+          paths:
+            - "/usr/include/google/protobuf"
+            
+      - run: sudo apt install python3 python3-pip libgirepository1.0-dev
+      - run: ./lazy.sh devsetup
+
+      - run: make vendordeps
+      - save_cache:
+          key: vendor
+          paths:
+            - "./vendor"
+            
+      - run: make
+      - run: make vet
+      - run: make test
+      - run: make release
+
+      - store_artifacts:
+          path: ./artifacts/release
+          when: always
+
+
+  build-1.11:
+    <<: *build-latest
+    docker:
+      - image: circleci/golang:1.11
+  build-1.12:
+    <<: *build-latest
+    docker:
+    - image: circleci/golang:1.12

.travis.yml

@@ -0,0 +1,69 @@
+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 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"

Gopkg.lock

@@ -1,6 +1,14 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 
 
+[[projects]]
+  branch = "master"
+  digest = "1:8cf2cf1ab10480b5e0df950dac1517aaabde05d055d9d955652997ae4b9ecbbf"
+  name = "github.com/alvaroloes/enumer"
+  packages = ["."]
+  pruneopts = ""
+  revision = "6bcfe2edaac32ad71b88ce4cf92d34cd643e4ecb"
+
 [[projects]]
   branch = "master"
   digest = "1:c0bec5f9b98d0bc872ff5e834fac186b807b656683bd29cb82fb207a1513fabb"
@@ -64,11 +72,31 @@
 [[projects]]
   digest = "1:3dd078fda7500c341bc26cfbc6c6a34614f295a2457149fc1045cab767cbcf18"
   name = "github.com/golang/protobuf"
-  packages = ["proto"]
+  packages = [
+    "proto",
+    "protoc-gen-go",
+    "protoc-gen-go/descriptor",
+    "protoc-gen-go/generator",
+    "protoc-gen-go/generator/internal/remap",
+    "protoc-gen-go/grpc",
+    "protoc-gen-go/plugin",
+    "ptypes",
+    "ptypes/any",
+    "ptypes/duration",
+    "ptypes/timestamp",
+  ]
   pruneopts = ""
   revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5"
   version = "v1.2.0"
 
+[[projects]]
+  digest = "1:ad92aa49f34cbc3546063c7eb2cabb55ee2278b72842eda80e2a20a8a06a8d73"
+  name = "github.com/google/uuid"
+  packages = ["."]
+  pruneopts = ""
+  revision = "0cd6bf5da1e1c83f8b45653022c74f71af0538a4"
+  version = "v1.1.1"
+
 [[projects]]
   branch = "master"
   digest = "1:cb09475f771b9167fb9333629f5d6a7161572602ea040f1094602b0dc8709878"
@@ -141,6 +169,22 @@
   revision = "3247c84500bff8d9fb6d579d800f20b3e091582c"
   version = "v1.0.0"
 
+[[projects]]
+  digest = "1:4ff67dde814694496d7aa31be44b900f9717a10c8bc9136b13f49c8ef97f439a"
+  name = "github.com/montanaflynn/stats"
+  packages = ["."]
+  pruneopts = ""
+  revision = "63fbb2597b7a13043b453a4b819945badb8f8926"
+  version = "v0.5.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:f60ff065b58bd53e641112b38bbda9d2684deb828393c7ffb89c69a1ee301d17"
+  name = "github.com/pascaldekloe/name"
+  packages = ["."]
+  pruneopts = ""
+  revision = "0fd16699aae1833640fca52a937944c6f3b1d58c"
+
 [[projects]]
   digest = "1:7365acd48986e205ccb8652cc746f09c8b7876030d53710ea6ef7d0bd0dcd7ca"
   name = "github.com/pkg/errors"
@@ -149,6 +193,14 @@
   revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
   version = "v0.8.0"
 
+[[projects]]
+  digest = "1:1cbc6b98173422a756ae79e485952cb37a0a460c710541c75d3e9961c5a60782"
+  name = "github.com/pkg/profile"
+  packages = ["."]
+  pruneopts = ""
+  revision = "5b67d428864e92711fcbd2f8629456121a56d91f"
+  version = "v1.2.1"
+
 [[projects]]
   digest = "1:256484dbbcd271f9ecebc6795b2df8cad4c458dd0f5fd82a8c2fa0c29f233411"
   name = "github.com/pmezard/go-difflib"
@@ -159,30 +211,11 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:1392748e290ca66ac8447ef24961f8ae9e1d846a53af0f58a5a0256982ce0577"
+  digest = "1:fa72f780ae3b4820ed12cef7a034291ab10d83e2da4ab5ba81afa44d5bf3a529"
   name = "github.com/problame/go-netssh"
   packages = ["."]
   pruneopts = ""
-  revision = "c56ad38d2c91397ad3c8dd9443d7448e328a9e9e"
-
-[[projects]]
-  branch = "master"
-  digest = "1:8c63c44f018bd52b03ebad65c9df26aabbc6793138e421df1c8c84c285a45bc6"
-  name = "github.com/problame/go-rwccmd"
-  packages = ["."]
-  pruneopts = ""
-  revision = "391d2c78c8404a9683d79f75dd24ab53040f89f7"
-
-[[projects]]
-  digest = "1:c2ba1c9dc003c15856e4529dac028cacba08ee8924300f058b3467cde9acf7a9"
-  name = "github.com/problame/go-streamrpc"
-  packages = [
-    ".",
-    "internal/pdu",
-  ]
-  pruneopts = ""
-  revision = "de6f6a4041c77f700f02d8fe749e54efa50811f7"
-  version = "v0.4"
+  revision = "09d6bc45d284784cb3e5aaa1998513f37eb19cc6"
 
 [[projects]]
   branch = "master"
@@ -228,6 +261,14 @@
   pruneopts = ""
   revision = "8b1c2da0d56deffdbb9e48d4414b4e674bd8083e"
 
+[[projects]]
+  digest = "1:3962f553b77bf6c03fc07cd687a22dd3b00fe11aa14d31194f5505f5bb65cdc8"
+  name = "github.com/sergi/go-diff"
+  packages = ["diffmatchpatch"]
+  pruneopts = ""
+  revision = "1744e2970ca51c86172c8190fadad617561ed6e7"
+  version = "v1.0.0"
+
 [[projects]]
   branch = "master"
   digest = "1:146327ce93be37e68bd3ff8541090d96da8cb3adc9e35d57570e9170a29f6bf6"
@@ -256,58 +297,181 @@
   version = "v1.1.4"
 
 [[projects]]
-  branch = "v2"
-  digest = "1:9d92186f609a73744232323416ddafd56fae67cb552162cc190ab903e36900dd"
-  name = "github.com/zrepl/yaml-config"
-  packages = ["."]
+  digest = "1:f80053a92d9ac874ad97d665d3005c1118ed66e9e88401361dc32defe6bef21c"
+  name = "github.com/theckman/goconstraint"
+  packages = ["go1.11/gte"]
   pruneopts = ""
-  revision = "af27d27978ad95808723a62d87557d63c3ff0605"
+  revision = "93babf24513d0e8277635da8169fcc5a46ae3f6a"
+  version = "v1.11.0"
+
+[[projects]]
+  digest = "1:529ed3f98838f69e13761788d0cc71b44e130058fab13bae2ce09f7a176bced4"
+  name = "github.com/yudai/gojsondiff"
+  packages = [
+    ".",
+    "formatter",
+  ]
+  pruneopts = ""
+  revision = "7b1b7adf999dab73a6eb02669c3d82dbb27a3dd6"
+  version = "1.0.0"
 
 [[projects]]
   branch = "master"
-  digest = "1:9c286cf11d0ca56368185bada5dd6d97b6be4648fc26c354fcba8df7293718f7"
+  digest = "1:9857bb2293f372b2181004d8b62179bbdb4ab0982ec6f762abe6cf2bfedaff85"
+  name = "github.com/yudai/golcs"
+  packages = ["."]
+  pruneopts = ""
+  revision = "ecda9a501e8220fae3b4b600c3db4b0ba22cfc68"
+
+[[projects]]
+  branch = "v2"
+  digest = "1:6b8a6afafde7ed31cd0c577ba40d88ce39e8f1c5eb76d7836be7d5b74f1c534a"
+  name = "github.com/zrepl/yaml-config"
+  packages = ["."]
+  pruneopts = ""
+  revision = "08227ad854131f7dfcdfb12579fb73dd8a38a03a"
+
+[[projects]]
+  branch = "master"
+  digest = "1:ea539c13b066dac72a940b62f37600a20ab8e88057397c78f3197c1a48475425"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "http/httpguts",
+    "http2",
+    "http2/hpack",
+    "idna",
+    "internal/timeseries",
+    "trace",
+  ]
+  pruneopts = ""
+  revision = "351d144fa1fc0bd934e2408202be0c29f25e35a0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:f358024b019f87eecaadcb098113a40852c94fe58ea670ef3c3e2d2c7bd93db1"
   name = "golang.org/x/sys"
   packages = ["unix"]
   pruneopts = ""
-  revision = "bf42f188b9bc6f2cf5b8ee5a912ef1aedd0eba4c"
+  revision = "4ed8d59d0b35e1e29334a206d1b3f38b1e5dfb31"
 
 [[projects]]
   digest = "1:5acd3512b047305d49e8763eef7ba423901e85d5dd2fd1e71778a0ea8de10bd4"
   name = "golang.org/x/text"
   packages = [
+    "collate",
+    "collate/build",
     "encoding",
     "encoding/internal/identifier",
+    "internal/colltab",
     "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
     "transform",
+    "unicode/bidi",
     "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
   ]
   pruneopts = ""
   revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
   version = "v0.3.0"
 
+[[projects]]
+  branch = "master"
+  digest = "1:4cd780b2ee42c8eac9c02bfb6e6b52dcbaef770774458c8938f5cbfb73a7b6d3"
+  name = "golang.org/x/tools"
+  packages = ["cmd/stringer"]
+  pruneopts = ""
+  revision = "d0ca3933b724e6be513276cc2edb34e10d667438"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5fc6c317675b746d0c641b29aa0aab5fcb403c0d07afdbf0de86b0d447a0502a"
+  name = "google.golang.org/genproto"
+  packages = ["googleapis/rpc/status"]
+  pruneopts = ""
+  revision = "bd91e49a0898e27abb88c339b432fa53d7497ac0"
+
+[[projects]]
+  digest = "1:d141efe4aaad714e3059c340901aab3147b6253e58c85dafbcca3dd8b0e88ad6"
+  name = "google.golang.org/grpc"
+  packages = [
+    ".",
+    "balancer",
+    "balancer/base",
+    "balancer/roundrobin",
+    "binarylog/grpc_binarylog_v1",
+    "codes",
+    "connectivity",
+    "credentials",
+    "credentials/internal",
+    "encoding",
+    "encoding/proto",
+    "grpclog",
+    "internal",
+    "internal/backoff",
+    "internal/binarylog",
+    "internal/channelz",
+    "internal/envconfig",
+    "internal/grpcrand",
+    "internal/grpcsync",
+    "internal/syscall",
+    "internal/transport",
+    "keepalive",
+    "metadata",
+    "naming",
+    "peer",
+    "resolver",
+    "resolver/dns",
+    "resolver/passthrough",
+    "stats",
+    "status",
+    "tap",
+  ]
+  pruneopts = ""
+  revision = "df014850f6dee74ba2fc94874043a9f3f75fbfd8"
+  version = "v1.17.0"
+
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
   input-imports = [
+    "github.com/alvaroloes/enumer",
     "github.com/fatih/color",
     "github.com/gdamore/tcell/termbox",
     "github.com/go-logfmt/logfmt",
     "github.com/golang/protobuf/proto",
+    "github.com/golang/protobuf/protoc-gen-go",
+    "github.com/google/uuid",
     "github.com/jinzhu/copier",
     "github.com/kr/pretty",
     "github.com/mattn/go-isatty",
+    "github.com/montanaflynn/stats",
     "github.com/pkg/errors",
+    "github.com/pkg/profile",
     "github.com/problame/go-netssh",
-    "github.com/problame/go-rwccmd",
-    "github.com/problame/go-streamrpc",
     "github.com/prometheus/client_golang/prometheus",
     "github.com/prometheus/client_golang/prometheus/promhttp",
     "github.com/spf13/cobra",
     "github.com/spf13/pflag",
     "github.com/stretchr/testify/assert",
     "github.com/stretchr/testify/require",
+    "github.com/yudai/gojsondiff",
+    "github.com/yudai/gojsondiff/formatter",
     "github.com/zrepl/yaml-config",
+    "golang.org/x/net/context",
     "golang.org/x/sys/unix",
+    "golang.org/x/tools/cmd/stringer",
+    "google.golang.org/grpc",
+    "google.golang.org/grpc/codes",
+    "google.golang.org/grpc/credentials",
+    "google.golang.org/grpc/keepalive",
+    "google.golang.org/grpc/peer",
+    "google.golang.org/grpc/status",
   ]
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -1,8 +1,11 @@
-ignored = [ "github.com/inconshreveable/mousetrap" ]
+ignored = [
+    "github.com/inconshreveable/mousetrap",
+]
 
-[[constraint]]
-  branch = "master"
-  name = "github.com/ftrvxmtrx/fd"
+required = [
+    "golang.org/x/tools/cmd/stringer",
+    "github.com/alvaroloes/enumer",
+]
 
 [[constraint]]
   branch = "master"
@@ -12,14 +15,6 @@ ignored = [ "github.com/inconshreveable/mousetrap" ]
   branch = "master"
   name = "github.com/kr/pretty"
 
-[[constraint]]
-  branch = "master"
-  name = "github.com/mitchellh/go-homedir"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/mitchellh/mapstructure"
-
 [[constraint]]
   name = "github.com/pkg/errors"
   version = "0.8.0"
@@ -28,10 +23,6 @@ ignored = [ "github.com/inconshreveable/mousetrap" ]
   branch = "master"
   name = "github.com/spf13/cobra"
 
-[[constraint]]
-  name = "github.com/spf13/viper"
-  version = "1.0.0"
-
 [[constraint]]
   name = "github.com/stretchr/testify"
   version = "1.1.4"
@@ -44,10 +35,6 @@ ignored = [ "github.com/inconshreveable/mousetrap" ]
   name = "github.com/go-logfmt/logfmt"
   version = "*"
 
-[[constraint]]
-  name = "github.com/problame/go-rwccmd"
-  branch = "master"
-
 [[constraint]]
   name = "github.com/problame/go-netssh"
   branch = "master"
@@ -58,18 +45,21 @@ ignored = [ "github.com/inconshreveable/mousetrap" ]
 
 [[constraint]]
   name = "github.com/golang/protobuf"
-  version = "1.2.0"
+  version = "1"
 
 [[constraint]]
   name = "github.com/fatih/color"
   version = "1.7.0"
 
-[[constraint]]
-  name = "github.com/problame/go-streamrpc"
-  version = "0.4.0"
-
-
 
 [[constraint]]
   name = "github.com/gdamore/tcell"
   version = "1.0.0"
+
+[[constraint]]
+  name = "google.golang.org/grpc"
+  version = "1"
+  
+[[constraint]]
+  version = "1.1.0"
+  name = "github.com/google/uuid"

Makefile

@@ -1,45 +1,18 @@
 .PHONY: generate build test vet cover release docs docs-clean clean vendordeps
 .DEFAULT_GOAL := build
 
-ROOT := github.com/zrepl/zrepl
-SUBPKGS += client
-SUBPKGS += config
-SUBPKGS += daemon
-SUBPKGS += daemon/filters
-SUBPKGS += daemon/job
-SUBPKGS += daemon/logging
-SUBPKGS += daemon/nethelpers
-SUBPKGS += daemon/pruner
-SUBPKGS += daemon/snapper
-SUBPKGS += daemon/streamrpcconfig
-SUBPKGS += daemon/transport
-SUBPKGS += daemon/transport/connecter
-SUBPKGS += daemon/transport/serve
-SUBPKGS += endpoint
-SUBPKGS += logger
-SUBPKGS += pruning
-SUBPKGS += pruning/retentiongrid
-SUBPKGS += replication
-SUBPKGS += replication/fsrep
-SUBPKGS += replication/pdu
-SUBPKGS += replication/internal/queue
-SUBPKGS += replication/internal/diff
-SUBPKGS += tlsconf
-SUBPKGS += util
-SUBPKGS += version
-SUBPKGS += zfs
-
-_TESTPKGS := $(ROOT) $(foreach p,$(SUBPKGS),$(ROOT)/$(p))
-
 ARTIFACTDIR := artifacts
 
-ifndef ZREPL_VERSION
-    ZREPL_VERSION := $(shell git describe --dirty 2>/dev/null || echo "ZREPL_BUILD_INVALID_VERSION" )
-    ifeq ($(ZREPL_VERSION),ZREPL_BUILD_INVALID_VERSION) # can't use .SHELLSTATUS because Debian Stretch is still on gmake 4.1
+ifdef ZREPL_VERSION
+    _ZREPL_VERSION := $(ZREPL_VERSION)
+endif
+ifndef _ZREPL_VERSION
+    _ZREPL_VERSION := $(shell git describe --always --dirty 2>/dev/null || echo "ZREPL_BUILD_INVALID_VERSION" )
+    ifeq ($(_ZREPL_VERSION),ZREPL_BUILD_INVALID_VERSION) # can't use .SHELLSTATUS because Debian Stretch is still on gmake 4.1
         $(error cannot infer variable ZREPL_VERSION using git and variable is not overriden by make invocation)
     endif
 endif
-GO_LDFLAGS := "-X github.com/zrepl/zrepl/version.zreplVersion=$(ZREPL_VERSION)"
+GO_LDFLAGS := "-X github.com/zrepl/zrepl/version.zreplVersion=$(_ZREPL_VERSION)"
 
 GO_BUILD := go build -ldflags $(GO_LDFLAGS)
 
@@ -54,35 +27,21 @@ vendordeps:
 	dep ensure -v -vendor-only
 
 generate: #not part of the build, must do that manually
-	protoc -I=replication/pdu --go_out=replication/pdu replication/pdu/pdu.proto
-	@for pkg in $(_TESTPKGS); do\
-		go generate "$$pkg" || exit 1; \
-	done;
+	protoc -I=replication/logic/pdu --go_out=plugins=grpc:replication/logic/pdu replication/logic/pdu/pdu.proto
+	go generate -x ./...
 
 build:
 	@echo "INFO: In case of missing dependencies, run 'make vendordeps'"
 	$(GO_BUILD) -o "$(ARTIFACTDIR)/zrepl"
 
 test:
-	@for pkg in $(_TESTPKGS); do \
-		echo "Testing $$pkg"; \
-		go test "$$pkg" || exit 1; \
-	done;
+	go test ./...
 
 vet:
-	@for pkg in $(_TESTPKGS); do \
-		echo "Vetting $$pkg"; \
-		go vet "$$pkg" || exit 1; \
-	done;
-
-cover: artifacts
-	@for pkg in $(_TESTPKGS); do \
-		profile="$(ARTIFACTDIR)/cover-$$(basename $$pkg).out"; \
-		go test -coverprofile "$$profile" $$pkg || exit 1; \
-		if [ -f "$$profile" ]; then \
-   			go tool cover -html="$$profile" -o "$${profile}.html" || exit 2; \
-		fi; \
-	done;
+	# for each supported platform to cover conditional compilation
+	GOOS=linux   go vet ./...
+	GOOS=darwin  go vet ./...
+	GOOS=freebsd go vet ./...
 
 $(ARTIFACTDIR):
 	mkdir -p "$@"
@@ -115,7 +74,7 @@ $(RELEASE_BINS): $(ARTIFACTDIR)/zrepl-%-amd64: generate $(ARTIFACTDIR) vet test
 
 $(RELEASE_NOARCH): docs $(ARTIFACTDIR)/bash_completion $(ARTIFACTDIR)/go_version.txt
 	tar --mtime='1970-01-01' --sort=name \
-		--transform 's/$(ARTIFACTDIR)/zrepl-$(ZREPL_VERSION)-noarch/' \
+		--transform 's/$(ARTIFACTDIR)/zrepl-$(_ZREPL_VERSION)-noarch/' \
 		-acf $@ \
 		$(ARTIFACTDIR)/docs/html \
 		$(ARTIFACTDIR)/bash_completion \
@@ -126,10 +85,14 @@ release: $(RELEASE_BINS) $(RELEASE_NOARCH)
 	mkdir -p "$(ARTIFACTDIR)/release"
 	cp $^ "$(ARTIFACTDIR)/release"
 	cd "$(ARTIFACTDIR)/release" && sha512sum $$(ls | sort) > sha512sum.txt
-	@if echo "$(ZREPL_VERSION)" | grep dirty > /dev/null; then\
-		echo '[WARN] Do not publish the artifacts, make variable ZREPL_VERSION=$(ZREPL_VERSION) indicates they are dirty!'; \
-		exit 1; \
-	fi
+	@# note that we use ZREPL_VERSION and not _ZREPL_VERSION because we want to detect the override
+	@if git describe --always --dirty 2>/dev/null | grep dirty >/dev/null; then \
+        echo '[INFO] either git reports checkout is dirty or git is not installed or this is not a git checkout'; \
+		if [ "$(ZREPL_VERSION)" = "" ]; then \
+			echo '[WARN] git checkout is dirty and make variable ZREPL_VERSION was not used to override'; \
+			exit 1; \
+		fi; \
+	fi;
 
 clean: docs-clean
 	rm -rf "$(ARTIFACTDIR)"

README.md

@@ -1,3 +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/language-Go-6ad7e5.svg)](https://golang.org/)
+[![User Docs](https://img.shields.io/badge/docs-web-blue.svg)](https://zrepl.github.io)
+[![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)
+[![Donate via Liberapay](https://img.shields.io/badge/donate-liberapay-yellow.svg)](https://liberapay.com/zrepl/donate)
+[![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)
+
 # zrepl
 zrepl is a one-stop ZFS backup & replication solution.
 
@@ -26,6 +33,8 @@ Check out the *Coding Workflow* section below for details.
 * Make sure your distro is compatible with the paths in `docs/installation.rst`.
 * 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/`.
 * Use `make release ZREPL_VERSION='mydistro-1.2.3_1'`
     * Your distro's name and any versioning supplemental to zrepl's (e.g. package revision) should be in this string
 * Make sure you are informed about new zrepl versions, e.g. by subscribing to GitHub's release RSS feed.
@@ -45,21 +54,53 @@ Make sure to develop an understanding how zrepl is typically used by studying th
 ### Project Structure
 
 ```
-├── cmd
-│   ├── endpoint            # implementations of endpoints for package replication
-│   ├── sampleconf          # example configuration
+├── 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
+│   ├── job                 # job implementations
+│   ├── logging             # logging outlets + formatters
+│   ├── nethelpers
+│   ├── prometheus
+│   ├── pruner              # pruner implementation
+│   ├── snapper             # snapshotter implementation
 ├── docs                    # sphinx-based documentation
+├── dist                    # supplemental material for users & package maintainers
 │   ├── **/*.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
-├── logger                  # logger package used by zrepl
-├── replication             # replication functionality
-├── rpc                     # rpc protocol implementation
+│   └── public_git          # checkout of zrepl.github.io managed by above shell script
+├── endpoint                # implementation of replication endpoints (=> package replication)
+├── logger                  # our own logger package
+├── 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               # transports implementation
+│   ├── fromconfig
+│   ├── local
+│   ├── ssh
+│   ├── tcp
+│   └── tls
 ├── util
-└── zfs                     # ZFS wrappers, filesystemm diffing
+├── vendor                  # managed by dep
+├── version                 # abstraction for versions (filled during build by Makefile)
+└── zfs                     # zfs(8) wrappers
 ```
 
 ### Coding Workflow

build.Dockerfile

@@ -11,12 +11,21 @@ RUN unzip -d /usr protoc-3.6.1-linux-x86_64.zip
 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 devsetup
+RUN /tmp/lazy.sh docdep
 
 # prepare volume mount of git checkout to /zrepl
 RUN mkdir -p /go/src/github.com/zrepl/zrepl
-RUN chmod -R 0777 /go
 RUN mkdir -p /.cache && chmod -R 0777 /.cache
 WORKDIR /go/src/github.com/zrepl/zrepl
 
+ADD Gopkg.toml Gopkg.lock  ./
+
+# godep will install the Go dependencies to vendor in order to then build and install
+# build dependencies like stringer to $GOPATH/bin.
+# However, since users volume-mount their Git checkout into /go/src/github.com/zrepl/zrepl
+# the vendor directory will be empty at build time, allowing them to experiment with
+# new checkouts, etc.
+# Thus, we only use the vendored deps for building dependencies.
+RUN /tmp/lazy.sh godep
+RUN chmod -R 0777 /go
 

build/build.go

@@ -0,0 +1,22 @@
+//+build windows
+
+// This package cannot actually be built, and since the Travis
+// tests run go test ./..., we have to avoid a build attempt.
+// Windows is not supported atm, so this works ¯\_(ツ)_/¯
+
+// This package is a pseudo-user of build-time dependencies for zrepl,
+// mostly for various code-generation tools.
+//
+// The imports are necessary to satisfy go dep
+package main
+
+import (
+	_ "fmt"
+	_ "github.com/alvaroloes/enumer"
+	_ "github.com/golang/protobuf/protoc-gen-go"
+	_ "golang.org/x/tools/cmd/stringer"
+)
+
+func main() {
+	fmt.Println("just a placeholder")
+}

cli/cli.go

@@ -42,6 +42,7 @@ func init() {
 type Subcommand struct {
 	Use             string
 	Short           string
+	Example 		string
 	NoRequireConfig bool
 	Run             func(subcommand *Subcommand, args []string) error
 	SetupFlags      func(f *pflag.FlagSet)
@@ -94,6 +95,7 @@ func addSubcommandToCobraCmd(c *cobra.Command, s *Subcommand) {
 	cmd := cobra.Command{
 		Use: s.Use,
 		Short: s.Short,
+		Example: s.Example,
 	}
 	if s.SetupSubcommands == nil {
 		cmd.Run = s.run
@@ -113,4 +115,4 @@ func Run() {
 	if err := rootCmd.Execute(); err != nil {
 		os.Exit(1)
 	}
-}
+}

client/configcheck.go

@@ -2,15 +2,22 @@ package client
 
 import (
 	"encoding/json"
+	"fmt"
 	"github.com/kr/pretty"
+	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
 	"github.com/zrepl/yaml-config"
 	"github.com/zrepl/zrepl/cli"
+	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/daemon/job"
+	"github.com/zrepl/zrepl/daemon/logging"
+	"github.com/zrepl/zrepl/logger"
 	"os"
 )
 
 var configcheckArgs struct {
 	format string
+	what string
 }
 
 var ConfigcheckCmd = &cli.Subcommand{
@@ -18,19 +25,88 @@ var ConfigcheckCmd = &cli.Subcommand{
 	Short: "check if config can be parsed without errors",
 	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]")
 	},
 	Run: func(subcommand *cli.Subcommand, args []string) error {
-		switch configcheckArgs.format {
-		case "pretty":
-			_, err := pretty.Println(subcommand.Config())
-			return err
-		case "json":
-			return json.NewEncoder(os.Stdout).Encode(subcommand.Config())
-		case "yaml":
-			return yaml.NewEncoder(os.Stdout).Encode(subcommand.Config())
-		default: // no output
+		formatMap := map[string]func(interface{}) {
+			"": func(i interface{}) {},
+			"pretty": func(i interface{}) { pretty.Println(i) },
+			"json": func(i interface{}) {
+				json.NewEncoder(os.Stdout).Encode(subcommand.Config())
+			},
+			"yaml": func(i interface{}) {
+				yaml.NewEncoder(os.Stdout).Encode(subcommand.Config())
+			},
+		}
+
+		formatter, ok := formatMap[configcheckArgs.format]
+		if !ok {
+			return fmt.Errorf("unsupported --format %q", configcheckArgs.format)
+		}
+
+		var hadErr bool
+		// further: try to build jobs
+		confJobs, err := job.JobsFromConfig(subcommand.Config())
+		if err != nil {
+			err := errors.Wrap(err, "cannot build jobs from config")
+			if configcheckArgs.what == "jobs" {
+				return err
+			} else {
+				fmt.Fprintf(os.Stderr, "%s\n", err)
+				confJobs = nil
+				hadErr = true
+			}
+		}
+
+		// further: try to build logging outlets
+		outlets, err := logging.OutletsFromConfig(*subcommand.Config().Global.Logging)
+		if err != nil {
+			err := errors.Wrap(err, "cannot build logging from config")
+			if configcheckArgs.what == "logging" {
+				return err
+			} else {
+				fmt.Fprintf(os.Stderr, "%s\n", err)
+				outlets = nil
+				hadErr = true
+			}
+		}
+
+
+		whatMap := map[string]func() {
+			"all": func() {
+				o := struct {
+					config *config.Config
+					jobs []job.Job
+					logging *logger.Outlets
+				}{
+					subcommand.Config(),
+					confJobs,
+					outlets,
+				}
+				formatter(o)
+			},
+			"config": func() {
+				formatter(subcommand.Config())
+			},
+			"jobs": func() {
+				formatter(confJobs)
+			},
+			"logging": func() {
+				formatter(outlets)
+			},
+		}
+
+		wf, ok := whatMap[configcheckArgs.what]
+		if !ok {
+			return fmt.Errorf("unsupported --format %q", configcheckArgs.what)
+		}
+		wf()
+
+		if hadErr {
+			return fmt.Errorf("config parsing failed")
+		} else {
+			return nil
 		}
-		return nil
 	},
 }
 

client/migrate.go

@@ -0,0 +1,108 @@
+package client
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/pflag"
+	"github.com/zrepl/zrepl/zfs"
+
+	"github.com/zrepl/zrepl/cli"
+	"github.com/zrepl/zrepl/config"
+)
+
+var (
+	MigrateCmd = &cli.Subcommand{
+		Use:   "migrate",
+		Short: "perform migration of the on-disk / zfs properties",
+		SetupSubcommands: func() []*cli.Subcommand {
+			return migrations
+		},
+	}
+)
+
+type migration struct {
+	name   string
+	method func(config *config.Config, args []string) error
+}
+
+var migrations = []*cli.Subcommand{
+	&cli.Subcommand{
+		Use: "0.0.X:0.1:placeholder",
+		Run: doMigratePlaceholder0_1,
+		SetupFlags: func(f *pflag.FlagSet) {
+			f.BoolVar(&migratePlaceholder0_1Args.dryRun, "dry-run", false, "dry run")
+		},
+	},
+}
+
+var migratePlaceholder0_1Args struct {
+	dryRun bool
+}
+
+func doMigratePlaceholder0_1(sc *cli.Subcommand, args []string) error {
+	if len(args) != 0 {
+		return fmt.Errorf("migration does not take arguments, got %v", args)
+	}
+
+	cfg := sc.Config()
+
+	ctx := context.Background()
+	allFSS, err := zfs.ZFSListMapping(ctx, zfs.NoFilter())
+	if err != nil {
+		return errors.Wrap(err, "cannot list filesystems")
+	}
+
+	type workItem struct {
+		jobName string
+		rootFS  *zfs.DatasetPath
+		fss     []*zfs.DatasetPath
+	}
+	var wis []workItem
+	for i, j := range cfg.Jobs {
+		var rfsS string
+		switch job := j.Ret.(type) {
+		case *config.SinkJob:
+			rfsS = job.RootFS
+		case *config.PullJob:
+			rfsS = job.RootFS
+		default:
+			fmt.Printf("ignoring job %q (%d/%d, type %T)\n", j.Name(), i, len(cfg.Jobs), j.Ret)
+			continue
+		}
+		rfs, err := zfs.NewDatasetPath(rfsS)
+		if err != nil {
+			return errors.Wrapf(err, "root fs for job %q is not a valid dataset path", j.Name())
+		}
+		var fss []*zfs.DatasetPath
+		for _, fs := range allFSS {
+			if fs.HasPrefix(rfs) {
+				fss = append(fss, fs)
+			}
+		}
+		wis = append(wis, workItem{j.Name(), rfs, fss})
+	}
+
+	for _, wi := range wis {
+		fmt.Printf("job %q => migrate filesystems below root_fs %q\n", wi.jobName, wi.rootFS.ToString())
+		if len(wi.fss) == 0 {
+			fmt.Printf("\tno filesystems\n")
+			continue
+		}
+		for _, fs := range wi.fss {
+			fmt.Printf("\t%q ... ", fs.ToString())
+			r, err := zfs.ZFSMigrateHashBasedPlaceholderToCurrent(fs, migratePlaceholder0_1Args.dryRun)
+			if err != nil {
+				fmt.Printf("error: %s\n", err)
+			} else if !r.NeedsModification {
+				fmt.Printf("unchanged (placeholder=%v)\n", r.OriginalState.IsPlaceholder)
+			} else {
+				fmt.Printf("migrate (placeholder=%v) (old value = %q)\n",
+					r.OriginalState.IsPlaceholder, r.OriginalState.RawLocalPropertyValue)
+			}
+		}
+	}
+
+	return nil
+}

client/migrate_test.go

@@ -0,0 +1,16 @@
+package client
+
+import "testing"
+
+func TestMigrationsUnambiguousNames(t *testing.T) {
+	names := make(map[string]bool)
+	for _, mig := range migrations {
+		if _, ok := names[mig.Use]; ok {
+			t.Errorf("duplicate migration name %q", mig.Use)
+			t.FailNow()
+			return
+		} else {
+			names[mig.Use] = true
+		}
+	}
+}

client/status.go

@@ -10,8 +10,7 @@ import (
 	"github.com/zrepl/zrepl/daemon"
 	"github.com/zrepl/zrepl/daemon/job"
 	"github.com/zrepl/zrepl/daemon/pruner"
-	"github.com/zrepl/zrepl/replication"
-	"github.com/zrepl/zrepl/replication/fsrep"
+	"github.com/zrepl/zrepl/replication/report"
 	"io"
 	"math"
 	"net/http"
@@ -22,6 +21,52 @@ import (
 	"time"
 )
 
+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.Now().Sub(p.lastChange) > 3 * time.Second {
+		p.last = nil
+		return 0, 0
+	}
+
+
+	deltaV := currentVal - p.last.val;
+	deltaT := time.Now().Sub(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
@@ -29,10 +74,14 @@ type tui struct {
 	lock   sync.Mutex //For report and error
 	report map[string]job.Status
 	err    error
+
+	replicationProgress map[string]*bytesProgressHistory // by job name
 }
 
 func newTui() tui {
-	return tui{}
+	return tui{
+		replicationProgress: make(map[string]*bytesProgressHistory, 0),
+	}
 }
 
 func (t *tui) moveCursor(x, y int) {
@@ -40,9 +89,11 @@ func (t *tui) moveCursor(x, y int) {
 	t.y += y
 }
 
+const INDENT_MULTIPLIER = 4
+
 func (t *tui) moveLine(dl int, col int) {
 	t.y += dl
-	t.x = t.indent*4 + col
+	t.x = t.indent*INDENT_MULTIPLIER + col
 }
 
 func (t *tui) write(text string) {
@@ -60,6 +111,40 @@ 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)
 }
@@ -74,6 +159,7 @@ func (t *tui) addIndent(indent int) {
 	t.moveLine(0, 0)
 }
 
+
 var statusFlags struct {
 	Raw bool
 }
@@ -167,6 +253,15 @@ loop:
 
 }
 
+func (t *tui) getReplicationProgresHistory(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()
@@ -202,7 +297,44 @@ func (t *tui) draw() {
 			t.setIndent(1)
 			t.newline()
 
-			if v.Type != job.TypePush && v.Type != job.TypePull {
+			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.getReplicationProgresHistory(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)
+			} 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)
+			} else {
 				t.printf("No status representation for job type '%s', dumping as YAML", v.Type)
 				t.newline()
 				asYaml, err := yaml.Marshal(v.JobSpecific)
@@ -215,104 +347,96 @@ func (t *tui) draw() {
 				t.newline()
 				continue
 			}
-
-			pushStatus, ok := v.JobSpecific.(*job.ActiveSideStatus)
-			if !ok || pushStatus == nil {
-				t.printf("ActiveSideStatus is null")
-				t.newline()
-				continue
-			}
-
-			t.printf("Replication:")
-			t.newline()
-			t.addIndent(1)
-			t.renderReplicationReport(pushStatus.Replication)
-			t.addIndent(-1)
-
-			t.printf("Pruning Sender:")
-			t.newline()
-			t.addIndent(1)
-			t.renderPrunerReport(pushStatus.PruningSender)
-			t.addIndent(-1)
-
-			t.printf("Pruning Receiver:")
-			t.newline()
-			t.addIndent(1)
-			t.renderPrunerReport(pushStatus.PruningReceiver)
-			t.addIndent(-1)
-
 		}
 	}
 	termbox.Flush()
 }
 
-func (t *tui) renderReplicationReport(rep *replication.Report) {
+func (t *tui) renderReplicationReport(rep *report.Report, history *bytesProgressHistory) {
 	if rep == nil {
 		t.printf("...\n")
 		return
 	}
 
-	all := make([]*fsrep.Report, 0, len(rep.Completed)+len(rep.Pending) + 1)
-	all = append(all, rep.Completed...)
-	all = append(all, rep.Pending...)
-	if rep.Active != nil {
-		all = append(all, rep.Active)
+	if rep.WaitReconnectError != nil {
+		t.printfDrawIndentedAndWrappedIfMultiline("Connectivity: %s", rep.WaitReconnectError)
+		t.newline()
 	}
-	sort.Slice(all, func(i, j int) bool {
-		return all[i].Filesystem < all[j].Filesystem
+	if !rep.WaitReconnectSince.IsZero() {
+		delta := rep.WaitReconnectUntil.Sub(time.Now()).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 follwing 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
 	})
 
-	state, err := replication.StateString(rep.Status)
-	if err != nil {
-		t.printf("Status: %q (parse error: %q)\n", rep.Status, err)
-		return
-	}
-
-	t.printf("Status: %s", state)
+	t.printf("Status: %s", latest.State)
 	t.newline()
-	if rep.Problem != "" {
-		t.printf("Problem: %s", rep.Problem)
+	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 rep.SleepUntil.After(time.Now()) &&
-		state & ^(replication.ContextDone|replication.Completed) != 0 {
-		t.printf("Sleeping until %s (%s left)\n", rep.SleepUntil, rep.SleepUntil.Sub(time.Now()))
-	}
 
-	if state != replication.Planning && state != replication.PlanningError {
+	if latest.State != report.AttemptPlanning && latest.State != report.AttemptPlanningError {
+		// Draw global progress bar
 		// Progress: [---------------]
-		sumUpFSRep := func(rep *fsrep.Report) (transferred, total int64) {
-			for _, s := range rep.Pending {
-				transferred += s.Bytes
-				total  += s.ExpectedBytes
-			}
-			for _, s := range rep.Completed {
-				transferred += s.Bytes
-				total += s.ExpectedBytes
-			}
-			return
-		}
-		var transferred, total int64
-		for _, fs := range all {
-			fstx, fstotal := sumUpFSRep(fs)
-			transferred += fstx
-			total += fstotal
-		}
+		expected, replicated := latest.BytesSum()
+		rate, changeCount := history.Update(replicated)
 		t.write("Progress: ")
-		t.drawBar(80, transferred, total)
-		t.write(fmt.Sprintf(" %s / %s", ByteCountBinary(transferred), ByteCountBinary(total)))
+		t.drawBar(50, replicated, expected, changeCount)
+		t.write(fmt.Sprintf(" %s / %s @ %s/s", ByteCountBinary(replicated), ByteCountBinary(expected), ByteCountBinary(rate)))
 		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
+		}
+
 	}
 
-	var maxFSLen int
-	for _, fs := range all {
-		if len(fs.Filesystem) > maxFSLen {
-			maxFSLen = len(fs.Filesystem)
-		}
-	}
-	for _, fs := range all {
-		printFilesystemStatus(fs, t, fs == rep.Active, maxFSLen)
-	}
 }
 
 func (t *tui) renderPrunerReport(r *pruner.Report) {
@@ -333,9 +457,6 @@ func (t *tui) renderPrunerReport(r *pruner.Report) {
 	if r.Error != "" {
 		t.printf("Error: %s\n", r.Error)
 	}
-	if r.SleepUntil.After(time.Now()) {
-		t.printf("Sleeping until %s (%s left)\n", r.SleepUntil, r.SleepUntil.Sub(time.Now()))
-	}
 
 	type commonFS struct {
 		*pruner.FSReport
@@ -351,8 +472,7 @@ func (t *tui) renderPrunerReport(r *pruner.Report) {
 
 	switch state {
 	case pruner.Plan: fallthrough
-	case pruner.PlanWait: fallthrough
-	case pruner.ErrPerm:
+	case pruner.PlanErr:
 		return
 	}
 
@@ -392,8 +512,18 @@ func (t *tui) renderPrunerReport(r *pruner.Report) {
 	for _, fs := range all {
 		t.write(rightPad(fs.Filesystem, maxFSname, " "))
 		t.write(" ")
-		if fs.Error != "" {
-			t.printf("ERROR:    %s\n", fs.Error) // whitespace is padding
+		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
 		}
 
@@ -401,11 +531,11 @@ func (t *tui) renderPrunerReport(r *pruner.Report) {
 			len(fs.DestroyList), len(fs.SnapshotList))
 
 		if fs.completed {
-			t.printf( "Completed %s\n", pruneRuleActionStr)
+			t.printf( "Completed  %s\n", pruneRuleActionStr)
 			continue
 		}
 
-		t.write("Pending   ") // whitespace is padding 10
+		t.write("Pending    ") // whitespace is padding 10
 		if len(fs.DestroyList) == 1 {
 			t.write(fs.DestroyList[0].Name)
 		} else {
@@ -416,25 +546,6 @@ func (t *tui) renderPrunerReport(r *pruner.Report) {
 
 }
 
-const snapshotIndent = 1
-func calculateMaxFSLength(all []*fsrep.Report) (maxFS, maxStatus int) {
-	for _, e := range all {
-		if len(e.Filesystem) > maxFS {
-			maxFS = len(e.Filesystem)
-		}
-		all2 := make([]*fsrep.StepReport, 0, len(e.Pending) + len(e.Completed))
-		all2 = append(all2, e.Pending...)
-		all2 = append(all2, e.Completed...)
-		for _, e2 := range all2 {
-			elen := len(e2.Problem) + len(e2.From) + len(e2.To) + 60 // random spacing, units, labels, etc
-			if elen > maxStatus {
-				maxStatus = elen
-			}
-		}
-	}
-	return
-}
-
 func times(str string, n int) (out string) {
 	for i := 0; i < n; i++ {
 		out += str
@@ -457,7 +568,10 @@ func leftPad(str string, length int, pad string) string {
 	return times(pad, length-len(str)) + str
 }
 
-func (t *tui) drawBar(length int, bytes, totalBytes int64) {
+var arrowPositions = `>\|/`
+
+// changeCount = 0 indicates stall / no progresss
+func (t *tui) drawBar(length int, bytes, totalBytes int64, changeCount int) {
 	var completedLength int
 	if totalBytes > 0 {
 		completedLength = int(int64(length) * bytes / totalBytes)
@@ -470,66 +584,46 @@ func (t *tui) drawBar(length int, bytes, totalBytes int64) {
 
 	t.write("[")
 	t.write(times("=", completedLength))
-	t.write(">")
+	t.write( string(arrowPositions[changeCount%len(arrowPositions)]))
 	t.write(times("-", length-completedLength))
 	t.write("]")
 }
 
-func StringStepState(s fsrep.StepState) string {
-	switch s {
-	case fsrep.StepReplicationReady: return "Ready"
-	case fsrep.StepReplicationRetry: return "Retry"
-	case fsrep.StepMarkReplicatedReady: return "MarkReady"
-	case fsrep.StepMarkReplicatedRetry: return "MarkRetry"
-	case fsrep.StepPermanentError: return "PermanentError"
-	case fsrep.StepCompleted: return "Completed"
-	default:
-		return fmt.Sprintf("UNKNOWN %d", s)
-	}
-}
+func (t *tui) printFilesystemStatus(rep *report.FilesystemReport, active bool, maxFS int) {
 
-func filesystemStatusString(rep *fsrep.Report, active bool, fsWidth int) (line string, bytes, totalBytes int64) {
-	bytes = int64(0)
-	totalBytes = int64(0)
-	for _, s := range rep.Pending {
-		bytes += s.Bytes
-		totalBytes += s.ExpectedBytes
-	}
-	for _, s := range rep.Completed {
-		bytes += s.Bytes
-		totalBytes += s.ExpectedBytes
-	}
-
-	next := ""
-	if rep.Problem != "" {
-		next = " problem: " + rep.Problem
-	} else if len(rep.Pending) > 0 {
-		if rep.Pending[0].From != "" {
-			next = fmt.Sprintf(" next: %s => %s", rep.Pending[0].From, rep.Pending[0].To)
-		} else {
-			next = fmt.Sprintf(" next: %s (full)", rep.Pending[0].To)
-		}
-	}
-	status := fmt.Sprintf("%s (step %d/%d, %s/%s)%s",
-		rep.Status,
-		len(rep.Completed), len(rep.Pending) + len(rep.Completed),
-		ByteCountBinary(bytes), ByteCountBinary(totalBytes),
-		next,
+	expected, replicated := rep.BytesSum()
+	status := fmt.Sprintf("%s (step %d/%d, %s/%s)",
+		strings.ToUpper(string(rep.State)),
+		rep.CurrentStep, len(rep.Steps),
+		ByteCountBinary(replicated), ByteCountBinary(expected),
 	)
+
 	activeIndicator := " "
 	if active {
 		activeIndicator = "*"
 	}
-	line = fmt.Sprintf("%s %s %s",
+	t.printf("%s %s %s ",
 		activeIndicator,
-		rightPad(rep.Filesystem, fsWidth, " "),
+		rightPad(rep.Info.Name, maxFS, " "),
 		status)
-	return line, bytes, totalBytes
-}
 
-func printFilesystemStatus(rep *fsrep.Report, t *tui, active bool, maxFS int) {
-	totalStatus, _, _ := filesystemStatusString(rep, active, maxFS)
-	t.write(totalStatus)
+	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: %s (full)", nextStep.Info.To)
+			}
+		} else {
+			next = "" // individual FSes may still be in planning state
+		}
+
+	}
+	t.printfDrawIndentedAndWrappedIfMultiline("%s", next)
+
 	t.newline()
 }
 

client/testcmd.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"fmt"
+	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
 	"github.com/zrepl/zrepl/cli"
 	"github.com/zrepl/zrepl/config"
@@ -12,7 +13,7 @@ import (
 var TestCmd = &cli.Subcommand {
 	Use: "test",
 	SetupSubcommands: func() []*cli.Subcommand {
-		return []*cli.Subcommand{testFilter}
+		return []*cli.Subcommand{testFilter, testPlaceholder}
 	},
 }
 
@@ -105,4 +106,71 @@ func runTestFilterCmd(subcommand *cli.Subcommand, args []string) error {
 		return fmt.Errorf("filter errors occurred")
 	}
 	return nil
-}
+}
+
+var testPlaceholderArgs struct {
+	action string
+	ds     string
+	plv    string
+	all    bool
+}
+
+var testPlaceholder = &cli.Subcommand{
+	Use:   "placeholder [--all | --dataset DATASET]",
+	Short: fmt.Sprintf("list received placeholder filesystems (zfs property %q)", zfs.PlaceholderPropertyName),
+	Example: `
+	placeholder --all
+	placeholder --dataset path/to/sink/clientident/fs`,
+	NoRequireConfig: true,
+	SetupFlags: func(f *pflag.FlagSet) {
+		f.StringVar(&testPlaceholderArgs.ds, "dataset", "", "dataset path (not required to exist)")
+		f.BoolVar(&testPlaceholderArgs.all, "all", false, "list tab-separated placeholder status of all filesystems")
+	},
+	Run: runTestPlaceholder,
+}
+
+func runTestPlaceholder(subcommand *cli.Subcommand, args []string) error {
+
+	var checkDPs []*zfs.DatasetPath
+
+	// all actions first
+	if testPlaceholderArgs.all {
+		out, err := zfs.ZFSList([]string{"name"})
+		if err != nil {
+			return errors.Wrap(err, "could not list ZFS filesystems")
+		}
+		for _, row := range out {
+			dp, err := zfs.NewDatasetPath(row[0])
+			if err != nil {
+				panic(err)
+			}
+			checkDPs = append(checkDPs, dp)
+		}
+	} else {
+		dp, err := zfs.NewDatasetPath(testPlaceholderArgs.ds)
+		if err != nil {
+			return err
+		}
+		if dp.Empty() {
+			return fmt.Errorf("must specify --dataset DATASET or --all")
+		}
+		checkDPs = append(checkDPs, dp)
+	}
+
+	fmt.Printf("IS_PLACEHOLDER\tDATASET\tzrepl:placeholder\n")
+	for _, dp := range checkDPs {
+		ph, err := zfs.ZFSGetFilesystemPlaceholderState(dp)
+		if err != nil {
+			return errors.Wrap(err, "cannot get placeholder state")
+		}
+		if !ph.FSExists {
+			panic("placeholder state inconsistent: filesystem " + ph.FS + " must exist in this context")
+		}
+		is := "yes"
+		if !ph.IsPlaceholder {
+			is = "no"
+		}
+		fmt.Printf("%s\t%s\t%s\n", is, dp.ToString(), ph.RawLocalPropertyValue)
+	}
+	return nil
+}

config/config.go

@@ -5,6 +5,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/zrepl/yaml-config"
 	"io/ioutil"
+	"log/syslog"
 	"os"
 	"reflect"
 	"regexp"
@@ -33,12 +34,13 @@ type JobEnum struct {
 func (j JobEnum) Name() string {
 	var name string
 	switch v := j.Ret.(type) {
+	case *SnapJob: name = v.Name
 	case *PushJob: name = v.Name
 	case *SinkJob: name = v.Name
 	case *PullJob: name = v.Name
 	case *SourceJob: name = v.Name
 	default:
-		panic(fmt.Sprintf("unknownn job type %T", v))
+		panic(fmt.Sprintf("unknown job type %T", v))
 	}
 	return name
 }
@@ -58,6 +60,15 @@ type PassiveJob struct {
 	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 PushJob struct {
 	ActiveJob `yaml:",inline"`
 	Snapshotting SnapshottingEnum          `yaml:"snapshotting"`
@@ -67,7 +78,38 @@ type PushJob struct {
 type PullJob struct {
 	ActiveJob `yaml:",inline"`
 	RootFS    string        `yaml:"root_fs"`
-	Interval  time.Duration `yaml:"interval,positive"`
+	Interval  PositiveDurationOrManual `yaml:"interval"`
+}
+
+type PositiveDurationOrManual struct {
+	Interval time.Duration
+	Manual   bool
+}
+
+var _ yaml.Unmarshaler = (*PositiveDurationOrManual)(nil)
+
+func (i *PositiveDurationOrManual) UnmarshalYAML(u func(interface{}, bool) error) (err error) {
+	var s string
+	if err := u(&s, true); err != nil {
+		return err
+	}
+	switch s {
+	case "manual":
+		i.Manual = true
+		i.Interval = 0
+	case "":
+		return fmt.Errorf("value must not be empty")
+	default:
+		i.Manual = false
+		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
 }
 
 type SinkJob struct {
@@ -115,7 +157,7 @@ time: true
 level: "warn"
 format: "human"
 `
-	s := StdoutLoggingOutlet{}
+	s := &StdoutLoggingOutlet{}
 	err := yaml.UnmarshalStrict([]byte(def), &s)
 	if err != nil {
 		panic(err)
@@ -130,7 +172,6 @@ type Global struct {
 	Monitoring []MonitoringEnum       `yaml:"monitoring,optional"`
 	Control    *GlobalControl         `yaml:"control,optional,fromdefaults"`
 	Serve      *GlobalServe           `yaml:"serve,optional,fromdefaults"`
-	RPC        *RPCConfig             `yaml:"rpc,optional,fromdefaults"`
 }
 
 func Default(i interface{}) {
@@ -145,29 +186,18 @@ func Default(i interface{}) {
 	}
 }
 
-type RPCConfig struct {
-	Timeout             time.Duration `yaml:"timeout,optional,positive,default=10s"`
-	TxChunkSize         uint32        `yaml:"tx_chunk_size,optional,default=32768"`
-	RxStructuredMaxLen  uint32        `yaml:"rx_structured_max,optional,default=16777216"`
-	RxStreamChunkMaxLen uint32        `yaml:"rx_stream_chunk_max,optional,default=16777216"`
-	RxHeaderMaxLen      uint32        `yaml:"rx_header_max,optional,default=40960"`
-	SendHeartbeatInterval             time.Duration `yaml:"send_heartbeat_interval,optional,positive,default=5s"`
-
-}
-
 type ConnectEnum struct {
 	Ret interface{}
 }
 
 type ConnectCommon struct {
-	Type string     `yaml:"type"`
-	RPC  *RPCConfig `yaml:"rpc,optional"`
+	Type string            `yaml:"type"`
 }
 
 type TCPConnect struct {
 	ConnectCommon `yaml:",inline"`
 	Address       string        `yaml:"address"`
-	DialTimeout   time.Duration `yaml:"dial_timeout,positive,default=10s"`
+	DialTimeout   time.Duration `yaml:"dial_timeout,zeropositive,default=10s"`
 }
 
 type TLSConnect struct {
@@ -177,7 +207,7 @@ type TLSConnect struct {
 	Cert          string        `yaml:"cert"`
 	Key           string        `yaml:"key"`
 	ServerCN      string        `yaml:"server_cn"`
-	DialTimeout   time.Duration `yaml:"dial_timeout,positive,default=10s"`
+	DialTimeout   time.Duration `yaml:"dial_timeout,zeropositive,default=10s"`
 }
 
 type SSHStdinserverConnect struct {
@@ -189,7 +219,7 @@ type SSHStdinserverConnect struct {
 	TransportOpenCommand []string      `yaml:"transport_open_command,optional"` //TODO unused
 	SSHCommand           string        `yaml:"ssh_command,optional"`            //TODO unused
 	Options              []string      `yaml:"options,optional"`
-	DialTimeout          time.Duration `yaml:"dial_timeout,positive,default=10s"`
+	DialTimeout          time.Duration `yaml:"dial_timeout,zeropositive,default=10s"`
 }
 
 type LocalConnect struct {
@@ -203,8 +233,7 @@ type ServeEnum struct {
 }
 
 type ServeCommon struct {
-	Type string     `yaml:"type"`
-	RPC  *RPCConfig `yaml:"rpc,optional"`
+	Type string            `yaml:"type"`
 }
 
 type TCPServe struct {
@@ -220,7 +249,7 @@ type TLSServe struct {
 	Cert             string        `yaml:"cert"`
 	Key              string        `yaml:"key"`
 	ClientCNs        []string      `yaml:"client_cns"`
-	HandshakeTimeout time.Duration `yaml:"handshake_timeout,positive,default=10s"`
+	HandshakeTimeout time.Duration `yaml:"handshake_timeout,zeropositive,default=10s"`
 }
 
 type StdinserverServer struct {
@@ -250,6 +279,7 @@ type PruneKeepLastN struct {
 type PruneKeepRegex struct { // FIXME rename to KeepRegex
 	Type  string `yaml:"type"`
 	Regex string `yaml:"regex"`
+	Negate bool   `yaml:"negate,optional,default=false"`
 }
 
 type LoggingOutletEnum struct {
@@ -270,6 +300,7 @@ type StdoutLoggingOutlet struct {
 
 type SyslogLoggingOutlet struct {
 	LoggingOutletCommon `yaml:",inline"`
+	Facility            *SyslogFacility `yaml:"facility,optional,fromdefaults"`
 	RetryInterval       time.Duration `yaml:"retry_interval,positive,default=10s"`
 }
 
@@ -296,6 +327,14 @@ type PrometheusMonitoring struct {
 	Listen string `yaml:"listen"`
 }
 
+type SyslogFacility syslog.Priority
+
+func (f *SyslogFacility) SetDefault() {
+	*f = SyslogFacility(syslog.LOG_LOCAL0)
+}
+
+var _ yaml.Defaulter = (*SyslogFacility)(nil)
+
 type GlobalControl struct {
 	SockPath string `yaml:"sockpath,default=/var/run/zrepl/control"`
 }
@@ -339,6 +378,7 @@ func enumUnmarshal(u func(interface{}, bool) error, types map[string]interface{}
 
 func (t *JobEnum) UnmarshalYAML(u func(interface{}, bool) error) (err error) {
 	t.Ret, err = enumUnmarshal(u, map[string]interface{}{
+		"snap":   &SnapJob{},
 		"push":   &PushJob{},
 		"sink":   &SinkJob{},
 		"pull":   &PullJob{},
@@ -401,6 +441,40 @@ func (t *MonitoringEnum) UnmarshalYAML(u func(interface{}, bool) error) (err err
 	return
 }
 
+func (t *SyslogFacility) UnmarshalYAML(u func(interface{}, bool) error) (err error) {
+	var s string
+	if err := u(&s, true); err != nil {
+		return err
+	}
+	var level syslog.Priority
+	switch s {
+		case "kern":     level = syslog.LOG_KERN
+		case "user":     level = syslog.LOG_USER
+		case "mail":     level = syslog.LOG_MAIL
+		case "daemon":   level = syslog.LOG_DAEMON
+		case "auth":     level = syslog.LOG_AUTH
+		case "syslog":   level = syslog.LOG_SYSLOG
+		case "lpr":      level = syslog.LOG_LPR
+		case "news":     level = syslog.LOG_NEWS
+		case "uucp":     level = syslog.LOG_UUCP
+		case "cron":     level = syslog.LOG_CRON
+		case "authpriv": level = syslog.LOG_AUTHPRIV
+		case "ftp":      level = syslog.LOG_FTP
+		case "local0":   level = syslog.LOG_LOCAL0
+		case "local1":   level = syslog.LOG_LOCAL1
+		case "local2":   level = syslog.LOG_LOCAL2
+		case "local3":   level = syslog.LOG_LOCAL3
+		case "local4":   level = syslog.LOG_LOCAL4
+		case "local5":   level = syslog.LOG_LOCAL5
+		case "local6":   level = syslog.LOG_LOCAL6
+		case "local7":   level = syslog.LOG_LOCAL7
+	default:
+		return fmt.Errorf("invalid syslog level: %q", s)
+	}
+	*t = SyslogFacility(level)
+	return  nil
+}
+
 var ConfigFileDefaultLocations = []string{
 	"/etc/zrepl/zrepl.yml",
 	"/usr/local/etc/zrepl/zrepl.yml",

config/config_global_test.go

@@ -1,9 +1,11 @@
 package config
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/zrepl/yaml-config"
+	"log/syslog"
 	"testing"
 )
 
@@ -57,7 +59,7 @@ global:
 func TestDefaultLoggingOutlet(t *testing.T) {
 	conf := testValidGlobalSection(t, "")
 	assert.Equal(t, 1, len(*conf.Global.Logging))
-	o := (*conf.Global.Logging)[0].Ret.(StdoutLoggingOutlet)
+	o := (*conf.Global.Logging)[0].Ret.(*StdoutLoggingOutlet)
 	assert.Equal(t, "warn", o.Level)
 	assert.Equal(t, "human", o.Format)
 }
@@ -72,11 +74,41 @@ global:
 	assert.Equal(t, ":9091", conf.Global.Monitoring[0].Ret.(*PrometheusMonitoring).Listen)	
 }
 
+func TestSyslogLoggingOutletFacility(t *testing.T) {
+	type SyslogFacilityPriority struct {
+		Facility string
+		Priority syslog.Priority
+	}
+	syslogFacilitiesPriorities := []SyslogFacilityPriority{
+		{"", syslog.LOG_LOCAL0}, // default
+		{"kern", syslog.LOG_KERN}, {"daemon", syslog.LOG_DAEMON}, {"auth", syslog.LOG_AUTH},
+		{"syslog", syslog.LOG_SYSLOG}, {"lpr", syslog.LOG_LPR}, {"news", syslog.LOG_NEWS},
+		{"uucp", syslog.LOG_UUCP}, {"cron", syslog.LOG_CRON}, {"authpriv", syslog.LOG_AUTHPRIV},
+		{"ftp", syslog.LOG_FTP}, {"local0", syslog.LOG_LOCAL0}, {"local1", syslog.LOG_LOCAL1},
+		{"local2", syslog.LOG_LOCAL2}, {"local3", syslog.LOG_LOCAL3}, {"local4", syslog.LOG_LOCAL4},
+		{"local5", syslog.LOG_LOCAL5}, {"local6", syslog.LOG_LOCAL6}, {"local7", syslog.LOG_LOCAL7},
+	}
+
+	for _, sFP := range syslogFacilitiesPriorities {
+		logcfg := fmt.Sprintf(`
+global:
+  logging:
+  - type: syslog
+    level: info
+    format: human
+    facility: %s
+`, sFP.Facility)
+		conf := testValidGlobalSection(t, logcfg)
+		assert.Equal(t, 1, len(*conf.Global.Logging))
+		assert.True(t, SyslogFacility(sFP.Priority) == *(*conf.Global.Logging)[0].Ret.(*SyslogLoggingOutlet).Facility)
+	}
+}
+
 func TestLoggingOutletEnumList_SetDefaults(t *testing.T) {
 	e := &LoggingOutletEnumList{}
 	var i yaml.Defaulter = e
 	require.NotPanics(t, func() {
 		i.SetDefault()
-		assert.Equal(t, "warn", (*e)[0].Ret.(StdoutLoggingOutlet).Level)
+		assert.Equal(t, "warn", (*e)[0].Ret.(*StdoutLoggingOutlet).Level)
 	})
 }

config/config_positiveintervalormanual_test.go

@@ -0,0 +1,41 @@
+package config
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/zrepl/yaml-config"
+)
+
+func TestPositiveDurationOrManual(t *testing.T) {
+	cases := []struct {
+		Comment, Input string
+		Result         *PositiveDurationOrManual
+	}{
+		{"empty is error", "", nil},
+		{"negative is error", "-1s", nil},
+		{"zero seconds is error", "0s", nil},
+		{"zero is error", "0", nil},
+		{"non-manual is error", "something", nil},
+		{"positive seconds works", "1s", &PositiveDurationOrManual{Manual: false, Interval: 1 * time.Second}},
+		{"manual works", "manual", &PositiveDurationOrManual{Manual: true, Interval: 0}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.Comment, func(t *testing.T) {
+			var out struct {
+				FieldName PositiveDurationOrManual `yaml:"fieldname"`
+			}
+			input := fmt.Sprintf("\nfieldname: %s\n", tc.Input)
+			err := yaml.UnmarshalStrict([]byte(input), &out)
+			if tc.Result == nil {
+				assert.Error(t, err)
+				t.Logf("%#v", out)
+			} else {
+				assert.Equal(t, *tc.Result, out.FieldName)
+			}
+		})
+	}
+
+}

config/config_rpc_test.go

@@ -1,86 +0,0 @@
-package config
-
-import (
-	"github.com/stretchr/testify/assert"
-	"testing"
-	"time"
-)
-
-func TestRPC(t *testing.T) {
-	conf := testValidConfig(t, `
-jobs:
-- name: pull_servers
-  type: pull
-  connect:
-    type: tcp
-    address: "server1.foo.bar:8888"
-    rpc:
-      timeout: 20s # different form default, should merge
-  root_fs: "pool2/backup_servers"
-  interval: 10m
-  pruning:
-    keep_sender:
-      - type: not_replicated
-    keep_receiver:
-      - type: last_n
-        count: 100
-
-- name: pull_servers2
-  type: pull
-  connect:
-    type: tcp
-    address: "server1.foo.bar:8888"
-    rpc:
-      tx_chunk_size: 0xabcd # different from default, should merge
-  root_fs: "pool2/backup_servers"
-  interval: 10m
-  pruning:
-    keep_sender:
-    - type: not_replicated
-    keep_receiver:
-    - type: last_n
-      count: 100
-
-- type: sink
-  name: "laptop_sink"
-  root_fs: "pool2/backup_laptops"
-  serve:
-    type: tcp
-    listen: "192.168.122.189:8888"
-    clients: {
-	"10.23.42.23":"client1"
-    }
-    rpc:
-      rx_structured_max: 0x2342
-
-- type: sink
-  name: "other_sink"
-  root_fs: "pool2/backup_laptops"
-  serve:
-    type: tcp
-    listen: "192.168.122.189:8888"
-    clients: {
-	"10.23.42.23":"client1"
-    }
-    rpc:
-      send_heartbeat_interval: 10s
-
-`)
-
-	assert.Equal(t, 20*time.Second, conf.Jobs[0].Ret.(*PullJob).Connect.Ret.(*TCPConnect).RPC.Timeout)
-	assert.Equal(t, uint32(0xabcd), conf.Jobs[1].Ret.(*PullJob).Connect.Ret.(*TCPConnect).RPC.TxChunkSize)
-	assert.Equal(t, uint32(0x2342), conf.Jobs[2].Ret.(*SinkJob).Serve.Ret.(*TCPServe).RPC.RxStructuredMaxLen)
-	assert.Equal(t, 10*time.Second, conf.Jobs[3].Ret.(*SinkJob).Serve.Ret.(*TCPServe).RPC.SendHeartbeatInterval)
-	defConf := RPCConfig{}
-	Default(&defConf)
-	assert.Equal(t, defConf.Timeout, conf.Global.RPC.Timeout)
-}
-
-func TestGlobal_DefaultRPCConfig(t *testing.T) {
-	assert.NotPanics(t, func() {
-		var c RPCConfig
-		Default(&c)
-		assert.NotNil(t, c)
-		assert.Equal(t, c.TxChunkSize, uint32(1)<<15)
-	})
-}

config/config_test.go

@@ -1,11 +1,14 @@
 package config
 
 import (
-	"github.com/kr/pretty"
-	"github.com/stretchr/testify/require"
+	"bytes"
 	"path"
 	"path/filepath"
 	"testing"
+	"text/template"
+
+	"github.com/kr/pretty"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSampleConfigsAreParsedWithoutErrors(t *testing.T) {
@@ -35,8 +38,21 @@ func TestSampleConfigsAreParsedWithoutErrors(t *testing.T) {
 
 }
 
+// template must be a template/text template with a single '{{ . }}' as placehodler for val
+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) {
+func testValidConfig(t *testing.T, input string) *Config {
 	t.Helper()
 	conf, err := testConfig(t, input)
 	require.NoError(t, err)
@@ -47,4 +63,4 @@ func testValidConfig(t *testing.T, input string) (*Config) {
 func testConfig(t *testing.T, input string) (*Config, error) {
 	t.Helper()
 	return ParseConfigBytes([]byte(input))
-}
+}

config/samples/snap.yml

@@ -0,0 +1,14 @@
+jobs:
+- name: snapjob
+  type: snap
+  filesystems: {
+    "tank/frequently_changed<": true,
+  }
+  snapshotting:
+    type: periodic
+    interval: 2m
+    prefix: zrepl_snapjob_
+  pruning:
+    keep:
+      - type: last_n
+        count: 60

daemon/control.go

@@ -5,16 +5,18 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"time"
+
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/zrepl/zrepl/daemon/job"
 	"github.com/zrepl/zrepl/daemon/nethelpers"
 	"github.com/zrepl/zrepl/logger"
 	"github.com/zrepl/zrepl/version"
-	"io"
-	"net"
-	"net/http"
-	"time"
+	"github.com/zrepl/zrepl/zfs"
 )
 
 type controlJob struct {
@@ -38,6 +40,8 @@ func (j *controlJob) Name() string { return jobNameControl }
 
 func (j *controlJob) Status() *job.Status { return &job.Status{Type: job.TypeInternal} }
 
+func (j *controlJob) OwnedDatasetSubtreeRoot() (p *zfs.DatasetPath, ok bool) { return nil, false }
+
 var promControl struct {
 	requestBegin *prometheus.CounterVec
 	requestFinished *prometheus.HistogramVec
@@ -100,10 +104,11 @@ func (j *controlJob) Run(ctx context.Context) {
 		}}})
 
 	mux.Handle(ControlJobEndpointStatus,
-		requestLogger{log: log, handler: jsonResponder{func() (interface{}, error) {
+		// don't log requests to status endpoint, too spammy
+		jsonResponder{func() (interface{}, error) {
 			s := j.jobs.status()
 			return s, nil
-		}}})
+		}})
 
 	mux.Handle(ControlJobEndpointSignal,
 		requestLogger{log: log, handler: jsonRequestResponder{func(decoder jsonDecoder) (interface{}, error) {

daemon/job/active.go

@@ -2,43 +2,67 @@ package job
 
 import (
 	"context"
+	"sync"
+	"time"
+
 	"github.com/pkg/errors"
-	"github.com/problame/go-streamrpc"
 	"github.com/prometheus/client_golang/prometheus"
+
 	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/daemon/filters"
 	"github.com/zrepl/zrepl/daemon/job/reset"
 	"github.com/zrepl/zrepl/daemon/job/wakeup"
-	"github.com/zrepl/zrepl/daemon/transport/connecter"
-	"github.com/zrepl/zrepl/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/logging"
 	"github.com/zrepl/zrepl/daemon/pruner"
+	"github.com/zrepl/zrepl/daemon/snapper"
 	"github.com/zrepl/zrepl/endpoint"
 	"github.com/zrepl/zrepl/replication"
+	"github.com/zrepl/zrepl/replication/driver"
+	"github.com/zrepl/zrepl/replication/logic"
+	"github.com/zrepl/zrepl/replication/report"
+	"github.com/zrepl/zrepl/rpc"
+	"github.com/zrepl/zrepl/transport"
+	"github.com/zrepl/zrepl/transport/fromconfig"
 	"github.com/zrepl/zrepl/zfs"
-	"sync"
-	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/daemon/snapper"
-	"time"
 )
 
 type ActiveSide struct {
-	mode          activeMode
-	name          string
-	clientFactory *connecter.ClientFactory
+	mode      activeMode
+	name      string
+	connecter transport.Connecter
 
 	prunerFactory *pruner.PrunerFactory
 
-
-	promRepStateSecs *prometheus.HistogramVec // labels: state
-	promPruneSecs *prometheus.HistogramVec // labels: prune_side
-	promBytesReplicated *prometheus.CounterVec // labels: filesystem
+	promRepStateSecs    *prometheus.HistogramVec // labels: state
+	promPruneSecs       *prometheus.HistogramVec // labels: prune_side
+	promBytesReplicated *prometheus.CounterVec   // labels: filesystem
 
 	tasksMtx sync.Mutex
 	tasks    activeSideTasks
 }
 
+//go:generate enumer -type=ActiveSideState
+type ActiveSideState int
+
+const (
+	ActiveSideReplicating ActiveSideState = 1 << iota
+	ActiveSidePruneSender
+	ActiveSidePruneReceiver
+	ActiveSideDone // also errors
+)
+
 type activeSideTasks struct {
-	replication *replication.Replication
+	state ActiveSideState
+
+	// valid for state ActiveSideReplicating, ActiveSidePruneSender, ActiveSidePruneReceiver, ActiveSideDone
+	replicationReport driver.ReportFunc
+	replicationCancel context.CancelFunc
+
+	// valid for state ActiveSidePruneSender, ActiveSidePruneReceiver, ActiveSideDone
 	prunerSender, prunerReceiver *pruner.Pruner
+
+	// valid for state ActiveSidePruneReceiver, ActiveSideDone
+	prunerSenderCancel, prunerReceiverCancel context.CancelFunc
 }
 
 func (a *ActiveSide) updateTasks(u func(*activeSideTasks)) activeSideTasks {
@@ -55,28 +79,59 @@ func (a *ActiveSide) updateTasks(u func(*activeSideTasks)) activeSideTasks {
 }
 
 type activeMode interface {
-	SenderReceiver(client *streamrpc.Client) (replication.Sender, replication.Receiver, error)
+	ConnectEndpoints(rpcLoggers rpc.Loggers, connecter transport.Connecter)
+	DisconnectEndpoints()
+	SenderReceiver() (logic.Sender, logic.Receiver)
 	Type() Type
 	RunPeriodic(ctx context.Context, wakeUpCommon chan<- struct{})
+	ResetConnectBackoff()
 }
 
 type modePush struct {
-	fsfilter         endpoint.FSFilter
-	snapper *snapper.PeriodicOrManual
+	setupMtx sync.Mutex
+	sender   *endpoint.Sender
+	receiver *rpc.Client
+	fsfilter endpoint.FSFilter
+	snapper  *snapper.PeriodicOrManual
 }
 
-func (m *modePush) SenderReceiver(client *streamrpc.Client) (replication.Sender, replication.Receiver, error) {
-	sender := endpoint.NewSender(m.fsfilter)
-	receiver := endpoint.NewRemote(client)
-	return sender, receiver, nil
+func (m *modePush) ConnectEndpoints(loggers rpc.Loggers, connecter transport.Connecter) {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	if m.receiver != nil || m.sender != nil {
+		panic("inconsistent use of ConnectEndpoints and DisconnectEndpoints")
+	}
+	m.sender = endpoint.NewSender(m.fsfilter)
+	m.receiver = rpc.NewClient(connecter, loggers)
+}
+
+func (m *modePush) DisconnectEndpoints() {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	m.receiver.Close()
+	m.sender = nil
+	m.receiver = nil
+}
+
+func (m *modePush) SenderReceiver() (logic.Sender, logic.Receiver) {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	return m.sender, m.receiver
 }
 
 func (m *modePush) Type() Type { return TypePush }
 
-func (m *modePush) RunPeriodic(ctx context.Context, wakeUpCommon chan <- struct{}) {
+func (m *modePush) RunPeriodic(ctx context.Context, wakeUpCommon chan<- struct{}) {
 	m.snapper.Run(ctx, wakeUpCommon)
 }
 
+func (m *modePush) ResetConnectBackoff() {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	if m.receiver != nil {
+		m.receiver.ResetConnectBackoff()
+	}
+}
 
 func modePushFromConfig(g *config.Global, in *config.PushJob) (*modePush, error) {
 	m := &modePush{}
@@ -94,20 +149,46 @@ func modePushFromConfig(g *config.Global, in *config.PushJob) (*modePush, error)
 }
 
 type modePull struct {
+	setupMtx sync.Mutex
+	receiver *endpoint.Receiver
+	sender   *rpc.Client
 	rootFS   *zfs.DatasetPath
-	interval time.Duration
+	interval config.PositiveDurationOrManual
 }
 
-func (m *modePull) SenderReceiver(client *streamrpc.Client) (replication.Sender, replication.Receiver, error) {
-	sender := endpoint.NewRemote(client)
-	receiver, err := endpoint.NewReceiver(m.rootFS)
-	return sender, receiver, err
+func (m *modePull) ConnectEndpoints(loggers rpc.Loggers, connecter transport.Connecter) {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	if m.receiver != nil || m.sender != nil {
+		panic("inconsistent use of ConnectEndpoints and DisconnectEndpoints")
+	}
+	m.receiver = endpoint.NewReceiver(m.rootFS, false)
+	m.sender = rpc.NewClient(connecter, loggers)
+}
+
+func (m *modePull) DisconnectEndpoints() {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	m.sender.Close()
+	m.sender = nil
+	m.receiver = nil
+}
+
+func (m *modePull) SenderReceiver() (logic.Sender, logic.Receiver) {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	return m.sender, m.receiver
 }
 
 func (*modePull) Type() Type { return TypePull }
 
 func (m *modePull) RunPeriodic(ctx context.Context, wakeUpCommon chan<- struct{}) {
-	t := time.NewTicker(m.interval)
+	if m.interval.Manual {
+		GetLogger(ctx).Info("manual pull configured, periodic pull disabled")
+		// "waiting for wakeups" is printed in common ActiveSide.do
+		return
+	}
+	t := time.NewTicker(m.interval.Interval)
 	defer t.Stop()
 	for {
 		select {
@@ -126,11 +207,16 @@ func (m *modePull) RunPeriodic(ctx context.Context, wakeUpCommon chan<- struct{}
 	}
 }
 
+func (m *modePull) ResetConnectBackoff() {
+	m.setupMtx.Lock()
+	defer m.setupMtx.Unlock()
+	if m.sender != nil {
+		m.sender.ResetConnectBackoff()
+	}
+}
+
 func modePullFromConfig(g *config.Global, in *config.PullJob) (m *modePull, err error) {
 	m = &modePull{}
-	if in.Interval <= 0 {
-		return nil, errors.New("interval must be positive")
-	}
 	m.interval = in.Interval
 
 	m.rootFS, err = zfs.NewDatasetPath(in.RootFS)
@@ -153,17 +239,17 @@ func activeSide(g *config.Global, in *config.ActiveJob, mode activeMode) (j *Act
 		Subsystem:   "replication",
 		Name:        "state_time",
 		Help:        "seconds spent during replication",
-		ConstLabels: prometheus.Labels{"zrepl_job":j.name},
+		ConstLabels: prometheus.Labels{"zrepl_job": j.name},
 	}, []string{"state"})
 	j.promBytesReplicated = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace:   "zrepl",
 		Subsystem:   "replication",
 		Name:        "bytes_replicated",
 		Help:        "number of bytes replicated from sender to receiver per filesystem",
-		ConstLabels: prometheus.Labels{"zrepl_job":j.name},
+		ConstLabels: prometheus.Labels{"zrepl_job": j.name},
 	}, []string{"filesystem"})
 
-	j.clientFactory, err = connecter.FromConfig(g, in.Connect)
+	j.connecter, err = fromconfig.ConnecterFromConfig(g, in.Connect)
 	if err != nil {
 		return nil, errors.Wrap(err, "cannot build client")
 	}
@@ -173,7 +259,7 @@ func activeSide(g *config.Global, in *config.ActiveJob, mode activeMode) (j *Act
 		Subsystem:   "pruning",
 		Name:        "time",
 		Help:        "seconds spent in pruner",
-		ConstLabels: prometheus.Labels{"zrepl_job":j.name},
+		ConstLabels: prometheus.Labels{"zrepl_job": j.name},
 	}, []string{"prune_side"})
 	j.prunerFactory, err = pruner.NewPrunerFactory(in.Pruning, j.promPruneSecs)
 	if err != nil {
@@ -192,7 +278,7 @@ func (j *ActiveSide) RegisterMetrics(registerer prometheus.Registerer) {
 func (j *ActiveSide) Name() string { return j.name }
 
 type ActiveSideStatus struct {
-	Replication *replication.Report
+	Replication                    *report.Report
 	PruningSender, PruningReceiver *pruner.Report
 }
 
@@ -201,8 +287,8 @@ func (j *ActiveSide) Status() *Status {
 
 	s := &ActiveSideStatus{}
 	t := j.mode.Type()
-	if tasks.replication != nil {
-		s.Replication = tasks.replication.Report()
+	if tasks.replicationReport != nil {
+		s.Replication = tasks.replicationReport()
 	}
 	if tasks.prunerSender != nil {
 		s.PruningSender = tasks.prunerSender.Report()
@@ -213,6 +299,15 @@ func (j *ActiveSide) Status() *Status {
 	return &Status{Type: t, JobSpecific: s}
 }
 
+func (j *ActiveSide) OwnedDatasetSubtreeRoot() (rfs *zfs.DatasetPath, ok bool) {
+	pull, ok := j.mode.(*modePull)
+	if !ok {
+		_ = j.mode.(*modePush) // make sure we didn't introduce a new job type
+		return nil, false
+	}
+	return pull.rootFS.Copy(), true
+}
+
 func (j *ActiveSide) Run(ctx context.Context) {
 	log := GetLogger(ctx)
 	ctx = logging.WithSubsystemLoggers(ctx, log)
@@ -234,27 +329,28 @@ outer:
 			break outer
 
 		case <-wakeup.Wait(ctx):
+			j.mode.ResetConnectBackoff()
 		case <-periodicDone:
 		}
 		invocationCount++
 		invLog := log.WithField("invocation", invocationCount)
-		j.do(WithLogger(ctx, invLog), periodicDone)
+		j.do(WithLogger(ctx, invLog))
 	}
 }
 
-func (j *ActiveSide) do(ctx context.Context, periodicWakeup <-chan struct{}) {
+func (j *ActiveSide) do(ctx context.Context) {
 
 	log := GetLogger(ctx)
 	ctx = logging.WithSubsystemLoggers(ctx, log)
+	loggers := rpc.GetLoggersOrPanic(ctx) // filled by WithSubsystemLoggers
+	j.mode.ConnectEndpoints(loggers, j.connecter)
+	defer j.mode.DisconnectEndpoints()
 
 	// allow cancellation of an invocation (this function)
 	ctx, cancelThisRun := context.WithCancel(ctx)
 	defer cancelThisRun()
-	runDone := make(chan struct{})
-	defer close(runDone)
 	go func() {
 		select {
-		case <-runDone:
 		case <-reset.Wait(ctx):
 			log.Info("reset received, cancelling current invocation")
 			cancelThisRun()
@@ -262,144 +358,67 @@ func (j *ActiveSide) do(ctx context.Context, periodicWakeup <-chan struct{}) {
 		}
 	}()
 
-	client, err := j.clientFactory.NewClient()
-	if err != nil {
-		log.WithError(err).Error("factory cannot instantiate streamrpc client")
-	}
-	defer client.Close(ctx)
+	sender, receiver := j.mode.SenderReceiver()
 
-	sender, receiver, err := j.mode.SenderReceiver(client)
-
-	tasks := j.updateTasks(func(tasks *activeSideTasks) {
-		// reset it
-		*tasks = activeSideTasks{}
-		tasks.replication = replication.NewReplication(j.promRepStateSecs, j.promBytesReplicated)
-	})
-
-	log.Info("start replication")
-	replicationDone := make(chan struct{})
-	replicationCtx, replicationCancel := context.WithCancel(ctx)
-	defer replicationCancel()
-	go func() {
-		tasks.replication.Drive(replicationCtx, sender, receiver)
-		close(replicationDone)
-	}()
-	outer:
-	for {
+	{
 		select {
-		case <-replicationDone:
-			// fine!
-			break outer
-		case <-periodicWakeup:
-			// Replication took longer than the periodic interval.
-			//
-			// For pull jobs, this isn't so bad because nothing changes on the active side
-			// if replication doesn't go forward.
-			//
-			// For push jobs, this means snapshots were taken.
-			// We need to invoke the pruner now, because otherwise an infinitely stuck replication
-			// will cause this side to fill up with snapshots.
-			//
-			// However, there are cases where replication progresses and just takes longer,
-			// and we don't want these situations be interrupted by a prune, which will require
-			// re-planning and starting over (think of initial replication as an example).
-			//
-			// Therefore, we prohibit pruning of snapshots that are part of the current replication plan.
-			// If there is no such plan, we kill the replication.
-
-			if j.mode.Type() == TypePush {
-
-				rep := tasks.replication.Report()
-				state, err := replication.StateString(rep.Status)
-				if err != nil {
-					panic(err)
-				}
-
-				switch state {
-				case replication.Planning:
-					fallthrough
-				case replication.PlanningError:
-					fallthrough
-				case replication.WorkingWait:
-					log.WithField("repl_state", state.String()).
-						Info("cancelling replication after new snapshots invalidated its current state")
-					replicationCancel()
-					log.Info("waiting for replication to stop")
-					<-replicationDone // no need to wait for ctx.Done, replication is already bound to global cancel
-					break outer
-				default:
-					log.WithField("repl_state", state.String()).
-						Warn("new snapshots while replication is running and making progress")
-				}
-
-			}
-
+		case <-ctx.Done():
+			return
+		default:
 		}
+		ctx, repCancel := context.WithCancel(ctx)
+		var repWait driver.WaitFunc
+		j.updateTasks(func(tasks *activeSideTasks) {
+			// reset it
+			*tasks = activeSideTasks{}
+			tasks.replicationCancel = repCancel
+			tasks.replicationReport, repWait = replication.Do(
+				ctx, logic.NewPlanner(j.promRepStateSecs, j.promBytesReplicated, sender, receiver),
+			)
+			tasks.state = ActiveSideReplicating
+		})
+		log.Info("start replication")
+		repWait(true) // wait blocking
+		repCancel()   // always cancel to free up context resources
 	}
 
-
-	var pruningWg sync.WaitGroup
-	log.Info("start pruning sender")
-	pruningWg.Add(1)
-	go func() {
-		defer pruningWg.Done()
+	{
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+		ctx, senderCancel := context.WithCancel(ctx)
 		tasks := j.updateTasks(func(tasks *activeSideTasks) {
 			tasks.prunerSender = j.prunerFactory.BuildSenderPruner(ctx, sender, sender)
+			tasks.prunerSenderCancel = senderCancel
+			tasks.state = ActiveSidePruneSender
 		})
+		log.Info("start pruning sender")
 		tasks.prunerSender.Prune()
-		// FIXME no need to do the cancellation dance with sender, we know it's local for push
-		// FIXME and we don't worry about pull ATM
-	}()
-	log.Info("start pruning receiver")
-	pruningWg.Add(1)
-	go func() {
-		defer pruningWg.Done()
-
-		receiverPrunerCtx, receiverPrunerCancel := context.WithCancel(ctx)
-		defer receiverPrunerCancel()
-		tasks := j.updateTasks(func(tasks *activeSideTasks) {
-			tasks.prunerReceiver = j.prunerFactory.BuildReceiverPruner(receiverPrunerCtx, receiver, sender)
-		})
-		receiverPrunerDone := make(chan struct{})
-		go func() {
-			defer close(receiverPrunerDone)
-			tasks.prunerReceiver.Prune()
-		}()
-
-		outer:
-		for {
-			select {
-			case <-receiverPrunerDone:
-				// fine!
-				break outer
-			case <-periodicWakeup:
-				// see comments for similar apporach with replication above
-				if j.mode.Type() == TypePush {
-					rep := tasks.prunerReceiver.Report()
-					state, err := pruner.StateString(rep.State)
-					if err != nil {
-						panic(err)
-					}
-					switch state {
-					case pruner.PlanWait:
-						fallthrough
-					case pruner.ExecWait:
-						log.WithField("pruner_state", state.String()).
-							Info("cancelling failing prune on receiver because new snapshots were taken on sender")
-						receiverPrunerCancel()
-						log.Info("waiting for receiver pruner to stop")
-						<-receiverPrunerDone
-						break outer
-					default:
-						log.WithField("pruner_state", state.String()).
-							Warn("new snapshots while prune on receiver is still running")
-					}
-				}
-			}
+		log.Info("finished pruning sender")
+		senderCancel()
+	}
+	{
+		select {
+		case <-ctx.Done():
+			return
+		default:
 		}
+		ctx, receiverCancel := context.WithCancel(ctx)
+		tasks := j.updateTasks(func(tasks *activeSideTasks) {
+			tasks.prunerReceiver = j.prunerFactory.BuildReceiverPruner(ctx, receiver, sender)
+			tasks.prunerReceiverCancel = receiverCancel
+			tasks.state = ActiveSidePruneReceiver
+		})
+		log.Info("start pruning receiver")
+		tasks.prunerReceiver.Prune()
+		log.Info("finished pruning receiver")
+		receiverCancel()
+	}
 
-	}()
-
-	pruningWg.Wait() // if pruners handle ctx cancellation correctly, we don't need to wait for it here
+	j.updateTasks(func(tasks *activeSideTasks) {
+		tasks.state = ActiveSideDone
+	})
 
 }

daemon/job/activesidestate_enumer.go

@@ -0,0 +1,66 @@
+// Code generated by "enumer -type=ActiveSideState"; DO NOT EDIT.
+
+package job
+
+import (
+	"fmt"
+)
+
+const (
+	_ActiveSideStateName_0 = "ActiveSideReplicatingActiveSidePruneSender"
+	_ActiveSideStateName_1 = "ActiveSidePruneReceiver"
+	_ActiveSideStateName_2 = "ActiveSideDone"
+)
+
+var (
+	_ActiveSideStateIndex_0 = [...]uint8{0, 21, 42}
+	_ActiveSideStateIndex_1 = [...]uint8{0, 23}
+	_ActiveSideStateIndex_2 = [...]uint8{0, 14}
+)
+
+func (i ActiveSideState) String() string {
+	switch {
+	case 1 <= i && i <= 2:
+		i -= 1
+		return _ActiveSideStateName_0[_ActiveSideStateIndex_0[i]:_ActiveSideStateIndex_0[i+1]]
+	case i == 4:
+		return _ActiveSideStateName_1
+	case i == 8:
+		return _ActiveSideStateName_2
+	default:
+		return fmt.Sprintf("ActiveSideState(%d)", i)
+	}
+}
+
+var _ActiveSideStateValues = []ActiveSideState{1, 2, 4, 8}
+
+var _ActiveSideStateNameToValueMap = map[string]ActiveSideState{
+	_ActiveSideStateName_0[0:21]:  1,
+	_ActiveSideStateName_0[21:42]: 2,
+	_ActiveSideStateName_1[0:23]:  4,
+	_ActiveSideStateName_2[0:14]:  8,
+}
+
+// ActiveSideStateString retrieves an enum value from the enum constants string name.
+// Throws an error if the param is not part of the enum.
+func ActiveSideStateString(s string) (ActiveSideState, error) {
+	if val, ok := _ActiveSideStateNameToValueMap[s]; ok {
+		return val, nil
+	}
+	return 0, fmt.Errorf("%s does not belong to ActiveSideState values", s)
+}
+
+// ActiveSideStateValues returns all values of the enum
+func ActiveSideStateValues() []ActiveSideState {
+	return _ActiveSideStateValues
+}
+
+// IsAActiveSideState returns "true" if the value is listed in the enum definition. "false" otherwise
+func (i ActiveSideState) IsAActiveSideState() bool {
+	for _, v := range _ActiveSideStateValues {
+		if i == v {
+			return true
+		}
+	}
+	return false
+}

daemon/job/build_jobs.go

@@ -2,6 +2,9 @@ package job
 
 import (
 	"fmt"
+	"sort"
+	"strings"
+
 	"github.com/pkg/errors"
 	"github.com/zrepl/zrepl/config"
 )
@@ -13,14 +16,33 @@ func JobsFromConfig(c *config.Config) ([]Job, error) {
 		if err != nil {
 			return nil, err
 		}
+		if j == nil || j.Name() == "" {
+			panic(fmt.Sprintf("implementation error: job builder returned nil job type %T", c.Jobs[i].Ret))
+		}
 		js[i] = j
 	}
+
+	// receiving-side root filesystems must not overlap
+	{
+		rfss := make([]string, len(js))
+		for i, j := range js {
+			jrfs, ok := j.OwnedDatasetSubtreeRoot()
+			if !ok {
+				continue
+			}
+			rfss[i] = jrfs.ToString()
+		}
+		if err := validateReceivingSidesDoNotOverlap(rfss); err != nil {
+			return nil, err
+		}
+	}
+
 	return js, nil
 }
 
 func buildJob(c *config.Global, in config.JobEnum) (j Job, err error) {
 	cannotBuildJob := func(e error, name string) (Job, error) {
-		return nil, errors.Wrapf(err, "cannot build job %q", name)
+		return nil, errors.Wrapf(e, "cannot build job %q", name)
 	}
 	// FIXME prettify this
 	switch v := in.Ret.(type) {
@@ -42,6 +64,11 @@ func buildJob(c *config.Global, in config.JobEnum) (j Job, err error) {
 		if err != nil {
 			return cannotBuildJob(err, v.Name)
 		}
+	case *config.SnapJob:
+		j, err = snapJobFromConfig(c, v)
+		if err != nil {
+			return cannotBuildJob(err, v.Name)
+		}
 	case *config.PushJob:
 		m, err := modePushFromConfig(c, v)
 		if err != nil {
@@ -66,3 +93,27 @@ func buildJob(c *config.Global, in config.JobEnum) (j Job, err error) {
 	return j, nil
 
 }
+
+func validateReceivingSidesDoNotOverlap(receivingRootFSs []string) error {
+	if len(receivingRootFSs) == 0 {
+		return nil
+	}
+	rfss := make([]string, len(receivingRootFSs))
+	copy(rfss, receivingRootFSs)
+	sort.Slice(rfss, func(i, j int) bool {
+		return strings.Compare(rfss[i], rfss[j]) == -1
+	})
+	// idea:
+	//   no path in rfss must be prefix of another
+	//
+	// rfss is now lexicographically sorted, which means that
+	// if i is prefix of j, i < j (in lexicographical order)
+	// thus,
+	// if any i is prefix of i+n (n >= 1), there is overlap
+	for i := 0; i < len(rfss)-1; i++ {
+		if strings.HasPrefix(rfss[i+1], rfss[i]) {
+			return fmt.Errorf("receiving jobs with overlapping root filesystems are forbidden")
+		}
+	}
+	return nil
+}

daemon/job/build_jobs_test.go

@@ -0,0 +1,42 @@
+package job
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+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"}},
+		{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)
+		}
+	}
+}

daemon/job/job.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/zrepl/zrepl/logger"
+	"github.com/zrepl/zrepl/zfs"
 )
 
 type Logger = logger.Logger
@@ -33,12 +35,16 @@ type Job interface {
 	Run(ctx context.Context)
 	Status() *Status
 	RegisterMetrics(registerer prometheus.Registerer)
+	// Jobs that return a subtree of the dataset hierarchy
+	// must return the root of that subtree as rfs and ok = true
+	OwnedDatasetSubtreeRoot() (rfs *zfs.DatasetPath, ok bool)
 }
 
 type Type string
 
 const (
 	TypeInternal Type = "internal"
+	TypeSnap Type = "snap"
 	TypePush Type = "push"
 	TypeSink Type = "sink"
 	TypePull Type  = "pull"
@@ -84,6 +90,10 @@ func (s *Status) UnmarshalJSON(in []byte) (err error) {
 		return fmt.Errorf("field '%s', not found", key)
 	}
 	switch s.Type {
+	case TypeSnap:
+		var st SnapJobStatus
+		err = json.Unmarshal(jobJSON, &st)
+		s.JobSpecific = &st
 	case TypePull: fallthrough
 	case TypePush:
 		var st ActiveSideStatus

daemon/job/passive.go

@@ -2,28 +2,30 @@ package job
 
 import (
 	"context"
+	"fmt"
+
 	"github.com/pkg/errors"
-	"github.com/problame/go-streamrpc"
 	"github.com/prometheus/client_golang/prometheus"
+
 	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/daemon/filters"
 	"github.com/zrepl/zrepl/daemon/logging"
-	"github.com/zrepl/zrepl/daemon/transport/serve"
 	"github.com/zrepl/zrepl/daemon/snapper"
 	"github.com/zrepl/zrepl/endpoint"
+	"github.com/zrepl/zrepl/rpc"
+	"github.com/zrepl/zrepl/transport"
+	"github.com/zrepl/zrepl/transport/fromconfig"
 	"github.com/zrepl/zrepl/zfs"
-	"path"
 )
 
 type PassiveSide struct {
-	mode passiveMode
-	name     string
-	l        serve.ListenerFactory
-	rpcConf  *streamrpc.ConnConfig
+	mode   passiveMode
+	name   string
+	listen transport.AuthenticatedListenerFactory
 }
 
 type passiveMode interface {
-	ConnHandleFunc(ctx context.Context, conn serve.AuthenticatedConn) streamrpc.HandlerFunc
+	Handler() rpc.Handler
 	RunPeriodic(ctx context.Context)
 	Type() Type
 }
@@ -34,26 +36,8 @@ type modeSink struct {
 
 func (m *modeSink) Type() Type { return TypeSink }
 
-func (m *modeSink) ConnHandleFunc(ctx context.Context, conn serve.AuthenticatedConn) streamrpc.HandlerFunc {
-	log := GetLogger(ctx)
-
-	clientRootStr := path.Join(m.rootDataset.ToString(), conn.ClientIdentity())
-	clientRoot, err := zfs.NewDatasetPath(clientRootStr)
-	if err != nil {
-		log.WithError(err).
-			WithField("client_identity", conn.ClientIdentity()).
-			Error("cannot build client filesystem map (client identity must be a valid ZFS FS name")
-	}
-	log.WithField("client_root", clientRoot).Debug("client root")
-
-	local, err := endpoint.NewReceiver(clientRoot)
-	if err != nil {
-		log.WithError(err).Error("unexpected error: cannot convert mapping to filter")
-		return nil
-	}
-
-	h := endpoint.NewHandler(local)
-	return h.Handle
+func (m *modeSink) Handler() rpc.Handler {
+	return endpoint.NewReceiver(m.rootDataset, true)
 }
 
 func (m *modeSink) RunPeriodic(_ context.Context) {}
@@ -72,7 +56,7 @@ func modeSinkFromConfig(g *config.Global, in *config.SinkJob) (m *modeSink, err
 
 type modeSource struct {
 	fsfilter zfs.DatasetFilter
-	snapper *snapper.PeriodicOrManual
+	snapper  *snapper.PeriodicOrManual
 }
 
 func modeSourceFromConfig(g *config.Global, in *config.SourceJob) (m *modeSource, err error) {
@@ -93,10 +77,8 @@ func modeSourceFromConfig(g *config.Global, in *config.SourceJob) (m *modeSource
 
 func (m *modeSource) Type() Type { return TypeSource }
 
-func (m *modeSource) ConnHandleFunc(ctx context.Context, conn serve.AuthenticatedConn) streamrpc.HandlerFunc {
-	sender := endpoint.NewSender(m.fsfilter)
-	h := endpoint.NewHandler(sender)
-	return h.Handle
+func (m *modeSource) Handler() rpc.Handler {
+	return endpoint.NewSender(m.fsfilter)
 }
 
 func (m *modeSource) RunPeriodic(ctx context.Context) {
@@ -106,8 +88,8 @@ func (m *modeSource) RunPeriodic(ctx context.Context) {
 func passiveSideFromConfig(g *config.Global, in *config.PassiveJob, mode passiveMode) (s *PassiveSide, err error) {
 
 	s = &PassiveSide{mode: mode, name: in.Name}
-	if s.l, s.rpcConf, err = serve.FromConfig(g, in.Serve); err != nil {
-		return nil, errors.Wrap(err, "cannot build server")
+	if s.listen, err = fromconfig.ListenerFactoryFromConfig(g, in.Serve); err != nil {
+		return nil, errors.Wrap(err, "cannot build listener factory")
 	}
 
 	return s, nil
@@ -115,82 +97,51 @@ func passiveSideFromConfig(g *config.Global, in *config.PassiveJob, mode passive
 
 func (j *PassiveSide) Name() string { return j.name }
 
-type PassiveStatus struct {}
+type PassiveStatus struct{}
 
 func (s *PassiveSide) Status() *Status {
 	return &Status{Type: s.mode.Type()} // FIXME PassiveStatus
 }
 
+func (j *PassiveSide) OwnedDatasetSubtreeRoot() (rfs *zfs.DatasetPath, ok bool) {
+	sink, ok := j.mode.(*modeSink)
+	if !ok {
+		_ = j.mode.(*modeSource) // make sure we didn't introduce a new job type
+		return nil, false
+	}
+	return sink.rootDataset.Copy(), true
+}
+
 func (*PassiveSide) RegisterMetrics(registerer prometheus.Registerer) {}
 
 func (j *PassiveSide) Run(ctx context.Context) {
 
 	log := GetLogger(ctx)
 	defer log.Info("job exiting")
-
-	l, err := j.l.Listen()
-	if err != nil {
-		log.WithError(err).Error("cannot listen")
-		return
-	}
-	defer l.Close()
-
+	ctx = logging.WithSubsystemLoggers(ctx, log)
 	{
-		ctx, cancel := context.WithCancel(logging.WithSubsystemLoggers(ctx, log)) // shadowing
+		ctx, cancel := context.WithCancel(ctx) // shadowing
 		defer cancel()
 		go j.mode.RunPeriodic(ctx)
 	}
 
-	log.WithField("addr", l.Addr()).Debug("accepting connections")
-	var connId int
-outer:
-	for {
-
-		select {
-		case res := <-accept(ctx, l):
-			if res.err != nil {
-				log.WithError(res.err).Info("accept error")
-				continue
-			}
-			conn := res.conn
-			connId++
-			connLog := log.
-				WithField("connID", connId)
-			connLog.
-				WithField("addr", conn.RemoteAddr()).
-				WithField("client_identity", conn.ClientIdentity()).
-				Info("handling connection")
-			go func() {
-				defer connLog.Info("finished handling connection")
-				defer conn.Close()
-				ctx := logging.WithSubsystemLoggers(ctx, connLog)
-				handleFunc := j.mode.ConnHandleFunc(ctx, conn)
-				if handleFunc == nil {
-					return
-				}
-				if err := streamrpc.ServeConn(ctx, conn, j.rpcConf, handleFunc); err != nil {
-					log.WithError(err).Error("error serving client")
-				}
-			}()
-
-		case <-ctx.Done():
-			break outer
-		}
-
+	handler := j.mode.Handler()
+	if handler == nil {
+		panic(fmt.Sprintf("implementation error: j.mode.Handler() returned nil: %#v", j))
 	}
 
-}
+	ctxInterceptor := func(handlerCtx context.Context) context.Context {
+		return logging.WithSubsystemLoggers(handlerCtx, log)
+	}
 
-type acceptResult struct {
-	conn serve.AuthenticatedConn
-	err  error
-}
+	rpcLoggers := rpc.GetLoggersOrPanic(ctx) // WithSubsystemLoggers above
+	server := rpc.NewServer(handler, rpcLoggers, ctxInterceptor)
 
-func accept(ctx context.Context, listener serve.AuthenticatedListener) <-chan acceptResult {
-	c := make(chan acceptResult, 1)
-	go func() {
-		conn, err := listener.Accept(ctx)
-		c <- acceptResult{conn, err}
-	}()
-	return c
+	listener, err := j.listen()
+	if err != nil {
+		log.WithError(err).Error("cannot listen")
+		return
+	}
+
+	server.Serve(ctx, listener)
 }

daemon/job/snapjob.go

@@ -0,0 +1,167 @@
+package job
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/zrepl/zrepl/config"
+	"github.com/zrepl/zrepl/daemon/filters"
+	"github.com/zrepl/zrepl/daemon/job/wakeup"
+	"github.com/zrepl/zrepl/daemon/logging"
+	"github.com/zrepl/zrepl/daemon/pruner"
+	"github.com/zrepl/zrepl/daemon/snapper"
+	"github.com/zrepl/zrepl/endpoint"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
+	"github.com/zrepl/zrepl/zfs"
+)
+
+type SnapJob struct {
+	name     string
+	fsfilter zfs.DatasetFilter
+	snapper  *snapper.PeriodicOrManual
+
+	prunerFactory *pruner.LocalPrunerFactory
+
+	promPruneSecs *prometheus.HistogramVec // labels: prune_side
+
+	pruner *pruner.Pruner
+}
+
+func (j *SnapJob) Name() string { return j.name }
+
+func (j *SnapJob) Type() Type { return TypeSnap }
+
+func snapJobFromConfig(g *config.Global, in *config.SnapJob) (j *SnapJob, err error) {
+	j = &SnapJob{}
+	fsf, err := filters.DatasetMapFilterFromConfig(in.Filesystems)
+	if err != nil {
+		return nil, errors.Wrap(err, "cannnot build filesystem filter")
+	}
+	j.fsfilter = fsf
+
+	if j.snapper, err = snapper.FromConfig(g, fsf, in.Snapshotting); err != nil {
+		return nil, errors.Wrap(err, "cannot build snapper")
+	}
+	j.name = in.Name
+	j.promPruneSecs = prometheus.NewHistogramVec(prometheus.HistogramOpts{
+		Namespace:   "zrepl",
+		Subsystem:   "pruning",
+		Name:        "time",
+		Help:        "seconds spent in pruner",
+		ConstLabels: prometheus.Labels{"zrepl_job": j.name},
+	}, []string{"prune_side"})
+	j.prunerFactory, err = pruner.NewLocalPrunerFactory(in.Pruning, j.promPruneSecs)
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot build snapjob pruning rules")
+	}
+	return j, nil
+}
+
+func (j *SnapJob) RegisterMetrics(registerer prometheus.Registerer) {
+	registerer.MustRegister(j.promPruneSecs)
+}
+
+type SnapJobStatus struct {
+	Pruning *pruner.Report
+}
+
+func (j *SnapJob) Status() *Status {
+	s := &SnapJobStatus{}
+	t := j.Type()
+	if j.pruner != nil {
+		s.Pruning = j.pruner.Report()
+	}
+	return &Status{Type: t, JobSpecific: s}
+}
+
+func (j *SnapJob) OwnedDatasetSubtreeRoot() (rfs *zfs.DatasetPath, ok bool) {
+	return nil, false
+}
+
+func (j *SnapJob) Run(ctx context.Context) {
+	log := GetLogger(ctx)
+	ctx = logging.WithSubsystemLoggers(ctx, log)
+
+	defer log.Info("job exiting")
+
+	periodicDone := make(chan struct{})
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	go j.snapper.Run(ctx, periodicDone)
+
+	invocationCount := 0
+outer:
+	for {
+		log.Info("wait for wakeups")
+		select {
+		case <-ctx.Done():
+			log.WithError(ctx.Err()).Info("context")
+			break outer
+
+		case <-wakeup.Wait(ctx):
+		case <-periodicDone:
+		}
+		invocationCount++
+		invLog := log.WithField("invocation", invocationCount)
+		j.doPrune(WithLogger(ctx, invLog))
+	}
+}
+
+// Adaptor that implements pruner.History around a pruner.Target.
+// The ReplicationCursor method is Get-op only and always returns
+// the filesystem's most recent version's GUID.
+//
+// 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,
+// 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
+// most recent filesystem version.
+type alwaysUpToDateReplicationCursorHistory struct {
+	// the Target passed as Target to BuildLocalPruner
+	target pruner.Target
+}
+
+var _ pruner.History = (*alwaysUpToDateReplicationCursorHistory)(nil)
+
+func (h alwaysUpToDateReplicationCursorHistory) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error) {
+	if req.GetGet() == nil {
+		return nil, fmt.Errorf("unsupported ReplicationCursor request: SnapJob only supports GETting a (faked) cursor")
+	}
+	fsvReq := &pdu.ListFilesystemVersionsReq{
+		Filesystem: req.GetFilesystem(),
+	}
+	res, err := h.target.ListFilesystemVersions(ctx, fsvReq)
+	if err != nil {
+		return nil, err
+	}
+	fsvs := res.GetVersions()
+	if len(fsvs) <= 0 {
+		return &pdu.ReplicationCursorRes{Result: &pdu.ReplicationCursorRes_Notexist{Notexist: true}}, nil
+	}
+	// always return must recent version
+	sort.Slice(fsvs, func(i, j int) bool {
+		return fsvs[i].CreateTXG < fsvs[j].CreateTXG
+	})
+	mostRecent := fsvs[len(fsvs)-1]
+	return &pdu.ReplicationCursorRes{Result: &pdu.ReplicationCursorRes_Guid{Guid: mostRecent.GetGuid()}}, nil
+}
+
+func (h alwaysUpToDateReplicationCursorHistory) ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error) {
+	return h.target.ListFilesystems(ctx, req)
+}
+
+func (j *SnapJob) doPrune(ctx context.Context) {
+	log := GetLogger(ctx)
+	ctx = logging.WithSubsystemLoggers(ctx, log)
+	sender := endpoint.NewSender(j.fsfilter)
+	j.pruner = j.prunerFactory.BuildLocalPruner(ctx, sender, alwaysUpToDateReplicationCursorHistory{sender})
+	log.Info("start pruning")
+	j.pruner.Prune()
+	log.Info("finished pruning")
+}

daemon/logging/adaptors.go

@@ -1,32 +0,0 @@
-package logging
-
-import (
-	"fmt"
-	"github.com/problame/go-streamrpc"
-	"github.com/zrepl/zrepl/logger"
-	"strings"
-)
-
-type streamrpcLogAdaptor = twoClassLogAdaptor
-
-type twoClassLogAdaptor struct {
-	logger.Logger
-}
-
-var _ streamrpc.Logger = twoClassLogAdaptor{}
-
-func (a twoClassLogAdaptor) Errorf(fmtStr string, args ...interface{}) {
-	const errorSuffix = ": %s"
-	if len(args) == 1 {
-		if err, ok := args[0].(error); ok && strings.HasSuffix(fmtStr, errorSuffix) {
-			msg := strings.TrimSuffix(fmtStr, errorSuffix)
-			a.WithError(err).Error(msg)
-			return
-		}
-	}
-	a.Logger.Error(fmt.Sprintf(fmtStr, args...))
-}
-
-func (a twoClassLogAdaptor) Infof(fmtStr string, args ...interface{}) {
-	a.Logger.Debug(fmt.Sprintf(fmtStr, args...))
-}

daemon/logging/build_logging.go

@@ -4,18 +4,23 @@ import (
 	"context"
 	"crypto/tls"
 	"crypto/x509"
+	"log/syslog"
+	"os"
+
 	"github.com/mattn/go-isatty"
 	"github.com/pkg/errors"
-	"github.com/problame/go-streamrpc"
+
 	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/daemon/pruner"
+	"github.com/zrepl/zrepl/daemon/snapper"
 	"github.com/zrepl/zrepl/endpoint"
 	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/replication"
+	"github.com/zrepl/zrepl/replication/driver"
+	"github.com/zrepl/zrepl/replication/logic"
+	"github.com/zrepl/zrepl/rpc"
+	"github.com/zrepl/zrepl/rpc/transportmux"
 	"github.com/zrepl/zrepl/tlsconf"
-	"os"
-	"github.com/zrepl/zrepl/daemon/snapper"
-	"github.com/zrepl/zrepl/daemon/transport/serve"
+	"github.com/zrepl/zrepl/transport"
 )
 
 func OutletsFromConfig(in config.LoggingOutletEnumList) (*logger.Outlets, error) {
@@ -60,22 +65,42 @@ func OutletsFromConfig(in config.LoggingOutletEnumList) (*logger.Outlets, error)
 
 }
 
+type Subsystem string
+
 const (
-	SubsysReplication = "repl"
-	SubsysStreamrpc   = "rpc"
-	SubsyEndpoint     = "endpoint"
+	SubsysReplication  Subsystem = "repl"
+	SubsyEndpoint      Subsystem = "endpoint"
+	SubsysPruning      Subsystem = "pruning"
+	SubsysSnapshot     Subsystem = "snapshot"
+	SubsysTransport    Subsystem = "transport"
+	SubsysTransportMux Subsystem = "transportmux"
+	SubsysRPC          Subsystem = "rpc"
+	SubsysRPCControl   Subsystem = "rpc.ctrl"
+	SubsysRPCData      Subsystem = "rpc.data"
 )
 
 func WithSubsystemLoggers(ctx context.Context, log logger.Logger) context.Context {
-	ctx = replication.WithLogger(ctx, log.WithField(SubsysField, "repl"))
-	ctx = streamrpc.ContextWithLogger(ctx, streamrpcLogAdaptor{log.WithField(SubsysField, "rpc")})
-	ctx = endpoint.WithLogger(ctx, log.WithField(SubsysField, "endpoint"))
-	ctx = pruner.WithLogger(ctx, log.WithField(SubsysField, "pruning"))
-	ctx = snapper.WithLogger(ctx, log.WithField(SubsysField, "snapshot"))
-	ctx = serve.WithLogger(ctx, log.WithField(SubsysField, "serve"))
+	ctx = logic.WithLogger(ctx, log.WithField(SubsysField, SubsysReplication))
+	ctx = driver.WithLogger(ctx, log.WithField(SubsysField, SubsysReplication))
+	ctx = endpoint.WithLogger(ctx, log.WithField(SubsysField, SubsyEndpoint))
+	ctx = pruner.WithLogger(ctx, log.WithField(SubsysField, SubsysPruning))
+	ctx = snapper.WithLogger(ctx, log.WithField(SubsysField, SubsysSnapshot))
+	ctx = transport.WithLogger(ctx, log.WithField(SubsysField, SubsysTransport))
+	ctx = transportmux.WithLogger(ctx, log.WithField(SubsysField, SubsysTransportMux))
+	ctx = rpc.WithLoggers(ctx,
+		rpc.Loggers{
+			General: log.WithField(SubsysField, SubsysRPC),
+			Control: log.WithField(SubsysField, SubsysRPCControl),
+			Data:    log.WithField(SubsysField, SubsysRPCData),
+		},
+	)
 	return ctx
 }
 
+func LogSubsystem(log logger.Logger, subsys Subsystem) logger.Logger {
+	return log.ReplaceField(SubsysField, subsys)
+}
+
 func parseLogFormat(i interface{}) (f EntryFormatter, err error) {
 	var is string
 	switch j := i.(type) {
@@ -200,6 +225,7 @@ func parseSyslogOutlet(in *config.SyslogLoggingOutlet, formatter EntryFormatter)
 	out = &SyslogOutlet{}
 	out.Formatter = formatter
 	out.Formatter.SetMetadataFlags(MetadataNone)
+	out.Facility = syslog.Priority(*in.Facility)
 	out.RetryInterval = in.RetryInterval
 	return out, nil
 }

daemon/logging/logging_outlets.go

@@ -124,6 +124,7 @@ func (h *TCPOutlet) WriteEntry(e logger.Entry) error {
 type SyslogOutlet struct {
 	Formatter          EntryFormatter
 	RetryInterval      time.Duration
+	Facility           syslog.Priority
 	writer             *syslog.Writer
 	lastConnectAttempt time.Time
 }
@@ -142,7 +143,7 @@ func (o *SyslogOutlet) WriteEntry(entry logger.Entry) error {
 		if now.Sub(o.lastConnectAttempt) < o.RetryInterval {
 			return nil // not an error toward logger
 		}
-		o.writer, err = syslog.New(syslog.LOG_LOCAL0, "zrepl")
+		o.writer, err = syslog.New(o.Facility, "zrepl")
 		o.lastConnectAttempt = time.Now()
 		if err != nil {
 			o.writer = nil

daemon/prometheus.go

@@ -7,6 +7,7 @@ import (
 	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/daemon/job"
 	"github.com/zrepl/zrepl/logger"
+	"github.com/zrepl/zrepl/rpc/dataconn/frameconn"
 	"github.com/zrepl/zrepl/zfs"
 	"net"
 	"net/http"
@@ -41,6 +42,8 @@ func (j *prometheusJob) Name() string { return jobNamePrometheus }
 
 func (j *prometheusJob) Status() *job.Status { return &job.Status{Type: job.TypeInternal} }
 
+func (j *prometheusJob) OwnedDatasetSubtreeRoot() (p *zfs.DatasetPath, ok bool) { return nil, false }
+
 func (j *prometheusJob) RegisterMetrics(registerer prometheus.Registerer) {}
 
 func (j *prometheusJob) Run(ctx context.Context) {
@@ -49,6 +52,10 @@ func (j *prometheusJob) Run(ctx context.Context) {
 		panic(err)
 	}
 
+	if err := frameconn.PrometheusRegister(prometheus.DefaultRegisterer); err != nil {
+		panic(err)
+	}
+
 	log := job.GetLogger(ctx)
 
 	l, err := net.Listen("tcp", j.listen)

daemon/pruner/pruner.go

@@ -8,21 +8,24 @@ import (
 	"github.com/zrepl/zrepl/config"
 	"github.com/zrepl/zrepl/logger"
 	"github.com/zrepl/zrepl/pruning"
-	"github.com/zrepl/zrepl/replication/pdu"
-	"net"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
+	"github.com/zrepl/zrepl/util/envconst"
 	"sort"
+	"strings"
 	"sync"
 	"time"
 )
 
-// Try to keep it compatible with gitub.com/zrepl/zrepl/replication.Endpoint
+// Try to keep it compatible with gitub.com/zrepl/zrepl/endpoint.Endpoint
 type History interface {
 	ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error)
+	ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error)
 }
 
+// Try to keep it compatible with gitub.com/zrepl/zrepl/endpoint.Endpoint
 type Target interface {
-	ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error)
-	ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.FilesystemVersion, error) // fix depS
+	ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error)
+	ListFilesystemVersions(ctx context.Context, req *pdu.ListFilesystemVersionsReq) (*pdu.ListFilesystemVersionsRes, error)
 	DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error)
 }
 
@@ -60,13 +63,11 @@ type Pruner struct {
 
 	state State
 
-	// State ErrWait|ErrPerm
-	sleepUntil time.Time
+	// State PlanErr
 	err        error
 
 	// State Exec
-	prunePending   []*fs
-	pruneCompleted []*fs
+	execQueue *execQueue
 }
 
 type PrunerFactory struct {
@@ -77,6 +78,12 @@ type PrunerFactory struct {
 	promPruneSecs *prometheus.HistogramVec
 }
 
+type LocalPrunerFactory struct {
+	keepRules     []pruning.KeepRule
+	retryWait     time.Duration
+	promPruneSecs *prometheus.HistogramVec
+}
+
 func checkContainsKeep1(rules []pruning.KeepRule) error {
 	if len(rules) == 0 {
 		return nil //No keep rules means keep all - ok
@@ -90,6 +97,26 @@ func checkContainsKeep1(rules []pruning.KeepRule) error {
 	return errors.New("sender keep rules must contain last_n or be empty so that the last snapshot is definitely kept")
 }
 
+func NewLocalPrunerFactory(in config.PruningLocal, promPruneSecs *prometheus.HistogramVec) (*LocalPrunerFactory, error) {
+	rules, err := pruning.RulesFromConfig(in.Keep)
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot build pruning rules")
+	}
+	for _, r := range in.Keep {
+		if _, ok := r.Ret.(*config.PruneKeepNotReplicated); ok {
+			// rule NotReplicated  for a local pruner doesn't make sense
+			// because no replication happens with that job type
+			return nil, fmt.Errorf("single-site pruner cannot support `not_replicated` keep rule")
+		}
+	}
+	f := &LocalPrunerFactory{
+		keepRules:     rules,
+		retryWait:     envconst.Duration("ZREPL_PRUNER_RETRY_INTERVAL", 10*time.Second),
+		promPruneSecs: promPruneSecs,
+	}
+	return f, nil
+}
+
 func NewPrunerFactory(in config.PruningSenderReceiver, promPruneSecs *prometheus.HistogramVec) (*PrunerFactory, error) {
 	keepRulesReceiver, err := pruning.RulesFromConfig(in.KeepReceiver)
 	if err != nil {
@@ -110,11 +137,11 @@ func NewPrunerFactory(in config.PruningSenderReceiver, promPruneSecs *prometheus
 		considerSnapAtCursorReplicated = considerSnapAtCursorReplicated || !knr.KeepSnapshotAtCursor
 	}
 	f := &PrunerFactory{
-		keepRulesSender,
-		keepRulesReceiver,
-		10 * time.Second, //FIXME constant
-		considerSnapAtCursorReplicated,
-		promPruneSecs,
+		senderRules: keepRulesSender,
+		receiverRules: keepRulesReceiver,
+		retryWait: envconst.Duration("ZREPL_PRUNER_RETRY_INTERVAL", 10 * time.Second),
+		considerSnapAtCursorReplicated: considerSnapAtCursorReplicated,
+		promPruneSecs: promPruneSecs,
 	}
 	return f, nil
 }
@@ -151,65 +178,64 @@ func (f *PrunerFactory) BuildReceiverPruner(ctx context.Context, target Target,
 	return p
 }
 
+func (f *LocalPrunerFactory) BuildLocalPruner(ctx context.Context, target Target, receiver History) *Pruner {
+	p := &Pruner{
+		args: args{
+			ctx,
+			target,
+			receiver,
+			f.keepRules,
+			f.retryWait,
+			false, // considerSnapAtCursorReplicated is not relevant for local pruning
+			f.promPruneSecs.WithLabelValues("local"),
+		},
+		state: Plan,
+	}
+	return p
+}
+
 //go:generate enumer -type=State
 type State int
 
 const (
 	Plan State = 1 << iota
-	PlanWait
+	PlanErr
 	Exec
-	ExecWait
-	ErrPerm
+	ExecErr
 	Done
 )
 
-func (s State) statefunc() state {
-	var statemap = map[State]state{
-		Plan:     statePlan,
-		PlanWait: statePlanWait,
-		Exec:     stateExec,
-		ExecWait: stateExecWait,
-		ErrPerm:  nil,
-		Done:     nil,
-	}
-	return statemap[s]
-}
-
-type updater func(func(*Pruner)) State
-type state func(args *args, u updater) state
+type updater func(func(*Pruner))
 
 func (p *Pruner) Prune() {
 	p.prune(p.args)
 }
 
 func (p *Pruner) prune(args args) {
-	s := p.state.statefunc()
-	for s != nil {
-		pre := p.state
-		s = s(&args, func(f func(*Pruner)) State {
+	u := func(f func(*Pruner)) {
 			p.mtx.Lock()
 			defer p.mtx.Unlock()
 			f(p)
-			return p.state
-		})
-		post := p.state
-		GetLogger(args.ctx).
-			WithField("transition", fmt.Sprintf("%s=>%s", pre, post)).
-			Debug("state transition")
+		}
+	// TODO support automatic retries
+	// It is advisable to merge this code with package replication/driver before
+	// That will likely require re-modelling struct fs like replication/driver.attempt,
+	// including figuring out how to resume a plan after being interrupted by network errors
+	// The non-retrying code in this package should move straight to replication/logic.
+	doOneAttempt(&args, u)
 	}
-}
 
 type Report struct {
-	State string
-	SleepUntil time.Time
-	Error string
+	State              string
+	Error              string
 	Pending, Completed []FSReport
 }
 
 type FSReport struct {
-	Filesystem string
+	Filesystem                string
 	SnapshotList, DestroyList []SnapshotReport
-	Error string
+	SkipReason                FSSkipReason
+	LastError                 string
 }
 
 type SnapshotReport struct {
@@ -224,34 +250,34 @@ func (p *Pruner) Report() *Report {
 
 	r := Report{State: p.state.String()}
 
-	if p.state & PlanWait|ExecWait != 0 {
-		r.SleepUntil = p.sleepUntil
-	}
-	if p.state & PlanWait|ExecWait|ErrPerm != 0 {
 		if p.err != nil {
 			r.Error = p.err.Error()
 		}
-	}
 
-	if p.state & Plan|PlanWait == 0 {
-		return &r
-	}
-
-	r.Pending = make([]FSReport, len(p.prunePending))
-	for i, fs := range p.prunePending{
-		r.Pending[i] = fs.Report()
-	}
-	r.Completed = make([]FSReport, len(p.pruneCompleted))
-	for i, fs := range p.pruneCompleted{
-		r.Completed[i] = fs.Report()
+	if p.execQueue != nil {
+		r.Pending, r.Completed = p.execQueue.Report()
 	}
 
 	return &r
 }
 
+func (p *Pruner) State() State {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	return p.state
+}
+
 type fs struct {
 	path  string
 
+	// permanent error during planning
+	planErr        error
+	planErrContext string
+
+	// if != "", the fs was skipped for planning and the field
+	// contains the reason
+	skipReason FSSkipReason
+
 	// snapshots presented by target
 	// (type snapshot)
 	snaps []pruning.Snapshot
@@ -260,14 +286,21 @@ type fs struct {
 	destroyList []pruning.Snapshot
 
 	mtx sync.RWMutex
-	// for Plan
-	err error
+
+	// only during Exec state, also used by execQueue
+	execErrLast error
 }
 
-func (f *fs) Update(err error) {
-	f.mtx.Lock()
-	defer f.mtx.Unlock()
-	f.err = err
+type FSSkipReason string
+
+const (
+	NotSkipped                   = ""
+	SkipPlaceholder              = "filesystem is placeholder"
+	SkipNoCorrespondenceOnSender = "filesystem has no correspondence on sender"
+)
+
+func (r FSSkipReason) NotSkipped() bool {
+	return r == NotSkipped
 }
 
 func (f *fs) Report() FSReport {
@@ -276,8 +309,15 @@ func (f *fs) Report() FSReport {
 
 	r := FSReport{}
 	r.Filesystem = f.path
-	if f.err != nil {
-		r.Error = f.err.Error()
+	r.SkipReason = f.skipReason
+	if !r.SkipReason.NotSkipped() {
+		return r
+	}
+
+	if f.planErr != nil {
+		r.LastError = f.planErr.Error()
+	} else  if f.execErrLast != nil {
+		r.LastError = f.execErrLast.Error()
 	}
 
 	r.SnapshotList = make([]SnapshotReport, len(f.snaps))
@@ -315,89 +355,89 @@ func (s snapshot) Replicated() bool { return s.replicated }
 
 func (s snapshot) Date() time.Time { return s.date }
 
-func shouldRetry(e error) bool {
-	switch e.(type) {
-	case nil:
-		return true
-	case net.Error:
-		return true
-	}
-	return false
-}
-
-func onErr(u updater, e error) state {
-	return u(func(p *Pruner) {
-		p.err = e
-		if !shouldRetry(e) {
-			p.state = ErrPerm
-			return
-		}
-		switch p.state {
-		case Plan:
-			p.state = PlanWait
-		case Exec:
-			p.state = ExecWait
-		default:
-			panic(p.state)
-		}
-	}).statefunc()
-}
-
-func statePlan(a *args, u updater) state {
+func doOneAttempt(a *args, u updater) {
 
 	ctx, target, receiver := a.ctx, a.target, a.receiver
 
-	tfss, err := target.ListFilesystems(ctx)
+	sfssres, err := receiver.ListFilesystems(ctx, &pdu.ListFilesystemReq{})
 	if err != nil {
-		return onErr(u, err)
+		u(func(p *Pruner) {
+			p.state = PlanErr
+			p.err = err
+		})
+		return
+	}
+	sfss := make(map[string]*pdu.Filesystem)
+	for _, sfs := range sfssres.GetFilesystems() {
+		sfss[sfs.GetPath()] = sfs
 	}
 
+	tfssres, err := target.ListFilesystems(ctx, &pdu.ListFilesystemReq{})
+	if err != nil {
+		u(func(p *Pruner) {
+			p.state = PlanErr
+			p.err = err
+		})
+		return
+	}
+	tfss := tfssres.GetFilesystems()
+
 	pfss := make([]*fs, len(tfss))
-fsloop:
+tfss_loop:
 	for i, tfs := range tfss {
 
 		l := GetLogger(ctx).WithField("fs", tfs.Path)
 		l.Debug("plan filesystem")
 
-
 		pfs := &fs{
-			path:  tfs.Path,
+			path: tfs.Path,
 		}
 		pfss[i] = pfs
 
-		tfsvs, err := target.ListFilesystemVersions(ctx, tfs.Path)
-		if err != nil {
-			l.WithError(err).Error("cannot list filesystem versions")
-			if shouldRetry(err) {
-				return onErr(u, err)
-			}
-			pfs.err = err
-			continue fsloop
+		if tfs.GetIsPlaceholder() {
+			pfs.skipReason = SkipPlaceholder
+			l.WithField("skip_reason", pfs.skipReason).Debug("skipping filesystem")
+			continue
+		} else if sfs := sfss[tfs.GetPath()]; sfs == nil {
+			pfs.skipReason = SkipNoCorrespondenceOnSender
+			l.WithField("skip_reason", pfs.skipReason).WithField("sfs", sfs.GetPath()).Debug("skipping filesystem")
+			continue
 		}
+
+		pfsPlanErrAndLog := func(err error, message string) {
+			t := fmt.Sprintf("%T", err)
+			pfs.planErr = err
+			pfs.planErrContext = message
+			l.WithField("orig_err_type", t).WithError(err).Error(fmt.Sprintf("%s: plan error, skipping filesystem", message))
+		}
+
+		tfsvsres, err := target.ListFilesystemVersions(ctx, &pdu.ListFilesystemVersionsReq{Filesystem: tfs.Path})
+		if err != nil {
+			pfsPlanErrAndLog(err, "cannot list filesystem versions")
+			continue tfss_loop
+		}
+		tfsvs := tfsvsres.GetVersions()
+		// no progress here since we could run in a live-lock (must have used target AND receiver before progress)
+
 		pfs.snaps = make([]pruning.Snapshot, 0, len(tfsvs))
 
 		rcReq := &pdu.ReplicationCursorReq{
 			Filesystem: tfs.Path,
-			Op:         &pdu.ReplicationCursorReq_Get{
+			Op: &pdu.ReplicationCursorReq_Get{
 				Get: &pdu.ReplicationCursorReq_GetOp{},
 			},
 		}
 		rc, err := receiver.ReplicationCursor(ctx, rcReq)
 		if err != nil {
-			l.WithError(err).Error("cannot get replication cursor")
-			if shouldRetry(err) {
-				return onErr(u, err)
-			}
-			pfs.err = err
-			continue fsloop
+			pfsPlanErrAndLog(err, "cannot get replication cursor bookmark")
+			continue tfss_loop
 		}
-		if rc.GetError() != "" {
-			l.WithField("reqErr", rc.GetError()).Error("cannot get replication cursor")
-			pfs.err = fmt.Errorf("%s", rc.GetError())
-			continue fsloop
+		if rc.GetNotexist() {
+			err := errors.New("replication cursor bookmark does not exist (one successful replication is required before pruning works)")
+			pfsPlanErrAndLog(err, "")
+			continue tfss_loop
 		}
 
-
 		// scan from older to newer, all snapshots older than cursor are interpreted as replicated
 		sort.Slice(tfsvs, func(i, j int) bool {
 			return tfsvs[i].CreateTXG < tfsvs[j].CreateTXG
@@ -419,9 +459,9 @@ fsloop:
 			}
 			creation, err := tfsv.CreationAsTime()
 			if err != nil {
-				pfs.err = fmt.Errorf("%s%s has invalid creation date: %s", tfs, tfsv.RelName(), err)
-				l.WithError(pfs.err).Error("")
-				continue fsloop
+				err := fmt.Errorf("%s: %s", tfsv.RelName(), err)
+				pfsPlanErrAndLog(err, "fs version with invalid creation date")
+				continue tfss_loop
 			}
 			// note that we cannot use CreateTXG because target and receiver could be on different pools
 			atCursor := tfsv.Guid == rc.GetGuid()
@@ -433,48 +473,63 @@ fsloop:
 			})
 		}
 		if preCursor {
-			pfs.err = fmt.Errorf("replication cursor not found in prune target filesystem versions")
-			l.WithError(pfs.err).Error("")
-			continue fsloop
+			pfsPlanErrAndLog(fmt.Errorf("replication cursor not found in prune target filesystem versions"), "")
+			continue tfss_loop
 		}
 
 		// Apply prune rules
 		pfs.destroyList = pruning.PruneSnapshots(pfs.snaps, a.rules)
-
 	}
 
-	return u(func(pruner *Pruner) {
+	u(func(pruner *Pruner) {
+		pruner.execQueue = newExecQueue(len(pfss))
 		for _, pfs := range pfss {
-			if pfs.err != nil {
-				pruner.pruneCompleted = append(pruner.pruneCompleted, pfs)
-			} else {
-				pruner.prunePending = append(pruner.prunePending, pfs)
-			}
+			pruner.execQueue.Put(pfs, nil, false)
 		}
 		pruner.state = Exec
-	}).statefunc()
-}
-
-func stateExec(a *args, u updater) state {
-
-	var pfs *fs
-	state := u(func(pruner *Pruner) {
-		if len(pruner.prunePending) == 0 {
-			nextState := Done
-			for _, pfs := range pruner.pruneCompleted {
-				if pfs.err != nil {
-					nextState = ErrPerm
-				}
-			}
-			pruner.state = nextState
-			return
-		}
-		pfs = pruner.prunePending[0]
 	})
-	if state != Exec {
-		return state.statefunc()
+
+	for {
+	var pfs *fs
+		u(func(pruner *Pruner) {
+		pfs = pruner.execQueue.Pop()
+		})
+		if pfs == nil {
+			break
+		}
+		doOneAttemptExec(a, u, pfs)
 	}
 
+	var rep *Report
+	{
+		// must not hold lock for report
+		var pruner *Pruner
+		u(func(p *Pruner) {
+			pruner = p
+		})
+		rep = pruner.Report()
+	}
+	u(func(p *Pruner) {
+		if len(rep.Pending) > 0 {
+			panic("queue should not have pending items at this point")
+		}
+		hadErr := false
+		for _, fsr := range rep.Completed {
+			hadErr = hadErr || fsr.SkipReason.NotSkipped() && fsr.LastError != ""
+			}
+		if hadErr {
+			p.state = ExecErr
+		} else {
+			p.state = Done
+		}
+	})
+	
+
+	}
+
+// attempts to exec pfs, puts it back into the queue with the result
+func doOneAttemptExec(a *args, u updater, pfs *fs) {
+
 	destroyList := make([]*pdu.FilesystemVersion, len(pfs.destroyList))
 	for i := range destroyList {
 		destroyList[i] = pfs.destroyList[i].(snapshot).fsv
@@ -483,41 +538,57 @@ func stateExec(a *args, u updater) state {
 			WithField("destroy_snap", destroyList[i].Name).
 			Debug("policy destroys snapshot")
 	}
-	pfs.Update(nil)
 	req := pdu.DestroySnapshotsReq{
 		Filesystem: pfs.path,
 		Snapshots:  destroyList,
 	}
-	_, err := a.target.DestroySnapshots(a.ctx, &req)
-	pfs.Update(err)
-	if err != nil && shouldRetry(err) {
-		return onErr(u, err)
+	GetLogger(a.ctx).WithField("fs", pfs.path).Debug("destroying snapshots")
+	res, err := a.target.DestroySnapshots(a.ctx, &req)
+	if err != nil {
+		u(func(pruner *Pruner) {
+			pruner.execQueue.Put(pfs, err, false)
+		})
+		return
 	}
-	// if it's not retryable, treat is like as being done
-
-	return u(func(pruner *Pruner) {
-		pruner.pruneCompleted = append(pruner.pruneCompleted, pfs)
-		pruner.prunePending = pruner.prunePending[1:]
-	}).statefunc()
-}
-
-func stateExecWait(a *args, u updater) state {
-	return doWait(Exec, a, u)
-}
-
-func statePlanWait(a *args, u updater) state {
-	return doWait(Plan, a, u)
-}
-
-func doWait(goback State, a *args, u updater) state {
-	timer := time.NewTimer(a.retryWait)
-	defer timer.Stop()
-	select {
-	case <-timer.C:
-		return u(func(pruner *Pruner) {
-			pruner.state = goback
-		}).statefunc()
-	case <-a.ctx.Done():
-		return onErr(u, a.ctx.Err())
+	// check if all snapshots were destroyed
+	destroyResults := make(map[string]*pdu.DestroySnapshotRes)
+	for _, fsres := range res.Results {
+		destroyResults[fsres.Snapshot.Name] = fsres
+	}
+	err = nil
+	destroyFails := make([]*pdu.DestroySnapshotRes, 0)
+	for _, reqDestroy := range destroyList {
+		 res, ok := destroyResults[reqDestroy.Name]
+		 if !ok {
+		 	err = fmt.Errorf("missing destroy-result for %s", reqDestroy.RelName())
+		 	break
+		 } else if res.Error != "" {
+		 	destroyFails = append(destroyFails, res)
+		 }
+	}
+	if err == nil && len(destroyFails) > 0 {
+		names := make([]string, len(destroyFails))
+		pairs := make([]string, len(destroyFails))
+		allSame := true
+		lastMsg := destroyFails[0].Error
+		for i := 0; i < len(destroyFails); i++{
+			allSame = allSame && destroyFails[i].Error == lastMsg
+			relname := destroyFails[i].Snapshot.RelName()
+			names[i] = relname
+			pairs[i] = fmt.Sprintf("(%s: %s)", relname, destroyFails[i].Error)
+		}
+		if allSame {
+			err = fmt.Errorf("destroys failed %s: %s",
+				strings.Join(names, ", "), lastMsg)
+		} else {
+			err = fmt.Errorf("destroys failed: %s", strings.Join(pairs, ", "))
+		}
+	}
+	u(func(pruner *Pruner) {
+		pruner.execQueue.Put(pfs, err, err == nil)
+	})
+	if err != nil {
+		GetLogger(a.ctx).WithError(err).Error("target could not destroy snapshots")
+		return
 	}
 }

daemon/pruner/pruner_queue.go

@@ -0,0 +1,83 @@
+package pruner
+
+import (
+	"sort"
+	"strings"
+	"sync"
+)
+
+type execQueue struct {
+	mtx sync.Mutex
+	pending, completed []*fs
+}
+
+func newExecQueue(cap int) *execQueue {
+	q := execQueue{
+		pending: make([]*fs, 0, cap),
+		completed: make([]*fs, 0, cap),
+	}
+	return &q
+}
+
+func (q *execQueue) Report() (pending, completed []FSReport) {
+	q.mtx.Lock()
+	defer q.mtx.Unlock()
+
+	pending = make([]FSReport, len(q.pending))
+	for i, fs := range q.pending {
+		pending[i] = fs.Report()
+	}
+	completed = make([]FSReport, len(q.completed))
+	for i, fs := range q.completed {
+		completed[i] = fs.Report()
+	}
+
+	return pending, completed
+}
+
+func (q *execQueue) HasCompletedFSWithErrors() bool {
+	q.mtx.Lock()
+	defer q.mtx.Unlock()
+	for _, fs := range q.completed {
+		if fs.execErrLast != nil {
+			return true
+		}
+	}
+	return false
+}
+
+func (q *execQueue) Pop() *fs {
+	if len(q.pending) == 0 {
+		return nil
+	}
+	fs := q.pending[0]
+	q.pending = q.pending[1:]
+	return fs
+}
+
+func(q *execQueue) Put(fs *fs, err error, done bool) {
+	fs.mtx.Lock()
+	fs.execErrLast = err
+	if done || err != nil {
+		fs.mtx.Unlock()
+		q.mtx.Lock()
+		q.completed = append(q.completed, fs)
+		q.mtx.Unlock()
+		return
+	}
+	fs.mtx.Unlock()
+
+	q.mtx.Lock()
+	// inefficient priority q
+	q.pending = append(q.pending, fs)
+	sort.SliceStable(q.pending, func(i, j int) bool {
+		q.pending[i].mtx.Lock()
+		defer q.pending[i].mtx.Unlock()
+		q.pending[j].mtx.Lock()
+		defer q.pending[j].mtx.Unlock()
+		return strings.Compare(q.pending[i].path, q.pending[j].path) == -1
+	})
+	q.mtx.Unlock()
+
+
+}

daemon/pruner/pruner_test.go

@@ -1,211 +0,0 @@
-package pruner
-
-import (
-	"context"
-	"fmt"
-	"github.com/stretchr/testify/assert"
-	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/pruning"
-	"github.com/zrepl/zrepl/replication/pdu"
-	"net"
-	"testing"
-	"time"
-)
-
-type mockFS struct {
-	path  string
-	snaps []string
-}
-
-func (m *mockFS) Filesystem() *pdu.Filesystem {
-	return &pdu.Filesystem{
-		Path: m.path,
-	}
-}
-
-func (m *mockFS) FilesystemVersions() []*pdu.FilesystemVersion {
-	versions := make([]*pdu.FilesystemVersion, len(m.snaps))
-	for i, v := range m.snaps {
-		versions[i] = &pdu.FilesystemVersion{
-			Type:     pdu.FilesystemVersion_Snapshot,
-			Name:     v,
-			Creation: pdu.FilesystemVersionCreation(time.Unix(0, 0)),
-			Guid: uint64(i),
-		}
-	}
-	return versions
-}
-
-type mockTarget struct {
-	fss                []mockFS
-	destroyed          map[string][]string
-	listVersionsErrs   map[string][]error
-	listFilesystemsErr []error
-	destroyErrs        map[string][]error
-}
-
-func (t *mockTarget) ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error) {
-	if len(t.listFilesystemsErr) > 0 {
-		e := t.listFilesystemsErr[0]
-		t.listFilesystemsErr = t.listFilesystemsErr[1:]
-		return nil, e
-	}
-	fss := make([]*pdu.Filesystem, len(t.fss))
-	for i := range fss {
-		fss[i] = t.fss[i].Filesystem()
-	}
-	return fss, nil
-}
-
-func (t *mockTarget) ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.FilesystemVersion, error) {
-	if len(t.listVersionsErrs[fs]) != 0 {
-		e := t.listVersionsErrs[fs][0]
-		t.listVersionsErrs[fs] = t.listVersionsErrs[fs][1:]
-		return nil, e
-	}
-
-	for _, mfs := range t.fss {
-		if mfs.path != fs {
-			continue
-		}
-		return mfs.FilesystemVersions(), nil
-	}
-	return nil, fmt.Errorf("filesystem %s does not exist", fs)
-}
-
-func (t *mockTarget) DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error) {
-	fs, snaps := req.Filesystem, req.Snapshots
-	if len(t.destroyErrs[fs]) != 0 {
-		e := t.destroyErrs[fs][0]
-		t.destroyErrs[fs] = t.destroyErrs[fs][1:]
-		return nil, e
-	}
-	destroyed := t.destroyed[fs]
-	res := make([]*pdu.DestroySnapshotRes, len(snaps))
-	for i, s := range snaps {
-		destroyed = append(destroyed, s.Name)
-		res[i] = &pdu.DestroySnapshotRes{Error: "", Snapshot: s}
-	}
-	t.destroyed[fs] = destroyed
-	return &pdu.DestroySnapshotsRes{Results: res}, nil
-}
-
-type mockCursor struct {
-	snapname string
-	guid uint64
-}
-type mockHistory struct {
-	errs map[string][]error
-	cursors map[string]*mockCursor
-}
-
-func (r *mockHistory) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error) {
-	fs := req.Filesystem
-	if len(r.errs[fs]) > 0 {
-		e := r.errs[fs][0]
-		r.errs[fs] = r.errs[fs][1:]
-		return nil, e
-	}
-	return &pdu.ReplicationCursorRes{Result: &pdu.ReplicationCursorRes_Guid{Guid: 0}}, nil
-}
-
-type stubNetErr struct {
-	msg string
-	temporary, timeout bool
-}
-
-var _ net.Error = stubNetErr{}
-
-func (e stubNetErr) Error() string {
-	return e.msg
-}
-
-func (e stubNetErr) Temporary() bool { return e.temporary }
-
-func (e stubNetErr) Timeout() bool { return e.timeout }
-
-func TestPruner_Prune(t *testing.T) {
-
-	var _ net.Error = &net.OpError{} // we use it below
-	target := &mockTarget{
-		listFilesystemsErr: []error{
-			stubNetErr{msg: "fakerror0"},
-		},
-		listVersionsErrs: map[string][]error{
-			"zroot/foo": {
-				stubNetErr{msg: "fakeerror1"}, // should be classified as temporaty
-				stubNetErr{msg: "fakeerror2"},
-			},
-		},
-		destroyErrs: map[string][]error{
-			"zroot/foo": {
-				fmt.Errorf("permanent error"),
-			},
-			"zroot/bar": {
-				stubNetErr{msg: "fakeerror3"},
-			},
-		},
-		destroyed: make(map[string][]string),
-		fss: []mockFS{
-			{
-				path: "zroot/foo",
-				snaps: []string{
-					"keep_a",
-					"keep_b",
-					"drop_c",
-					"keep_d",
-				},
-			},
-			{
-				path: "zroot/bar",
-				snaps: []string{
-					"keep_e",
-					"keep_f",
-					"drop_g",
-				},
-			},
-			{
-				path: "zroot/baz",
-				snaps: []string{
-					"keep_h",
-					"drop_i",
-				},
-			},
-		},
-	}
-	history := &mockHistory{
-		errs: map[string][]error{
-			"zroot/foo": {
-				stubNetErr{msg: "fakeerror4"},
-			},
-			"zroot/baz": {
-				fmt.Errorf("permanent error2"),
-			},
-		},
-	}
-
-	keepRules := []pruning.KeepRule{pruning.MustKeepRegex("^keep")}
-
-	p := Pruner{
-		args: args{
-			ctx: WithLogger(context.Background(), logger.NewTestLogger(t)),
-			target: target,
-			receiver: history,
-			rules: keepRules,
-			retryWait: 10*time.Millisecond,
-		},
-		state: Plan,
-	}
-	p.Prune()
-
-	exp := map[string][]string{
-		"zroot/bar": {"drop_g"},
-		// drop_c is prohibited by failing destroy
-		// drop_i is prohibiteed by failing ReplicationCursor call
-	}
-
-	assert.Equal(t, exp, target.destroyed)
-
-	//assert.Equal(t, map[string][]error{}, target.listVersionsErrs, "retried")
-
-}

daemon/pruner/state_enumer.go

@@ -7,19 +7,17 @@ import (
 )
 
 const (
-	_StateName_0 = "PlanPlanWait"
+	_StateName_0 = "PlanPlanErr"
 	_StateName_1 = "Exec"
-	_StateName_2 = "ExecWait"
-	_StateName_3 = "ErrPerm"
-	_StateName_4 = "Done"
+	_StateName_2 = "ExecErr"
+	_StateName_3 = "Done"
 )
 
 var (
-	_StateIndex_0 = [...]uint8{0, 4, 12}
+	_StateIndex_0 = [...]uint8{0, 4, 11}
 	_StateIndex_1 = [...]uint8{0, 4}
-	_StateIndex_2 = [...]uint8{0, 8}
-	_StateIndex_3 = [...]uint8{0, 7}
-	_StateIndex_4 = [...]uint8{0, 4}
+	_StateIndex_2 = [...]uint8{0, 7}
+	_StateIndex_3 = [...]uint8{0, 4}
 )
 
 func (i State) String() string {
@@ -33,22 +31,19 @@ func (i State) String() string {
 		return _StateName_2
 	case i == 16:
 		return _StateName_3
-	case i == 32:
-		return _StateName_4
 	default:
 		return fmt.Sprintf("State(%d)", i)
 	}
 }
 
-var _StateValues = []State{1, 2, 4, 8, 16, 32}
+var _StateValues = []State{1, 2, 4, 8, 16}
 
 var _StateNameToValueMap = map[string]State{
 	_StateName_0[0:4]:  1,
-	_StateName_0[4:12]: 2,
+	_StateName_0[4:11]: 2,
 	_StateName_1[0:4]:  4,
-	_StateName_2[0:8]:  8,
-	_StateName_3[0:7]:  16,
-	_StateName_4[0:4]:  32,
+	_StateName_2[0:7]:  8,
+	_StateName_3[0:4]:  16,
 }
 
 // StateString retrieves an enum value from the enum constants string name.

daemon/snapper/snapper.go

@@ -71,6 +71,7 @@ type State uint
 
 const (
 	SyncUp State = 1<<iota
+	SyncUpErrWait
 	Planning
 	Snapshotting
 	Waiting
@@ -81,6 +82,7 @@ const (
 func (s State) sf() state {
 	m := map[State]state{
 		SyncUp:       syncUp,
+		SyncUpErrWait: wait,
 		Planning:     plan,
 		Snapshotting: snapshot,
 		Waiting:      wait,
@@ -165,7 +167,16 @@ func (s *Snapper) Run(ctx context.Context, snapshotsTaken chan<- struct{}) {
 func onErr(err error, u updater) state {
 	return u(func(s *Snapper) {
 		s.err = err
-		s.state = ErrorWait
+		preState := s.state
+		switch s.state {
+		case SyncUp:
+			s.state = SyncUpErrWait
+		case Planning:
+			fallthrough
+		case Snapshotting:
+			s.state = ErrorWait
+		}
+		s.args.log.WithError(err).WithField("pre_state", preState).WithField("post_state", s.state).Error("snapshotting error")
 	}).sf()
 }
 
@@ -177,7 +188,10 @@ func onMainCtxDone(ctx context.Context, u updater) state {
 }
 
 func syncUp(a args, u updater) state {
-	fss, err := listFSes(a.fsf)
+	u(func(snapper *Snapper) {
+		snapper.lastInvocation = time.Now()
+	})
+	fss, err := listFSes(a.ctx, a.fsf)
 	if err != nil {
 		return onErr(err, u)
 	}
@@ -204,7 +218,7 @@ func plan(a args, u updater) state {
 	u(func(snapper *Snapper) {
 		snapper.lastInvocation = time.Now()
 	})
-	fss, err := listFSes(a.fsf)
+	fss, err := listFSes(a.ctx, a.fsf)
 	if err != nil {
 		return onErr(err, u)
 	}
@@ -284,6 +298,12 @@ func wait(a args, u updater) state {
 		lastTick := snapper.lastInvocation
 		snapper.sleepUntil = lastTick.Add(a.interval)
 		sleepUntil = snapper.sleepUntil
+		log := a.log.WithField("sleep_until", sleepUntil).WithField("duration", a.interval)
+		logFunc := log.Debug
+		if snapper.state == ErrorWait || snapper.state == SyncUpErrWait {
+			logFunc = log.Error
+		}
+		logFunc("enter wait-state after error")
 	})
 
 	t := time.NewTimer(sleepUntil.Sub(time.Now()))
@@ -299,8 +319,8 @@ func wait(a args, u updater) state {
 	}
 }
 
-func listFSes(mf *filters.DatasetMapFilter) (fss []*zfs.DatasetPath, err error) {
-	return zfs.ZFSListMapping(mf)
+func listFSes(ctx context.Context, mf *filters.DatasetMapFilter) (fss []*zfs.DatasetPath, err error) {
+	return zfs.ZFSListMapping(ctx, mf)
 }
 
 func findSyncPoint(log Logger, fss []*zfs.DatasetPath, prefix string, interval time.Duration) (syncPoint time.Time, err error) {

daemon/snapper/state_string.go

@@ -5,15 +5,16 @@ package snapper
 import "strconv"
 
 const (
-	_State_name_0 = "SyncUpPlanning"
-	_State_name_1 = "Snapshotting"
-	_State_name_2 = "Waiting"
-	_State_name_3 = "ErrorWait"
-	_State_name_4 = "Stopped"
+	_State_name_0 = "SyncUpSyncUpErrWait"
+	_State_name_1 = "Planning"
+	_State_name_2 = "Snapshotting"
+	_State_name_3 = "Waiting"
+	_State_name_4 = "ErrorWait"
+	_State_name_5 = "Stopped"
 )
 
 var (
-	_State_index_0 = [...]uint8{0, 6, 14}
+	_State_index_0 = [...]uint8{0, 6, 19}
 )
 
 func (i State) String() string {
@@ -29,6 +30,8 @@ func (i State) String() string {
 		return _State_name_3
 	case i == 32:
 		return _State_name_4
+	case i == 64:
+		return _State_name_5
 	default:
 		return "State(" + strconv.FormatInt(int64(i), 10) + ")"
 	}

daemon/streamrpcconfig/streamrpcconfig.go

@@ -1,25 +0,0 @@
-package streamrpcconfig
-
-import (
-	"github.com/problame/go-streamrpc"
-	"github.com/zrepl/zrepl/config"
-)
-
-func FromDaemonConfig(g *config.Global, in *config.RPCConfig) (*streamrpc.ConnConfig, error) {
-	conf := in
-	if conf == nil {
-		conf = g.RPC
-	}
-	srpcConf := &streamrpc.ConnConfig{
-		RxHeaderMaxLen:       conf.RxHeaderMaxLen,
-		RxStructuredMaxLen:   conf.RxStructuredMaxLen,
-		RxStreamMaxChunkSize: conf.RxStreamChunkMaxLen,
-		TxChunkSize:          conf.TxChunkSize,
-		Timeout: 			  conf.Timeout,
-		SendHeartbeatInterval: conf.SendHeartbeatInterval,
-	}
-	if err := srpcConf.Validate(); err != nil {
-		return nil, err
-	}
-	return srpcConf, nil
-}

daemon/transport/connecter/connecter.go

@@ -1,84 +0,0 @@
-package connecter
-
-import (
-	"context"
-	"fmt"
-	"github.com/problame/go-streamrpc"
-	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon/streamrpcconfig"
-	"github.com/zrepl/zrepl/daemon/transport"
-	"net"
-	"time"
-)
-
-
-type HandshakeConnecter struct {
-	connecter streamrpc.Connecter
-}
-
-func (c HandshakeConnecter) Connect(ctx context.Context) (net.Conn, error) {
-	conn, err := c.connecter.Connect(ctx)
-	if err != nil {
-		return nil, err
-	}
-	dl, ok := ctx.Deadline()
-	if !ok {
-		dl = time.Now().Add(10 * time.Second) // FIXME constant
-	}
-	if err := transport.DoHandshakeCurrentVersion(conn, dl); err != nil {
-		conn.Close()
-		return nil, err
-	}
-	return conn, nil
-}
-
-
-
-func FromConfig(g *config.Global, in config.ConnectEnum) (*ClientFactory, error) {
-	var (
-		connecter            streamrpc.Connecter
-		errConnecter, errRPC error
-		connConf             *streamrpc.ConnConfig
-	)
-	switch v := in.Ret.(type) {
-	case *config.SSHStdinserverConnect:
-		connecter, errConnecter = SSHStdinserverConnecterFromConfig(v)
-		connConf, errRPC = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	case *config.TCPConnect:
-		connecter, errConnecter = TCPConnecterFromConfig(v)
-		connConf, errRPC = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	case *config.TLSConnect:
-		connecter, errConnecter = TLSConnecterFromConfig(v)
-		connConf, errRPC = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	case *config.LocalConnect:
-		connecter, errConnecter = LocalConnecterFromConfig(v)
-		connConf, errRPC = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	default:
-		panic(fmt.Sprintf("implementation error: unknown connecter type %T", v))
-	}
-
-	if errConnecter != nil {
-		return nil, errConnecter
-	}
-	if errRPC != nil {
-		return nil, errRPC
-	}
-
-	config := streamrpc.ClientConfig{ConnConfig: connConf}
-	if err := config.Validate(); err != nil {
-		return nil, err
-	}
-
-	connecter = HandshakeConnecter{connecter}
-
-	return &ClientFactory{connecter: connecter, config: &config}, nil
-}
-
-type ClientFactory struct {
-	connecter streamrpc.Connecter
-	config    *streamrpc.ClientConfig
-}
-
-func (f ClientFactory) NewClient() (*streamrpc.Client, error) {
-	return streamrpc.NewClient(f.connecter, f.config)
-}

daemon/transport/handshake.go

@@ -1,136 +0,0 @@
-package transport
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"net"
-	"strings"
-	"time"
-	"unicode/utf8"
-)
-
-type HandshakeMessage struct {
-	ProtocolVersion int
-	Extensions []string
-}
-
-func (m *HandshakeMessage) Encode() ([]byte, error) {
-	if m.ProtocolVersion <= 0 || m.ProtocolVersion > 9999 {
-		return nil, fmt.Errorf("protocol version must be in [1, 9999]")
-	}
-	if len(m.Extensions) >= 9999 {
-		return nil, fmt.Errorf("protocol only supports [0, 9999] extensions")
-	}
-	// EXTENSIONS is a count of subsequent \n separated lines that contain protocol extensions
-	var extensions strings.Builder
-	for i, ext := range m.Extensions {
-		if strings.ContainsAny(ext, "\n") {
-			return nil, fmt.Errorf("Extension #%d contains forbidden newline character", i)
-		}
-		if !utf8.ValidString(ext) {
-			return nil, fmt.Errorf("Extension #%d is not valid UTF-8", i)
-		}
-		extensions.WriteString(ext)
-		extensions.WriteString("\n")
-	}
-	withoutLen := fmt.Sprintf("ZREPL_ZFS_REPLICATION PROTOVERSION=%04d EXTENSIONS=%04d\n%s",
-		m.ProtocolVersion, len(m.Extensions), extensions.String())
-	withLen := fmt.Sprintf("%010d %s", len(withoutLen), withoutLen)
-	return []byte(withLen), nil
-}
-
-func (m *HandshakeMessage) DecodeReader(r io.Reader, maxLen int) error {
-	var lenAndSpace [11]byte
-	if _, err := io.ReadFull(r, lenAndSpace[:]); err != nil {
-		return err
-	}
-	if !utf8.Valid(lenAndSpace[:]) {
-		return fmt.Errorf("invalid start of handshake message: not valid UTF-8")
-	}
-	var followLen int
-	n, err := fmt.Sscanf(string(lenAndSpace[:]), "%010d ", &followLen)
-	if n != 1 || err != nil {
-		return fmt.Errorf("could not parse handshake message length")
-	}
-	if followLen > maxLen {
-		return fmt.Errorf("handshake message length exceeds max length (%d vs %d)",
-			followLen, maxLen)
-	}
-
-	var buf bytes.Buffer
-	_, err = io.Copy(&buf, io.LimitReader(r, int64(followLen)))
-	if err != nil {
-		return err
-	}
-
-	var (
-		protoVersion, extensionCount int
-	)
-	n, err = fmt.Fscanf(&buf, "ZREPL_ZFS_REPLICATION PROTOVERSION=%04d EXTENSIONS=%4d\n",
-		&protoVersion, &extensionCount)
-	if n != 2 || err != nil {
-		return fmt.Errorf("could not parse handshake message: %s", err)
-	}
-	if protoVersion < 1 {
-		return fmt.Errorf("invalid protocol version %q", protoVersion)
-	}
-	m.ProtocolVersion = protoVersion
-
-	if extensionCount < 0 {
-		return fmt.Errorf("invalid extension count %q", extensionCount)
-	}
-	if extensionCount == 0 {
-		if buf.Len() != 0 {
-			return fmt.Errorf("unexpected data trailing after header")
-		}
-		m.Extensions = nil
-		return nil
-	}
-	s := buf.String()
-	if strings.Count(s, "\n") != extensionCount {
-		return fmt.Errorf("inconsistent extension count: found %d, header says %d", len(m.Extensions), extensionCount)
-	}
-	exts := strings.Split(s, "\n")
-	if exts[len(exts)-1] != "" {
-		return fmt.Errorf("unexpected data trailing after last extension newline")
-	}
-	m.Extensions = exts[0:len(exts)-1]
-
-	return nil
-}
-
-func DoHandshakeCurrentVersion(conn net.Conn, deadline time.Time) error {
-	// current protocol version is hardcoded here
-	return DoHandshakeVersion(conn, deadline, 1)
-}
-
-func DoHandshakeVersion(conn net.Conn, deadline time.Time, version int) error {
-	ours := HandshakeMessage{
-		ProtocolVersion: version,
-		Extensions: nil,
-	}
-	hsb, err := ours.Encode()
-	if err != nil {
-		return fmt.Errorf("could not encode protocol banner: %s", err)
-	}
-
-	conn.SetDeadline(deadline)
-	_, err = io.Copy(conn, bytes.NewBuffer(hsb))
-	if err != nil {
-		return fmt.Errorf("could not send protocol banner: %s", err)
-	}
-
-	theirs := HandshakeMessage{}
-	if err := theirs.DecodeReader(conn, 16 * 4096); err != nil { // FIXME constant
-		return fmt.Errorf("could not decode protocol banner: %s", err)
-	}
-
-	if theirs.ProtocolVersion != ours.ProtocolVersion {
-		return fmt.Errorf("protocol versions do not match: ours is %d, theirs is %d",
-			ours.ProtocolVersion, theirs.ProtocolVersion)
-	}
-	// ignore extensions, we don't use them
-
-	return nil
-}

daemon/transport/serve/serve.go

@@ -1,147 +0,0 @@
-package serve
-
-import (
-	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/daemon/transport"
-	"net"
-	"github.com/zrepl/zrepl/daemon/streamrpcconfig"
-	"github.com/problame/go-streamrpc"
-	"context"
-	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/zfs"
-	"time"
-)
-
-type contextKey int
-
-const contextKeyLog contextKey = 0
-
-type Logger = logger.Logger
-
-func WithLogger(ctx context.Context, log Logger) context.Context {
-	return context.WithValue(ctx, contextKeyLog, log)
-}
-
-func getLogger(ctx context.Context) Logger {
-	if log, ok := ctx.Value(contextKeyLog).(Logger); ok {
-		return log
-	}
-	return logger.NewNullLogger()
-}
-
-type AuthenticatedConn interface {
-	net.Conn
-	// ClientIdentity must be a string that satisfies ValidateClientIdentity
-	ClientIdentity() string
-}
-
-// A client identity must be a single component in a ZFS filesystem path
-func ValidateClientIdentity(in string) (err error) {
-	path, err := zfs.NewDatasetPath(in)
-	if err != nil {
-		return err
-	}
-	if path.Length() != 1 {
-		return errors.New("client identity must be a single path comonent (not empty, no '/')")
-	}
-	return nil
-}
-
-type authConn struct {
-	net.Conn
-	clientIdentity string
-}
-
-var _ AuthenticatedConn = authConn{}
-
-func (c authConn) ClientIdentity() string {
-	if err := ValidateClientIdentity(c.clientIdentity); err != nil {
-		panic(err)
-	}
-	return c.clientIdentity
-}
-
-// like net.Listener, but with an AuthenticatedConn instead of net.Conn
-type AuthenticatedListener interface {
-	Addr() (net.Addr)
-	Accept(ctx context.Context) (AuthenticatedConn, error)
-	Close() error
-}
-
-type ListenerFactory interface {
-	Listen() (AuthenticatedListener, error)
-}
-
-type HandshakeListenerFactory struct {
-	lf ListenerFactory
-}
-
-func (lf HandshakeListenerFactory) Listen() (AuthenticatedListener, error) {
-	l, err := lf.lf.Listen()
-	if err != nil {
-		return nil, err
-	}
-	return HandshakeListener{l}, nil
-}
-
-type HandshakeListener struct {
-	l AuthenticatedListener
-}
-
-func (l HandshakeListener) Addr() (net.Addr) { return l.l.Addr() }
-
-func (l HandshakeListener) Close() error { return l.l.Close() }
-
-func (l HandshakeListener) Accept(ctx context.Context) (AuthenticatedConn, error) {
-	conn, err := l.l.Accept(ctx)
-	if err != nil {
-		return nil, err
-	}
-	dl, ok := ctx.Deadline()
-	if !ok {
-		dl = time.Now().Add(10*time.Second) // FIXME constant
-	}
-	if err := transport.DoHandshakeCurrentVersion(conn, dl); err != nil {
-		conn.Close()
-		return nil, err
-	}
-	return conn, nil
-}
-
-func FromConfig(g *config.Global, in config.ServeEnum) (lf ListenerFactory, conf *streamrpc.ConnConfig, _ error) {
-
-	var (
-		lfError, rpcErr error
-	)
-	switch v := in.Ret.(type) {
-	case *config.TCPServe:
-		lf, lfError = TCPListenerFactoryFromConfig(g, v)
-		conf, rpcErr = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	case *config.TLSServe:
-		lf, lfError = TLSListenerFactoryFromConfig(g, v)
-		conf, rpcErr = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	case *config.StdinserverServer:
-		lf, lfError = MultiStdinserverListenerFactoryFromConfig(g, v)
-		conf, rpcErr = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	case *config.LocalServe:
-		lf, lfError = LocalListenerFactoryFromConfig(g, v)
-		conf, rpcErr = streamrpcconfig.FromDaemonConfig(g, v.RPC)
-	default:
-		return nil, nil, errors.Errorf("internal error: unknown serve type %T", v)
-	}
-
-	if lfError != nil {
-		return nil, nil, lfError
-	}
-	if rpcErr != nil {
-		return nil, nil, rpcErr
-	}
-
-	lf = HandshakeListenerFactory{lf}
-
-	return lf, conf, nil
-
-}
-
-

daemon/transport/serve/serve_tls.go

@@ -1,83 +0,0 @@
-package serve
-
-import (
-	"crypto/tls"
-	"crypto/x509"
-	"fmt"
-	"github.com/pkg/errors"
-	"github.com/zrepl/zrepl/config"
-	"github.com/zrepl/zrepl/tlsconf"
-	"net"
-	"time"
-	"context"
-)
-
-type TLSListenerFactory struct {
-	address          string
-	clientCA         *x509.CertPool
-	serverCert       tls.Certificate
-	handshakeTimeout time.Duration
-	clientCNs map[string]struct{}
-}
-
-func TLSListenerFactoryFromConfig(c *config.Global, in *config.TLSServe) (lf *TLSListenerFactory, err error) {
-	lf = &TLSListenerFactory{
-		address: in.Listen,
-		handshakeTimeout: in.HandshakeTimeout,
-	}
-
-	if in.Ca == "" || in.Cert == "" || in.Key == "" {
-		return nil, errors.New("fields 'ca', 'cert' and 'key'must be specified")
-	}
-
-	lf.clientCA, err = tlsconf.ParseCAFile(in.Ca)
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot parse ca file")
-	}
-
-	lf.serverCert, err = tls.LoadX509KeyPair(in.Cert, in.Key)
-	if err != nil {
-		return nil, errors.Wrap(err, "cannot parse cer/key pair")
-	}
-
-	lf.clientCNs = make(map[string]struct{}, len(in.ClientCNs))
-	for i, cn := range in.ClientCNs {
-		if err := ValidateClientIdentity(cn); err != nil {
-			return nil, errors.Wrapf(err, "unsuitable client_cn #%d %q", i, cn)
-		}
-		// dupes are ok fr now
-		lf.clientCNs[cn] = struct{}{}
-	}
-
-	return lf, nil
-}
-
-func (f *TLSListenerFactory) Listen() (AuthenticatedListener, error) {
-	l, err := net.Listen("tcp", f.address)
-	if err != nil {
-		return nil, err
-	}
-	tl := tlsconf.NewClientAuthListener(l, f.clientCA, f.serverCert, f.handshakeTimeout)
-	return tlsAuthListener{tl, f.clientCNs}, nil
-}
-
-type tlsAuthListener struct {
-	*tlsconf.ClientAuthListener
-	clientCNs map[string]struct{}
-}
-
-func (l tlsAuthListener) Accept(ctx context.Context) (AuthenticatedConn, error) {
-	c, cn, err := l.ClientAuthListener.Accept()
-	if err != nil {
-		return nil, err
-	}
-	if _, ok := l.clientCNs[cn]; !ok {
-		if err := c.Close(); err != nil {
-			getLogger(ctx).WithError(err).Error("error closing connection with unauthorized common name")
-		}
-		return nil, fmt.Errorf("unauthorized client common name %q from %s", cn, c.RemoteAddr())
-	}
-	return authConn{c, cn}, nil
-}
-
-

dist/grafana/grafana-prometheus-zrepl-0.1.json

@@ -0,0 +1,595 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "$$hashKey": "object:3351",
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 1,
+  "id": 7,
+  "iteration": 1552746418826,
+  "links": [],
+  "panels": [
+    {
+      "content": "# zrepl Prometheus Metrics\n\nzrepl exposes Prometheus metrics and ships with this Grafana dashboard.\nThe exported metrics are suitable for health checks:\n\n* The log should generally be warning & error-free\n  * The `Log Messages that require attention` graph visualizes log message counts indicating problems.\n* The number of goroutines should not grow unboundedly over time.\n  * During replication, the number of goroutines can be way higher than during idle time.\n  * If the goroutine count grows with each replication, there is clearly a goroutine leak. Please open a bug report.\n* The sys memory consumption should not grow unboundedly over time.\n  * Note that the Go runtime pre-allocates some of its heap from the OS.\n  * zrepl actually uses much less memory than allocated from the OS.\n  * Since Go 1.11, Go pre-allocates more aggressively.\n* Monitor that some data is replicated, although that metric does not guarantee that replication was successful.\n\n**In general, note that the exported metrics are not stable unless declared otherwise.**",
+      "gridPos": {
+        "h": 9,
+        "w": 24,
+        "x": 0,
+        "y": 0
+      },
+      "id": 35,
+      "mode": "markdown",
+      "title": "Panel Title",
+      "type": "text"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 9
+      },
+      "id": 15,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "$$hashKey": "object:3436",
+          "expr": "up{job='$prom_job_name'}",
+          "format": "time_series",
+          "intervalFactor": 1,
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "zrepl Instances Up",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": "5",
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ]
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 12,
+        "y": 9
+      },
+      "id": 22,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "increase(zrepl_daemon_log_entries{job='$prom_job_name',level=~'warn|error'}[$__interval])",
+          "format": "time_series",
+          "intervalFactor": 1,
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Log Messages that require attention",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ]
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 18
+      },
+      "id": 33,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "/replicated bytes in last.*/",
+          "yaxis": 2
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(zrepl_replication_bytes_replicated{job='$prom_job_name'}[$__interval])) by (zrepl_job)",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "replication data rate zrepl_job={{zrepl_job}}",
+          "refId": "A"
+        },
+        {
+          "expr": "sum(increase(zrepl_replication_bytes_replicated{job='$prom_job_name'}[10m])) by (zrepl_job)",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "replicated bytes in last 10min zrepl_job={{zrepl_job}}",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Replication Data Rate and Volume(integrates last 10min)",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "Bps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ]
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 12,
+        "y": 18
+      },
+      "id": 23,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(increase(zrepl_daemon_log_entries{job='$prom_job_name',zrepl_job=~\"^[^_].*\"}[$__interval])) by (instance,zrepl_job)",
+          "format": "time_series",
+          "intervalFactor": 1,
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Log Activity (without internal jobs)",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ]
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 27
+      },
+      "id": 17,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "$$hashKey": "object:3535",
+          "expr": "go_memstats_sys_bytes{job='$prom_job_name'}",
+          "format": "time_series",
+          "hide": false,
+          "intervalFactor": 1,
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Memory Allocated by the Go runtime from the OS (should not grow unboundedly)",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ]
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": null,
+      "fill": 1,
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 12,
+        "y": 27
+      },
+      "id": 19,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "go_goroutines{job='$prom_job_name'}",
+          "format": "time_series",
+          "intervalFactor": 1,
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "number of goroutines (should not grow unboundedly)",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ]
+    }
+  ],
+  "refresh": "1m",
+  "schemaVersion": 16,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "allValue": null,
+        "current": {
+          "text": "zrepl",
+          "value": "zrepl"
+        },
+        "datasource": "prometheus",
+        "hide": 0,
+        "includeAll": false,
+        "label": "Prometheus Job Name",
+        "multi": false,
+        "name": "prom_job_name",
+        "options": [],
+        "query": "label_values(up, job)",
+        "refresh": 1,
+        "regex": "",
+        "sort": 1,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      }
+    ]
+  },
+  "time": {
+    "from": "now-2d",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ],
+    "time_options": [
+      "5m",
+      "15m",
+      "1h",
+      "6h",
+      "12h",
+      "24h",
+      "2d",
+      "7d",
+      "30d"
+    ]
+  },
+  "timezone": "",
+  "title": "zrepl 0.1",
+  "uid": "xTljn4qmk",
+  "version": 6
+}

dist/systemd/zrepl.service

@@ -0,0 +1,41 @@
+[Unit]
+Description=zrepl daemon
+Documentation=https://zrepl.github.io
+
+[Service]
+Type=simple
+ExecStart=/usr/local/bin/zrepl --config /etc/zrepl/zrepl.yml daemon
+RuntimeDirectory=zrepl
+RuntimeDirectoryMode=0700
+
+ProtectSystem=strict
+#PrivateDevices=yes # TODO ZFS needs access to /dev/zfs, could we limit this?
+ProtectKernelTunables=yes
+ProtectControlGroups=yes
+PrivateTmp=yes
+#PrivateUsers=yes # TODO Does not work, why?
+ProtectKernelModules=true
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+RestrictNamespaces=true
+RestrictRealtime=yes
+SystemCallArchitectures=native
+
+# BEGIN ProtectHome
+ProtectHome=read-only   # DEBIAN STRETCH
+# ProtectHome=tmpfs     # FEDORA 28 / 29
+# END ProtectHome
+
+# BEGIN SystemCallFilter
+## BEGIN DEBIAN STRETCH
+SystemCallFilter=~ @mount @cpu-emulation @keyring @module @obsolete @privileged @raw-io @debug @clock @resources
+## END DEBIAN STRETCH
+## BEGIN FEDORA 28/29 
+## Syscall blacklist (should be fairly stable)
+#SystemCallFilter=~ @mount @aio @cpu-emulation @keyring @memlock @module @obsolete @privileged @raw-io @reboot @setuid @swap @sync @timer @debug @clock @chown @resources
+## Syscall whitelist (not sure how stable)
+#SystemCallFilter=@default @file-system @process @basic-io @ipc @network-io @signal @io-event brk mprotect sched_getaffinity ioctl getrandom
+## END END FEDORA 28/29
+# END SystemCallFilter
+
+[Install]
+WantedBy=multi-user.target

docs/changelog.rst

@@ -3,6 +3,7 @@
 .. |bugfix| replace:: [BUG]
 .. |docs| replace:: [DOCS]
 .. |feature| replace:: [FEATURE]
+.. |mig| replace:: **[MIGRATION]**
 
 .. _changelog:
 
@@ -19,6 +20,7 @@ We use the following annotations for classifying changes:
 * |break| Change that breaks interoperability or persistent state representation with previous releases.
   As a package maintainer, make sure to warn your users about config breakage somehow.
   Note that even updating the package on both sides might not be sufficient, e.g. if persistent state needs to be migrated to a new format.
+* |mig| Migration that must be run by the user.
 * |feature| Change that introduces new functionality.
 * |bugfix| Change that fixes a bug, no regressions or incompatibilities expected.
 * |docs| Change to the documentation.
@@ -29,13 +31,21 @@ We use the following annotations for classifying changes:
 This release is a milestone for zrepl and required significant refactoring if not rewrites of substantial parts of the application.
 It breaks both configuration and transport format, and thus requires manual intervention and updates on both sides of a replication setup.
 
+.. DANGER::
+   The changes in the pruning system for this release require you to explicitly define **keep rules**:
+   for any snapshot that you want to keep, at least one rule must match.
+   This is different from previous releases where pruning only affected snapshots with the configured snapshotting prefix.
+   Make sure that snapshots to be kept or ignored by zrepl are covered, e.g. by using the ``regex`` keep rule.
+   :ref:`Learn more in the config docs... <prune>`
+
+
 Notes to Package Maintainers
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+* Notify users about migrations (see changes attributed with |mig| below)
 * If the daemon crashes, the stack trace produced by the Go runtime and possibly diagnostic output of zrepl will be written to stderr.
   This behavior is independent from the ``stdout`` outlet type.
-  Please make sure the stderr output of the daemon is captured to a file.
-  Rotation should not be necessary because stderr is not written to under normal circumstances.
+  Please make sure the stderr output of the daemon is captured somewhere.
   To conserve precious stack traces, make sure that multiple service restarts do not directly discard previous stderr output.
 * Make it obvious for users how to set the ``GOTRACEBACK`` environment variable to ``GOTRACEBACK=crash``.
   This functionality will cause SIGABRT on panics and can be used to capture a coredump of the panicking process.
@@ -45,25 +55,45 @@ Notes to Package Maintainers
 Changes
 ~~~~~~~
 
+* |break| |mig| Placeholder property representation changed
+
+  * The :ref:`placeholder property <replication-placeholder-property>` now uses ``on|off`` as values
+    instead of hashes of the dataset path. This permits renames of the sink filesystem without
+    updating all placeholder properties.
+  * Relevant for 0.0.X-0.1-rc* to 0.1 migrations
+  * Make sure your config is valid with ``zrepl configcheck``
+  * Run ``zrepl migrate 0.0.X:0.1:placeholder``
+
 * |feature| :issue:`55` : Push replication (see :ref:`push job <job-push>` and :ref:`sink job <job-sink>`)
 * |feature| :ref:`TCP Transport <transport-tcp>`
 * |feature| :ref:`TCP + TLS client authentication transport <transport-tcp+tlsclientauth>`
-* |feature| :issue:`78` TODO MERGE COMMIT Replication protocol rewrite
+* |feature| :issue:`111`: RPC protocol rewrite
 
-  * Uses ``github.com/problame/go-streamrpc`` for RPC layer
-  * |break| zrepl 0.1 and restart on both sides of a replication setup is required
-  * |feature| :issue:`83`:  Improved error handling of network-level errors (zrepl retries instead of failing the entire job)
-  * |bugfix| :issue:`75` :issue:`81`: use connection timeouts and protocol-level heartbeats
-  * |break| |break_config|: mappings are no longer supported
+  * |break| Protocol breakage; Update and restart of all zrepl daemons is required.
+  * Use `gRPC <https://grpc.io/>`_ for control RPCs and a custom protocol for bulk data transfer.
+  * Automatic retries for network-temporary errors
 
-    * Receiving sides (``pull`` and ``sink`` job) specify a single ``root_fs``.
-      Received filesystems are then stored *per client* in ``${root_fs}/${client_identity}``.
+    * Limited to errors during replication for this release.
+      Addresses the common problem of ISP-forced reconnection at night, but will become
+      way more useful with resumable send & recv support.
+      Pruning errors are handled per FS, i.e., a prune RPC is attempted at least once per FS.
+
+* |feature| Proper timeout handling for the :ref:`SSH transport <transport-ssh+stdinserver>`
+
+  * |break| Requires Go 1.11 or later.
+  
+* |break| |break_config|: mappings are no longer supported
+
+  * Receiving sides (``pull`` and ``sink`` job) specify a single ``root_fs``.
+    Received filesystems are then stored *per client* in ``${root_fs}/${client_identity}``.
+    See :ref:`job-overview` for details.
 
 * |feature| |break| |break_config| Manual snapshotting + triggering of replication
 
   * |feature| :issue:`69`: include manually created snapshots in replication
   * |break_config| ``manual`` and ``periodic`` :ref:`snapshotting types <job-snapshotting-spec>`
-  * |feature| ``zrepl wakeup JOB`` subcommand to trigger *just* replication
+  * |feature| ``zrepl signal wakeup JOB`` subcommand to trigger replication + pruning
+  * |feature| ``zrepl signal reset JOB`` subcommand to abort current replication + pruning
 
 * |feature| |break| |break_config| New pruning system
 
@@ -77,16 +107,22 @@ Changes
   * |feature| |break| Bookmark pruning is no longer necessary
 
     * Per filesystem, zrepl creates a single bookmark (``#zrepl_replication_cursor``) and moves it forward with the most recent successfully replicated snapshot on the receiving side.
-    * Old bookmarks created prior to zrepl 0.1 (named like their corresponding snapshot) must be deleted manually.
+    * Old bookmarks created by prior versions of zrepl (named like their corresponding snapshot) must be deleted manually.
     * |break_config| ``keep_bookmarks`` parameter of the ``grid`` keep rule has been removed
 
 * |feature| ``zrepl status`` for live-updating replication progress (it's really cool!)
+* |feature| :ref:`Snapshot- & pruning-only job type <job-snap>` (for local snapshot management)
 * |feature| :issue:`67`: Expose `Prometheus <https://prometheus.io>`_ metrics via HTTP (:ref:`config docs <monitoring-prometheus>`)
 
+  * Compatible Grafana dashboard shipping in ``dist/grafana``
+
 * |break_config| Logging outlet types must be specified using the ``type`` instead of ``outlet`` key
 * |break| :issue:`53`: CLI: ``zrepl control *`` subcommands have been made direct subcommands of ``zrepl *``
 * |bugfix| Goroutine leak on ssh transport connection timeouts
 * |bugfix| :issue:`81` :issue:`77` : handle failed accepts correctly (``source`` job)
+* |bugfix| :issue:`100`: fix incompatibility with ZoL 0.8
+* |feature| :issue:`115`: logging: configurable syslog facility
+* |feature| Systemd unit file in ``dist/systemd``
 
 .. |lastrelease| replace:: 0.0.3
 
@@ -96,8 +132,3 @@ Previous Releases
 .. NOTE::
     Due to limitations in our documentation system, we only show the changelog since the last release and the time this documentation is built.
     For the changelog of previous releases, use the version selection in the hosted version of these docs at `zrepl.github.io <https://zrepl.github.io>`_.
-    
-    
-
-
-W

docs/configuration/jobs.rst

@@ -11,10 +11,12 @@
 Job Types & Replication
 =======================
 
+.. _job-overview:
+
 Overview & Terminology
 ----------------------
 
-A *job* is the unit of activity tracked by the zrepl daemon and configured in the |mainconfig|.
+A *job* is the unit of activity tracked by the zrepl daemon.
 Every job has a unique ``name``, a ``type`` and type-dependent fields which are documented on this page.
 
 Replication always happens between a pair of jobs: one is the **active side**, and one the **passive side**.
@@ -23,18 +25,22 @@ For communication, the active side connects to the passive side using a :ref:`tr
 
 The following table shows how different job types can be combined to achieve both push and pull mode setups:
 
-+-----------------------+--------------+----------------------------------+-----------------------------------------------+
-| Setup name            | active side  | passive side                     | use case                                      |
-+=======================+==============+==================================+===============================================+
-| Push mode             | ``push``     | ``sink``                         | * Laptop backup                               |
-|                       |              |                                  | * NAS behind NAT to offsite                   |
-+-----------------------+--------------+----------------------------------+-----------------------------------------------+
-| Pull mode             | ``pull``     | ``source``                       | * Central backup-server for many nodes        |
-|                       |              |                                  | * Remote server to NAS behind NAT             |
-+-----------------------+--------------+----------------------------------+-----------------------------------------------+
-| Local replication     | | ``push`` + ``sink`` in one config             | * Backup FreeBSD boot pool                    |
-|                       | | with :ref:`local transport <transport-local>` |                                               |
-+-----------------------+--------------+----------------------------------+-----------------------------------------------+
++-----------------------+--------------+----------------------------------+------------------------------------------------------------------------------------+
+| Setup name            | active side  | passive side                     | use case                                                                           |
++=======================+==============+==================================+====================================================================================+
+| Push mode             | ``push``     | ``sink``                         | * Laptop backup                                                                    |
+|                       |              |                                  | * NAS behind NAT to offsite                                                        |
++-----------------------+--------------+----------------------------------+------------------------------------------------------------------------------------+
+| Pull mode             | ``pull``     | ``source``                       | * Central backup-server for many nodes                                             |
+|                       |              |                                  | * Remote server to NAS behind NAT                                                  |
++-----------------------+--------------+----------------------------------+------------------------------------------------------------------------------------+
+| Local replication     | | ``push`` + ``sink`` in one config             | * Backup FreeBSD boot pool                                                         |
+|                       | | with :ref:`local transport <transport-local>` |                                                                                    |
++-----------------------+--------------+----------------------------------+------------------------------------------------------------------------------------+
+| Snap & prune-only     | ``snap``     | N/A                              | * | Snapshots & pruning but no replication                                         |
+|                       |              |                                  |   | required                                                                       |
+|                       |              |                                  | * Workaround for :ref:`source-side pruning <prune-workaround-source-side-pruning>` |
++-----------------------+--------------+----------------------------------+------------------------------------------------------------------------------------+
 
 How the Active Side Works
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -57,7 +63,7 @@ using the transport listener type specified in the ``serve`` field of the job co
 Each transport listener provides a client's identity to the passive side job.
 It uses the client identity for access control:
 
-* The ``sink`` job only allows pushes to those ZFS filesystems to the active side that are located below ``root_fs/${client_identity}``.
+* The ``sink`` job maps requests from different client identities to their respective sub-filesystem tree ``root_fs/${client_identity}``.
 * The ``source`` job has a whitelist of client identities that are allowed pull access.
 
 .. TIP::
@@ -91,7 +97,8 @@ The following steps take place during replication and can be monitored using the
 
   * Perform replication steps in the following order:
     Among all filesystems with pending replication steps, pick the filesystem whose next replication step's snapshot is the oldest.
-  * After a successful replication step, update the replication cursor bookmark (see below)
+  * Create placeholder filesystems on the receiving side to mirror the dataset paths on the sender to ``root_fs/${client_identity}``.
+  * After a successful replication step, update the replication cursor bookmark (see below).
    
 The idea behind the execution order of replication steps is that if the sender snapshots all filesystems simultaneously at fixed intervals, the receiver will have all filesystems snapshotted at time ``T1`` before the first snapshot at ``T2 = T1 + $interval`` is replicated.
 
@@ -101,6 +108,17 @@ The **replication cursor bookmark** ``#zrepl_replication_cursor`` is kept per fi
 It is a bookmark of the most recent successfully replicated snapshot to the receiving side.
 It is is used by the :ref:`not_replicated <prune-keep-not-replicated>` keep rule to identify all snapshots that have not yet been replicated to the receiving side.
 Regardless of whether that keep rule is used, the bookmark ensures that replication can always continue incrementally.
+Note that there is only one cursor bookmark per filesystem, which prohibits multiple jobs to replicate the same filesystem (:ref:`see below<jobs-multiple-jobs>`).
+
+.. _replication-placeholder-property:
+
+**Placeholder filesystems** on the receiving side are regular ZFS filesystems with the placeholder property ``zrepl:placeholder=on``.
+Placeholders allow the receiving side to mirror the sender's ZFS dataset hierachy without replicating every filesystem at every intermediary dataset path component.
+Consider the following example: ``S/H/J`` shall be replicated to ``R/sink/job/S/H/J``, but neither ``S/H`` nor ``S`` shall be replicated.
+ZFS requires the existence of ``R/sink/job/S`` and ``R/sink/job/S/H`` in order to receive into ``R/sink/job/S/H/J``.
+Thus, zrepl creates the parent filesystems as placeholders on the receiving side.
+If at some point ``S/H`` and ``S`` shall be replicated, the receiving side invalidates the placeholder flag automatically.
+The ``zrepl test placeholder`` command can be used to check whether a filesystem is a placeholder.
 
 .. ATTENTION::
 
@@ -114,7 +132,7 @@ Regardless of whether that keep rule is used, the bookmark ensures that replicat
 Taking Snaphots
 ---------------
 
-The ``push`` and ``source`` jobs can automatically take periodic snapshots of the filesystems matched by the ``filesystems`` filter field.
+The ``push``, ``source`` and ``snap`` jobs can automatically take periodic snapshots of the filesystems matched by the ``filesystems`` filter field.
 The snapshot names are composed of a user-defined prefix followed by a UTC date formatted like ``20060102_150405_000``.
 We use UTC because it will avoid name conflicts when switching time zones or between summer and winter time.
 
@@ -136,11 +154,12 @@ For ``push`` jobs, replication is automatically triggered after all filesystems
 
 There is also a ``manual`` snapshotting type, which covers the following use cases:
 
-* Existing infrastructure for automatic snapshots: you only want to use zrepl for replication.
+* Existing infrastructure for automatic snapshots: you only want to use this zrepl job for replication.
 * Run scripts before and after taking snapshots (like locking database tables).
   We are working on better integration for this use case: see :issue:`74`.
+* Handling snapshotting through a separate ``snap`` job.
 
-Note that you will have to trigger replication manually using the ``zrepl wakeup JOB`` subcommand in that case.
+Note that you will have to trigger replication manually using the ``zrepl signal wakeup JOB`` subcommand in that case.
 
 ::
 
@@ -154,6 +173,50 @@ Note that you will have to trigger replication manually using the ``zrepl wakeup
        type: manual
      ...
 
+.. _jobs-multiple-jobs:
+
+Multiple Jobs & More than 2 Machines
+------------------------------------
+
+.. ATTENTION::
+
+  When using multiple jobs across single or multiple machines, the following rules are critical to avoid race conditions & data loss:
+
+  1. The sets of ZFS filesystems matched by the ``filesystems`` filter fields must be disjoint across all jobs configured on a machine.
+  2. The ZFS filesystem subtrees of jobs with ``root_fs`` must be disjoint.
+  3. Across all zrepl instances on all machines in the replication domain, there must be a 1:1 correspondence between active and passive jobs.
+
+  Explanations & exceptions to above rules are detailed below.
+
+If you would like to see improvements to multi-job setups, please `open an issue on GitHub <https://github.com/zrepl/zrepl/issues/new>`_.
+
+No Overlapping
+~~~~~~~~~~~~~~
+
+Jobs run independently of each other.
+If two jobs match the same filesystem with their ``filesystems`` filter, they will operate on that filesystem independently and potentially in parallel.
+For example, if job A prunes snapshots that job B is planning to replicate, the replication will fail because B asssumed the snapshot to still be present.
+More subtle race conditions can occur with the :ref:`replication cursor bookmark <replication-cursor-bookmark>`, which currently only exists once per filesystem.
+
+N push jobs to 1 sink
+~~~~~~~~~~~~~~~~~~~~~
+
+The :ref:`sink job <job-sink>` namespaces by client identity.
+It is thus safe to push to one sink job with different client identities.
+If the push jobs have the same client identity, the filesystems matched by the push jobs must be disjoint to avoid races.
+
+N pull jobs from 1 source
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Multiple pull jobs pulling from the same source have potential for race conditions during pruning:
+each pull job prunes the source side independently, causing replication-prune and prune-prune races.
+
+There is currently no way for a pull job to filter which snapshots it should attempt to replicate.
+Thus, it is not possibe to just manually assert that the prune rules of all pull jobs are disjoint to avoid replication-prune and prune-prune races.
+
+
+------------------------------------------------------------------------------
+
 
 .. _job-push:
 
@@ -199,8 +262,8 @@ Job Type ``sink``
     * - ``serve``
       - |serve-transport|
     * - ``root_fs``
-      - ZFS dataset path are received to
-        ``$root_fs/$client_identity``
+      - ZFS filesystems are received to
+        ``$root_fs/$client_identity/$source_path``
 
 Example config: :sampleconf:`/sink.yml`
 
@@ -222,10 +285,11 @@ Job Type ``pull``
     * - ``connect``
       - |connect-transport|
     * - ``root_fs``
-      - ZFS dataset path are received to
-        ``$root_fs/$client_identity``
+      - ZFS filesystems are received to
+        ``$root_fs/$source_path``
     * - ``interval``
-      - Interval at which to pull from the source job
+      - | Interval at which to pull from the source job (e.g. ``10m``).
+        | ``manual`` disables periodic pulling, replication then only happens on :ref:`wakeup <cli-signal-wakeup>`.
     * - ``pruning``
       - |pruning-spec|
 
@@ -255,6 +319,7 @@ Job Type ``source``
 
 Example config: :sampleconf:`/source.yml`
 
+
 .. _replication-local:
 
 Local replication
@@ -265,3 +330,28 @@ If you have the need for local replication (most likely between two local storag
 Example config: :sampleconf:`/local.yml`.
 
 
+.. _job-snap:
+
+Job Type ``snap`` (snapshot & prune only)
+-----------------------------------------
+
+Job type that only takes snapshots and performs pruning on the local machine.
+
+.. list-table::
+    :widths: 20 80
+    :header-rows: 1
+
+    * - Parameter
+      - Comment
+    * - ``type``
+      - = ``snap``
+    * - ``name``
+      - unique name of the job
+    * - ``filesystems``
+      - |filter-spec| for filesystems to be snapshotted
+    * - ``snapshotting``
+      - |snapshotting-spec|
+    * - ``pruning``
+      - |pruning-spec|
+
+Example config: :sampleconf:`/snap.yml`

docs/configuration/logging.rst

@@ -7,7 +7,7 @@ Logging
 
 zrepl uses structured logging to provide users with easily processable log messages.
 
-Logging outlets are configured in the ``global`` section of the |mainconfig|.
+Logging outlets are configured in the ``global`` section of the config file.
 
 ::
 
@@ -147,6 +147,8 @@ Can only be specified once.
       -  minimum  :ref:`log level <logging-levels>`
     * - ``format``
       - output :ref:`format <logging-formats>`
+    * - ``facility``
+      - Which syslog facility to use (default = ``local0``)
     * - ``retry_interval``
       - Interval between reconnection attempts to syslog (default = 0)
 

docs/configuration/monitoring.rst

@@ -5,18 +5,24 @@
 Monitoring
 ==========
 
-Monitoring endpoints are configured in the ``global.monitoring`` section of the |mainconfig|.
+Monitoring endpoints are configured in the ``global.monitoring`` section of the config file.
 
 .. _monitoring-prometheus:
 
-Prometheus
-----------
+Prometheus & Grafana
+--------------------
 
 zrepl can expose `Prometheus metrics <https://prometheus.io/docs/instrumenting/exposition_formats/>`_ via HTTP.
 The ``listen`` attribute is a `net.Listen <https://golang.org/pkg/net/#Listen>`_  string for tcp, e.g. ``:9091`` or ``127.0.0.1:9091``.
-
 The Prometheues monitoring job appears in the ``zrepl control`` job list and may be specified **at most once**.
-At the time of writing, there is no stability guarantee on the exported metrics.
+
+zrepl also ships with an importable `Grafana <https://grafana.com>`_ dashboard that consumes the Prometheus metrics:
+see :repomasterlink:`dist/grafana`.
+The dashboard also contains some advice on which metrics are important to monitor.
+
+.. NOTE::
+
+  At the time of writing, there is no stability guarantee on the exported metrics.
 
 ::
 

docs/configuration/prune.rst

@@ -10,10 +10,12 @@ Typically, the requirements to temporal resolution and maximum retention time di
 For example, when using zrepl to back up a busy database server, you will want high temporal resolution (snapshots every 10 min) for the last 24h in case of administrative disasters, but cannot afford to store them for much longer because you might have high turnover volume in the database.
 On the receiving side, you may have more disk space available, or need to comply with other backup retention policies.
 
-zrepl uses a set of  **keep rules** to determine which snapshots shall be kept per filesystem.
+zrepl uses a set of  **keep rules** per sending and receiving side to determine which snapshots shall be kept per filesystem.
 **A snapshot that is not kept by any rule is destroyed.**
 The keep rules are **evaluated on the active side** (:ref:`push <job-push>` or :ref:`pull job <job-pull>`) of the replication setup, for both active and passive side, after replication completed or was determined to have failed permanently.
 
+
+
 Example Configuration:
 
 ::
@@ -45,19 +47,14 @@ Example Configuration:
              regex: "^zrepl_.*"
            # manually created snapshots will be kept forever on receiver
 
-
-.. ATTENTION::
-
-    It is currently not possible to define pruning on a source job.
-    The source job creates snapshots, which means that extended replication downtime will fill up the source's zpool with snapshots, since pruning is directed by the corresponding active side (pull job).
-    If this is a potential risk for you, consider using :ref:`push mode <job-push>`.
-
+.. DANGER::
+    You might have **existing snapshots** of filesystems affected by pruning which you want to keep, i.e. not be destroyed by zrepl.
+    Make sure to actually add the necessary ``regex`` keep rules on both sides, like with ``manual`` in the example above.
 
 .. _prune-keep-not-replicated:
 
 Policy ``not_replicated``
 -------------------------
-
 ::
 
    jobs:
@@ -97,7 +94,7 @@ the left edge of the leftmost (first) interval is the ``creation`` date of the y
 All intervals to its right describe time intervals further in the past.
 
 Each interval carries a maximum number of snapshots to keep.
-It is secified via ``(keep=N)``, where ``N`` is either ``all`` (all snapshots are kept) or a positive integer.
+It is specified via ``(keep=N)``, where ``N`` is either ``all`` (all snapshots are kept) or a positive integer.
 The default value is **keep=1**.
 
 The following procedure happens during pruning:
@@ -143,12 +140,75 @@ Policy ``regex``
      - type: push
        pruning:
          keep_receiver:
+         # keep all snapshots with prefix zrepl_ or manual_
          - type: regex
            regex: "^(zrepl|manual)_.*"
-    ...
+
+     - type: push
+       snapshotting:
+         prefix: zrepl_
+       pruning:
+         keep_sender:
+         # keep all snapshots that were not created by zrepl
+         - type: regex
+           negate: true
+           regex: "^zrepl_.*"
 
 ``regex`` keeps all snapshots whose names are matched by the regular expressionin ``regex``.
 Like all other regular expression fields in prune policies, zrepl uses Go's `regexp.Regexp <https://golang.org/pkg/regexp/#Compile>`_ Perl-compatible regular expressions (`Syntax <https://golang.org/pkg/regexp/syntax>`_).
+The optional `negate` boolean field inverts the semantics: Use it if you want to keep all snapshots that *do not* match the given regex.
 
+.. _prune-workaround-source-side-pruning:
 
+Source-side snapshot pruning
+----------------------------
 
+A :ref:`source jobs<job-source>` takes snapshots on the system it runs on.
+The corresponding :ref:`pull job <job-pull>` on the replication target connects to the source job and replicates the snapshots.
+Afterwards, the pull job coordinates pruning on both sender (the source job side) and receiver (the pull job side).
+
+There is no built-in way to define and execute pruning on the source side independently of the pull side.
+The source job will continue taking snapshots which will not be pruned until the pull side connects.
+This means that **extended replication downtime will fill up the source's zpool with snapshots**.
+
+If the above is a conceivable situation for you, consider using :ref:`push mode <job-push>`, where pruning happens on the same side where snapshots are taken.
+
+Workaround using ``snap`` job
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+As a workaround (see GitHub :issue:`102` for development progress), a pruning-only :ref:`snap job <job-snap>` can be defined on the source side:
+The snap job is in charge of snapshot creation & destruction, whereas the source job's role is reduced to just serving snapshots.
+However, since, jobs are run independently, it is possible that the snap job will prune snapshots that are queued for replication / destruction by the remote pull job that connects to the source job.
+Symptoms of such race conditions are spurious replication and destroy errors.
+
+Example configuration:
+
+::
+
+  # source side
+  jobs:
+  - type: snap
+    snapshotting:
+      type: periodic
+    pruning:
+      keep:
+        # source side pruning rules go here
+    ...
+
+  - type: source
+    snapshotting:
+      type: manual
+    root_fs: ...
+
+  # pull side
+  jobs:
+  - type: pull
+    pruning:
+      keep_sender:
+        # let the source-side snap job do the pruning
+        - type: regex
+          regex: ".*"
+        ...
+      keep_receiver:
+        # feel free to prune on the pull side as desired
+        ...

docs/configuration/transports.rst

@@ -10,6 +10,8 @@ On the passive (serving) side, the transport also provides the **client identity
 this string is used for access control and separation of filesystem sub-trees in :ref:`sink jobs <job-sink>`.
 Transports are specified in the ``connect`` or ``serve`` section of a job definition.
 
+.. contents::
+
 .. ATTENTION::
 
     The **client identities must be valid ZFS dataset path components**
@@ -27,6 +29,8 @@ This transport may also be used in conjunction with network-layer encryption and
 To make the IP-based client authentication effective, such solutions should provide authenticated IP addresses.
 Some options to consider:
 
+.. _transport-tcp-tunneling:
+
 * `WireGuard <https://www.wireguard.com/>`_: Linux-focussed, in-kernel TLS
 * `OpenVPN <https://openvpn.net/>`_: Cross-platform VPN, uses tun on \*nix
 * `IPSec <https://en.wikipedia.org/wiki/IPsec>`_: Properly standardized, in-kernel network-layer VPN
@@ -72,7 +76,9 @@ Connect
 
 The ``tls`` transport uses TCP + TLS with client authentication using client certificates.
 The client identity is the common name (CN) presented in the client certificate.
+
 It is recommended to set up a dedicated CA infrastructure for this transport, e.g. using OpenVPN's `EasyRSA <https://github.com/OpenVPN/easy-rsa>`_.
+For a simple 2-machine setup, see the :ref:`instructions below<transport-tcp+tlsclientauth-2machineopenssl>`.
 
 The implementation uses `Go's TLS library <https://golang.org/pkg/crypto/tls/>`_.
 Since Go binaries are statically linked, you or your distribution need to recompile zrepl when vulnerabilities in that library are disclosed.
@@ -80,6 +86,10 @@ Since Go binaries are statically linked, you or your distribution need to recomp
 All file paths are resolved relative to the zrepl daemon's working directory.
 Specify absolute paths if you are unsure what directory that is (or find out from your init system).
 
+If intermediate CAs are used, the **full chain** must be present in either in the ``ca`` file or the individual ``cert`` files.
+Regardless, the client's certificate must be first in the ``cert`` file, with each following certificate directly certifying the one preceding it (see `TLS's specification <https://tools.ietf.org/html/rfc5246#section-7.4.2>`_).
+This is the common default when using a CA management tool.
+
 Serve
 ~~~~~
 
@@ -91,9 +101,9 @@ Serve
         serve:
           type: tls
           listen: ":8888"
-          ca: /etc/zrepl/ca.crt
-          cert: /etc/zrepl/prod.crt
-          key: /etc/zrepl/prod.key
+          ca:   /etc/zrepl/ca.crt
+          cert: /etc/zrepl/prod.fullchain
+          key:  /etc/zrepl/prod.key
           client_cns:
             - "laptop1"
             - "homeserver"
@@ -111,8 +121,8 @@ Connect
       connect:
         type: tls
         address: "server1.foo.bar:8888"
-        ca: /etc/zrepl/ca.crt
-        cert: /etc/zrepl/backupserver.crt
+        ca:   /etc/zrepl/ca.crt
+        cert: /etc/zrepl/backupserver.fullchain
         key:  /etc/zrepl/backupserver.key
         server_cn: "server1"
         dial_timeout: # optional, default 10s
@@ -122,13 +132,91 @@ The ``server_cn`` specifies the expected common name (CN) of the server's certif
 It overrides the hostname specified in ``address``.
 The connection fails if either do not match.
 
+.. _transport-tcp+tlsclientauth-2machineopenssl:
+
+Self-Signed Certificates
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Tools like `EasyRSA <https://github.com/OpenVPN/easy-rsa>`_ make it easy to manage CA infrastructure for multiple clients, e.g. a central zrepl backup server (in sink mode).
+However, for a two-machine setup, self-signed certificates distributed using an out-of-band mechanism will also work just fine:
+
+Suppose you have a push-mode setup, with `backups.example.com` running the :ref:`sink job <job-sink>`, and `prod.example.com` running the :ref:`push job <job-push>`.
+Run the following OpenSSL commands on each host, substituting HOSTNAME in both filenames and the interactive input prompt by OpenSSL:
+
+.. code-block:: bash
+   :emphasize-lines: 1-5,24
+
+   openssl req -x509 -sha256 -nodes \
+      -newkey rsa:4096 \
+      -days 365 \
+      -keyout HOSTNAME.key \
+      -out HOSTNAME.crt
+
+   #Generating a 4096 bit RSA private key
+   #................++++
+   #.++++
+   #writing new private key to 'backups.key'
+   #-----
+   #You are about to be asked to enter information that will be incorporated
+   #into your certificate request.
+   #What you are about to enter is what is called a Distinguished Name or a DN.
+   #There are quite a few fields but you can leave some blank
+   #For some fields there will be a default value,
+   #If you enter '.', the field will be left blank.
+   #-----
+   #Country Name (2 letter code) [XX]:
+   #State or Province Name (full name) []:
+   #Locality Name (eg, city) [Default City]:
+   #Organization Name (eg, company) [Default Company Ltd]:
+   #Organizational Unit Name (eg, section) []:
+   #Common Name (eg, your name or your server's hostname) []:HOSTNAME
+   #Email Address []:
+
+Now copy each machine's ``HOSTNAME.crt`` to the other machine's ``/etc/zrepl/HOSTNAME.crt``, for example using `scp`.
+The serve & connect configuration will thus look like the following:
+
+::
+
+   # on backups.example.com
+   - type: sink
+     serve:
+       type: tls
+       listen: ":8888"
+       ca: "/etc/zrepl/prod.example.com.crt"
+       cert: "/etc/zrepl/backups.example.com.crt"
+       key: "/etc/zrepl/backups.example.com.key"
+       client_cns:
+         - "prod.example.com"
+     ...
+
+   # on prod.example.com
+   - type: push
+     connect:
+       type: tls
+       address:"backups.example.com:8888"
+       ca: /etc/zrepl/backups.example.com.crt
+       cert: /etc/zrepl/prod.example.com.crt
+       key:  /etc/zrepl/prod.example.com.key
+       server_cn: "backups.example.com"
+     ...
+
+
 .. _transport-ssh+stdinserver:
 
 ``ssh+stdinserver`` Transport
 -----------------------------
 
-``ssh+stdinserver`` is inspired by `git shell <https://git-scm.com/docs/git-shell>`_ and `Borg Backup <https://borgbackup.readthedocs.io/en/stable/deployment.html>`_.
-It is provided by the Go package ``github.com/problame/go-netssh``.
+``ssh+stdinserver`` uses the ``ssh`` command and some features of the server-side SSH ``authorized_keys`` file.
+It is less efficient than other transports because the data passes through two more pipes.
+However, it is fairly convenient to set up and allows the zrepl daemon to not be directly exposed to the internet, because all traffic passes through the system's SSH server.
+
+The concept is inspired by `git shell <https://git-scm.com/docs/git-shell>`_ and `Borg Backup <https://borgbackup.readthedocs.io/en/stable/deployment.html>`_.
+The implementation is provided by the Go package ``github.com/problame/go-netssh``.
+
+.. NOTE::
+
+   ``ssh+stdinserver`` generally provides inferior error detection and handling compared to the ``tcp`` and ``tls`` transports.
+   When encountering such problems, consider using  ``tcp`` or ``tls`` transports, or help improve package go-netssh.
 
 .. _transport-ssh+stdinserver-serve:
 

docs/global.rst.inc

@@ -1,3 +1,4 @@
 .. global list of substitutions
 
-.. |mainconfig| replace:: :ref:`main configuration file <mainconfigfile>`
+.. 
+  .. |macroname| replace:: macro expansion

docs/index.rst

@@ -5,6 +5,22 @@
 
 .. include:: global.rst.inc
 
+|GitHub license| |Language: Go| |User Docs| |Donate via PayPal| |Donate
+via Liberapay| |Twitter|
+
+.. |GitHub license| image:: https://img.shields.io/github/license/zrepl/zrepl.svg
+   :target: https://github.com/zrepl/zrepl/blob/master/LICENSE
+.. |Language: Go| image:: https://img.shields.io/badge/language-Go-6ad7e5.svg
+   :target: https://golang.org/
+.. |User Docs| image:: https://img.shields.io/badge/docs-web-blue.svg
+   :target: https://zrepl.github.io
+.. |Donate via PayPal| image:: https://img.shields.io/badge/donate-paypal-yellow.svg
+   :target: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=R5QSXJVYHGX96
+.. |Donate via Liberapay| image:: https://img.shields.io/badge/donate-liberapay-yellow.svg
+   :target: https://liberapay.com/zrepl/donate
+.. |Twitter| image:: https://img.shields.io/twitter/url/https/github.com/zrepl/zrepl.svg?style=social
+   :target: https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fzrepl%2Fzrepl
+
 zrepl - ZFS replication
 -----------------------
 
@@ -33,6 +49,7 @@ Main Features
 
   * Advanced replication features
 
+    * [x] Automatic retries for temporary network errors
     * [ ] Resumable send & receive
     * [ ] Compressed send & receive
     * [ ] Raw encrypted send & receive
@@ -77,7 +94,8 @@ We are happy about any help we can get!
   * These docs live in the ``docs/`` subdirectory
 
 * Document any non-obvious / confusing / plain broken behavior you encounter when setting up zrepl for the first time
-* Check the *Issues* and *Projects* sections for things to do
+* Check the *Issues* and *Projects* sections for things to do.
+  The `good first issues <https://github.com/zrepl/zrepl/labels/good%20first%20issue>`_ and `docs <https://github.com/zrepl/zrepl/labels/docs>`_ are suitable starting points.
 
 .. admonition:: Development Workflow
     :class: note

docs/installation.rst

@@ -66,18 +66,20 @@ Alternatively, you can install build dependencies on your local system and then
     mkdir -p "${GOPATH}/src/github.com/zrepl/zrepl"
     git clone https://github.com/zrepl/zrepl.git "${GOPATH}/src/github.com/zrepl/zrepl"
     cd "${GOPATH}/src/github.com/zrepl/zrepl"
+    python3 -m venv3
+    source venv3/bin/activate
     ./lazy.sh devsetup
     make vendordeps release
 
-Build results are located in the ``artifacts/`` directory.
+The Python venv is used for the documentation build dependencies.
+If you just want to build the zrepl binary, leave it out and use `./lazy.sh godep` instead.
+Either way, all build results are located in the ``artifacts/`` directory.
 
 .. NOTE::
 
     It is your job to install the apropriate binary in the zrepl users's ``$PATH``, e.g. ``/usr/local/bin/zrepl``.
     Otherwise, the examples in the :ref:`tutorial` may need to be adjusted.
 
-.. _mainconfigfile:
-
 What next?
 ----------
 

docs/publish.sh

@@ -54,6 +54,9 @@ echo "building site"
 set -e
 sphinx-versioning build \
    --show-banner \
+   --whitelist-branches 'master' \
+   --whitelist-tags '(v)?\d+\.\d+\.\d+$' \
+   --whitelist-tags '0.1.0-rc(3|4)$' \
    docs ./public_git \
    -- -c sphinxconf # older conf.py throw errors because they used
                     # version = subprocess.show_output(["git", "describe"])

docs/requirements.txt

@@ -1,28 +1,20 @@
-Babel==2.5.1
-certifi==2017.11.5
+alabaster==0.7.12
+Babel==2.6.0
+certifi==2018.10.15
 chardet==3.0.4
-click==6.7
-colorclass==2.2.0
-cryptography==1.7.1
 docutils==0.14
-idna==2.6
-imagesize==0.7.1
+idna==2.7
+imagesize==1.1.0
 Jinja2==2.10
-keyring==10.1
-keyrings.alt==1.3
-MarkupSafe==1.0
-pyasn1==0.1.9
-pycrypto==2.6.1
+MarkupSafe==1.1.0
+packaging==18.0
 Pygments==2.2.0
-pygobject==3.22.0
-pytz==2017.3
-pyxdg==0.25
-requests==2.18.4
-SecretStorage==2.3.1
-six==1.10.0
+pyparsing==2.3.0
+pytz==2018.7
+requests==2.20.1
+six==1.11.0
 snowballstemmer==1.2.1
-Sphinx==1.6.5
-sphinx-rtd-theme==0.2.4
-sphinxcontrib-versioning==2.2.1
-sphinxcontrib-websupport==1.0.1
-urllib3==1.22
+Sphinx==1.8.2
+sphinx-rtd-theme==0.4.2
+sphinxcontrib-websupport==1.1.0
+urllib3==1.24.1

docs/sphinxconf/conf.py

@@ -35,6 +35,8 @@ extensions = ['sphinx.ext.todo',
     'sphinx.ext.githubpages',
     'sphinx.ext.extlinks']
 
+suppress_warnings = ['image.nonlocal_uri']
+
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['../_templates']
 
@@ -173,6 +175,7 @@ texinfo_documents = [
 # http://www.sphinx-doc.org/en/stable/ext/extlinks.html
 extlinks = {
     'issue':('https://github.com/zrepl/zrepl/issues/%s', 'issue #'),
+    'repomasterlink':('https://github.com/zrepl/zrepl/blob/master/%s', ''),
     'sampleconf':('https://github.com/zrepl/zrepl/blob/master/config/samples%s', 'config/samples'),
     'commit':('https://github.com/zrepl/zrepl/commit/%s', 'commit '),
         }

docs/tutorial.rst

@@ -6,7 +6,7 @@ Tutorial
 ========
 
 
-This tutorial shows how zrepl can be used to implement a ZFS-based pull backup.
+This tutorial shows how zrepl can be used to implement a ZFS-based push backup.
 We assume the following scenario:
 
 * Production server ``prod`` with filesystems to back up:
@@ -17,12 +17,12 @@ We assume the following scenario:
 
 * Backup server ``backups`` with
 
-  * Filesystem ``storage/zrepl/pull/prod`` + children dedicated to backups of ``prod``
+  * Filesystem ``storage/zrepl/sink/prod`` + children dedicated to backups of ``prod``
 
 Our backup solution should fulfill the following requirements:
 
 * Periodically snapshot the filesystems on ``prod`` *every 10 minutes*
-* Incrementally replicate these snapshots to ``storage/zrepl/pull/prod/*`` on ``backups``
+* Incrementally replicate these snapshots to ``storage/zrepl/sink/prod/*`` on ``backups``
 * Keep only very few snapshots on ``prod`` to save disk space
 * Keep a fading history (24 hourly, 30 daily, 6 monthly) of snapshots on ``backups``
 
@@ -31,74 +31,70 @@ Analysis
 
 We can model this situation as two jobs:
 
-* A **source job** on ``prod``
+* A **push job** on ``prod``
 
   * Creates the snapshots
-  * Keeps a short history of snapshots to enable incremental replication to ``backups``
-  * Accepts connections from ``backups``
+  * Keeps a short history of local snapshots to enable incremental replication to ``backups``
+  * Connects to the ``zrepl daemon`` process on ``backups``
+  * Pushes snapshots ``backups``
+  * Prunes snapshots on ``backups`` after replication is complete
 
-* A **pull job** on ``backups``
+* A **sink job** on ``backups``
 
-  * Connects to the ``zrepl daemon`` process on ``prod``
-  * Pulls the snapshots to ``storage/zrepl/pull/prod/*``
-  * Fades out snapshots in ``storage/zrepl/pull/prod/*`` as they age
-
-
-Why doesn't the **pull job** create the snapshots before pulling?
-
-As is the case with all distributed systems, the link between ``prod`` and ``backups`` might be down for an hour or two.
-We do not want to sacrifice our required backup resolution of 10 minute intervals for a temporary connection outage.
-
-When the link comes up again, ``backups`` will catch up with the snapshots taken by ``prod`` in the meantime, without a gap in our backup history.
+  * Accepts connections & responds to requests from ``prod``
+  * Limits client ``prod`` access to filesystem sub-tree ``storage/zrepl/sink/prod``
 
 Install zrepl
 -------------
 
 Follow the :ref:`OS-specific installation instructions <installation>` and come back here.
 
-Configure server ``backups``
-----------------------------
+Generate TLS Certificates
+-------------------------
 
-We define a **pull job** named ``pull_prod`` in ``/etc/zrepl/zrepl.yml`` or ``/usr/local/etc/zrepl/zrepl.yml`` on host ``backups`` : ::
+We use the `TLS client authentication transport <transport-tcp+tlsclientauth>` to protect our data on the wire.
+To get things going quickly, we skip setting up a CA and generate two self-signed certificates as described :ref:`here <transport-tcp+tlsclientauth-2machineopenssl>`.
+Again, for convenience, We generate the key pairs on our local machine and distribute them using ssh:
 
-    jobs:
-    - name: pull_prod
-      type: pull
-      connect:
-        type: tcp
-        address: "192.168.2.20:2342"
-      root_fs: "storage/zrepl/pull/prod"
-      interval: 10m
-      pruning:
-        keep_sender:
-        - type: not_replicated
-        - type: last_n
-          count: 10
-        keep_receiver:
-        - type: grid
-          grid: 1x1h(keep=all) | 24x1h | 30x1d | 6x30d
-          regex: "^zrepl_"
-          interval: 10m
+.. code-block:: bash
+   :emphasize-lines: 6,13
 
-The ``connect`` section instructs the zrepl daemon to use plain TCP transport.
-Check out the :ref:`transports <transport>` section for alternatives that support encryption.
+   openssl req -x509 -sha256 -nodes \
+      -newkey rsa:4096 \
+      -days 365 \
+      -keyout backups.key \
+      -out backups.crt
+   # ... and use "backups" as Common Name (CN)
+
+   openssl req -x509 -sha256 -nodes \
+      -newkey rsa:4096 \
+      -days 365 \
+      -keyout prod.key \
+      -out prod.crt
+   # ... and use "prod" as Common Name (CN)
+
+   ssh root@backups "mkdir /etc/zrepl"
+   scp  backups.key backups.crt prod.crt root@backups:/etc/zrepl
+
+   ssh root@prod "mkdir /etc/zrepl"
+   scp  prod.key prod.crt backups.crt root@prod:/etc/zrepl
 
-.. _tutorial-configure-prod:
 
 Configure server ``prod``
 -------------------------
 
-We define a corresponding **source job** named ``source_backups`` in ``/etc/zrepl/zrepl.yml`` or ``/usr/local/etc/zrepl/zrepl.yml`` on host ``prod`` : ::
+We define a **push job** named ``prod_to_backups`` in ``/etc/zrepl/zrepl.yml`` on host ``prod`` : ::
 
     jobs:
-    - name: source_backups
-      type: source
-      serve:
-        type: tcp
-        listen: ":2342"
-        clients: {
-          "192.168.2.10" : "backups"
-        }
+    - name: prod_to_backups
+      type: push 
+      connect:
+        type: tls
+        address: "backups.example.com:8888"
+        ca: /etc/zrepl/backups.crt
+        cert: /etc/zrepl/prod.crt
+        key:  /etc/zrepl/prod.key
+        server_cn: "backups"
       filesystems: {
         "zroot/var/db:": true,
         "zroot/usr/home<": true,
@@ -108,44 +104,74 @@ We define a corresponding **source job** named ``source_backups`` in ``/etc/zrep
         type: periodic
         prefix: zrepl_
         interval: 10m
+      pruning:
+        keep_sender:
+        - type: not_replicated
+        - type: last_n
+          count: 10
+        keep_receiver:
+        - type: grid
+          grid: 1x1h(keep=all) | 24x1h | 30x1d | 6x30d
+          regex: "^zrepl_"
 
+.. _tutorial-configure-prod:
+
+Configure server ``backups``
+----------------------------
+
+We define a corresponding **sink job** named ``sink`` in ``/etc/zrepl/zrepl.yml`` on host ``prod`` : ::
+
+    jobs:
+    - name: sink
+      type: sink 
+      serve:
+         type: tls
+         listen: ":8888"
+         ca: "/etc/zrepl/prod.crt"
+         cert: "/etc/zrepl/backups.crt"
+         key: "/etc/zrepl/backups.key"
+         client_cns:
+           - "prod"
+      root_fs: "storage/zrepl/sink"
 
-The ``serve`` section whitelists ``backups``'s IP address ``192.168.2.10`` and assigns it the client identity ``backups`` which will show up in the logs.
-Again, check the :ref:`docs for encrypted transports <transport>`.
 
 Apply Configuration Changes
 ---------------------------
 
-We need to restart the zrepl daemon on **both** ``prod`` and ``backups``.
-This is :ref:`OS-specific <usage-zrepl-daemon-restarting>`.
+We use ``zrepl configcheck`` before to catch any configuration errors: no output indicates that everything is fine.
+If that is the case, restart the zrepl daemon on **both** ``prod`` and ``backups`` using ``service zrepl restart`` or ``systemctl restart zrepl``.
+
 
 Watch it Work
 -------------
 
 Run ``zrepl status`` on ``prod`` to monitor the replication and pruning activity.
-
-Additionally, you can check the detailed structured logs of the `zrepl daemon` process and use GNU *watch* to view the snapshots present on both machines.
+To re-trigger replication (snapshots are separate!), use ``zrepl signal wakeup prod_to_backups`` on ``prod``.
 
 If you like tmux, here is a handy script that works on FreeBSD: ::
 
     pkg install gnu-watch tmux
-    tmux new-window
-    tmux split-window "tail -f /var/log/zrepl.log"
-    tmux split-window "gnu-watch 'zfs list -t snapshot -o name,creation -s creation | grep zrepl_'"
-    tmux select-layout tiled
+    tmux new -s zrepl -d
+    tmux split-window -t zrepl "tail -f /var/log/messages"
+    tmux split-window -t zrepl "gnu-watch 'zfs list -t snapshot -o name,creation -s creation | grep zrepl_'"
+    tmux split-window -t zrepl "zrepl status"
+    tmux select-layout -t zrepl tiled
+    tmux attach -t zrepl
 
 The Linux equivalent might look like this: ::
 
     # make sure tmux is installed & let's assume you use systemd + journald
-    tmux new-window
-    tmux split-window "journalctl -f -u zrepl.service"
-    tmux split-window "watch 'zfs list -t snapshot -o name,creation -s creation | grep zrepl_'"
-    tmux select-layout tiled
+    tmux new -s zrepl -d
+    tmux split-window -t zrepl  "journalctl -f -u zrepl.service"
+    tmux split-window -t zrepl "watch 'zfs list -t snapshot -o name,creation -s creation | grep zrepl_'"
+    tmux split-window -t zrepl "zrepl status"
+    tmux select-layout -t zrepl tiled
+    tmux attach -t zrepl
 
 Summary
 -------
 
-Congratulations, you have a working pull backup. Where to go next?
+Congratulations, you have a working push backup. Where to go next?
 
 * Read more about :ref:`configuration format, options & job types <configuration_toc>`
 * Configure :ref:`logging <logging>` \& :ref:`monitoring <monitoring>`.

docs/usage.rst

@@ -13,6 +13,8 @@ CLI Overview
     The zrepl binary is self-documenting:
     run ``zrepl help`` for an overview of the available subcommands or ``zrepl SUBCOMMAND --help`` for information on available flags, etc.
 
+.. _cli-signal-wakeup:
+
 .. list-table::
     :widths: 30 70
     :header-rows: 1
@@ -27,10 +29,15 @@ CLI Overview
       - show job activity, or with ``--raw`` for JSON output
     * - ``zrepl stdinserver``
       - see :ref:`transport-ssh+stdinserver`
-    * - ``zrepl wakeup JOB``
-      - manually trigger replication + pruning
+    * - ``zrepl signal wakeup JOB``
+      - manually trigger replication + pruning of JOB
+    * - ``zrepl signal reset JOB``
+      - manually abort current replication + pruning of JOB
     * - ``zrepl configcheck``
       - check if config can be parsed without errors
+    * - ``zrepl migrate``
+      - | perform on-disk state / ZFS property migrations
+        | (see :ref:`changelog <changelog>` for details)
 
 .. _usage-zrepl-daemon:
 
@@ -62,3 +69,10 @@ Restarting
 The daemon handles SIGINT and SIGTERM for graceful shutdown.
 Graceful shutdown means at worst that a job will not be rescheduled for the next interval.
 The daemon exits as soon as all jobs have reported shut down.
+
+Systemd Unit File
+~~~~~~~~~~~~~~~~~
+
+A systemd service defintion template is available in :repomasterlink:`dist/systemd`.
+Note that some of the options only work on recent versions of systemd.
+Any help & improvements are very welcome, see :issue:`145`.

endpoint/context.go

@@ -9,6 +9,7 @@ type contextKey int
 
 const (
 	contextKeyLogger contextKey = iota
+	ClientIdentityKey
 )
 
 type Logger = logger.Logger

endpoint/endpoint.go

@@ -2,21 +2,19 @@
 package endpoint
 
 import (
-	"bytes"
 	"context"
 	"fmt"
-	"github.com/golang/protobuf/proto"
+	"path"
+
 	"github.com/pkg/errors"
-	"github.com/problame/go-streamrpc"
-	"github.com/zrepl/zrepl/replication"
-	"github.com/zrepl/zrepl/replication/pdu"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
+	"github.com/zrepl/zrepl/util/chainlock"
 	"github.com/zrepl/zrepl/zfs"
-	"io"
 )
 
 // Sender implements replication.ReplicationEndpoint for a sending side
 type Sender struct {
-	FSFilter                zfs.DatasetFilter
+	FSFilter zfs.DatasetFilter
 }
 
 func NewSender(fsf zfs.DatasetFilter) *Sender {
@@ -36,13 +34,13 @@ func (s *Sender) filterCheckFS(fs string) (*zfs.DatasetPath, error) {
 		return nil, err
 	}
 	if !pass {
-		return nil, replication.NewFilteredError(fs)
+		return nil, fmt.Errorf("endpoint does not allow access to filesystem %s", fs)
 	}
 	return dp, nil
 }
 
-func (p *Sender) ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error) {
-	fss, err := zfs.ZFSListMapping(p.FSFilter)
+func (s *Sender) ListFilesystems(ctx context.Context, r *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error) {
+	fss, err := zfs.ZFSListMapping(ctx, s.FSFilter)
 	if err != nil {
 		return nil, err
 	}
@@ -51,13 +49,15 @@ func (p *Sender) ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error)
 		rfss[i] = &pdu.Filesystem{
 			Path: fss[i].ToString(),
 			// FIXME: not supporting ResumeToken yet
+			IsPlaceholder: false, // sender FSs are never placeholders
 		}
 	}
-	return rfss, nil
+	res := &pdu.ListFilesystemRes{Filesystems: rfss}
+	return res, nil
 }
 
-func (p *Sender) ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.FilesystemVersion, error) {
-	lp, err := p.filterCheckFS(fs)
+func (s *Sender) ListFilesystemVersions(ctx context.Context, r *pdu.ListFilesystemVersionsReq) (*pdu.ListFilesystemVersionsRes, error) {
+	lp, err := s.filterCheckFS(r.GetFilesystem())
 	if err != nil {
 		return nil, err
 	}
@@ -69,31 +69,36 @@ func (p *Sender) ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.
 	for i := range fsvs {
 		rfsvs[i] = pdu.FilesystemVersionFromZFS(&fsvs[i])
 	}
-	return rfsvs, nil
+	res := &pdu.ListFilesystemVersionsRes{Versions: rfsvs}
+	return res, nil
+
 }
 
-func (p *Sender) Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, io.ReadCloser, error) {
-	_, err := p.filterCheckFS(r.Filesystem)
+func (s *Sender) Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, zfs.StreamCopier, error) {
+	_, err := s.filterCheckFS(r.Filesystem)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	if r.DryRun {
-		size, err := zfs.ZFSSendDry(r.Filesystem, r.From, r.To)
-		if err == zfs.BookmarkSizeEstimationNotSupported {
-			return &pdu.SendRes{ExpectedSize: 0}, nil, nil
-		}
-		if err != nil {
-			return nil, nil, err
-		}
-		return &pdu.SendRes{ExpectedSize: size}, nil, nil
-	} else {
-		stream, err := zfs.ZFSSend(r.Filesystem, r.From, r.To)
-		if err != nil {
-			return nil, nil, err
-		}
-		return &pdu.SendRes{}, stream, nil
+	si, err := zfs.ZFSSendDry(r.Filesystem, r.From, r.To, "")
+	if err != nil {
+		return nil, nil, err
 	}
+	var expSize int64 = 0      // protocol says 0 means no estimate
+	if si.SizeEstimate != -1 { // but si returns -1 for no size estimate
+		expSize = si.SizeEstimate
+	}
+	res := &pdu.SendRes{ExpectedSize: expSize}
+
+	if r.DryRun {
+		return res, nil, nil
+	}
+
+	streamCopier, err := zfs.ZFSSend(ctx, r.Filesystem, r.From, r.To, "")
+	if err != nil {
+		return nil, nil, err
+	}
+	return res, streamCopier, nil
 }
 
 func (p *Sender) DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error) {
@@ -104,6 +109,21 @@ func (p *Sender) DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshots
 	return doDestroySnapshots(ctx, dp, req.Snapshots)
 }
 
+func (p *Sender) Ping(ctx context.Context, req *pdu.PingReq) (*pdu.PingRes, error) {
+	res := pdu.PingRes{
+		Echo: req.GetMessage(),
+	}
+	return &res, nil
+}
+
+func (p *Sender) PingDataconn(ctx context.Context, req *pdu.PingReq) (*pdu.PingRes, error) {
+	return p.Ping(ctx, req)
+}
+
+func (p *Sender) WaitForConnectivity(ctx context.Context) error {
+	return nil
+}
+
 func (p *Sender) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error) {
 	dp, err := p.filterCheckFS(req.Filesystem)
 	if err != nil {
@@ -117,7 +137,7 @@ func (p *Sender) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCurs
 			return nil, err
 		}
 		if cursor == nil {
-			return &pdu.ReplicationCursorRes{Result: &pdu.ReplicationCursorRes_Error{Error: "cursor does not exist"}}, nil
+			return &pdu.ReplicationCursorRes{Result: &pdu.ReplicationCursorRes_Notexist{Notexist: true}}, nil
 		}
 		return &pdu.ReplicationCursorRes{Result: &pdu.ReplicationCursorRes_Guid{Guid: cursor.Guid}}, nil
 	case *pdu.ReplicationCursorReq_Set:
@@ -131,6 +151,10 @@ func (p *Sender) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCurs
 	}
 }
 
+func (p *Sender) Receive(ctx context.Context, r *pdu.ReceiveReq, receive zfs.StreamCopier) (*pdu.ReceiveRes, error) {
+	return nil, fmt.Errorf("sender does not implement Receive()")
+}
+
 type FSFilter interface { // FIXME unused
 	Filter(path *zfs.DatasetPath) (pass bool, err error)
 }
@@ -145,14 +169,56 @@ type FSMap interface { // FIXME unused
 
 // Receiver implements replication.ReplicationEndpoint for a receiving side
 type Receiver struct {
-	root *zfs.DatasetPath
+	rootWithoutClientComponent *zfs.DatasetPath
+	appendClientIdentity       bool
+
+	recvParentCreationMtx *chainlock.L
 }
 
-func NewReceiver(rootDataset *zfs.DatasetPath) (*Receiver, error) {
+func NewReceiver(rootDataset *zfs.DatasetPath, appendClientIdentity bool) *Receiver {
 	if rootDataset.Length() <= 0 {
-		return nil, errors.New("root dataset must not be an empty path")
+		panic(fmt.Sprintf("root dataset must not be an empty path: %v", rootDataset))
 	}
-	return &Receiver{root: rootDataset.Copy()}, nil
+	return &Receiver{
+		rootWithoutClientComponent: rootDataset.Copy(),
+		appendClientIdentity:       appendClientIdentity,
+		recvParentCreationMtx:      chainlock.New(),
+	}
+}
+
+func TestClientIdentity(rootFS *zfs.DatasetPath, clientIdentity string) error {
+	_, err := clientRoot(rootFS, clientIdentity)
+	return err
+}
+
+func clientRoot(rootFS *zfs.DatasetPath, clientIdentity string) (*zfs.DatasetPath, error) {
+	rootFSLen := rootFS.Length()
+	clientRootStr := path.Join(rootFS.ToString(), clientIdentity)
+	clientRoot, err := zfs.NewDatasetPath(clientRootStr)
+	if err != nil {
+		return nil, err
+	}
+	if rootFSLen+1 != clientRoot.Length() {
+		return nil, fmt.Errorf("client identity must be a single ZFS filesystem path component")
+	}
+	return clientRoot, nil
+}
+
+func (s *Receiver) clientRootFromCtx(ctx context.Context) *zfs.DatasetPath {
+	if !s.appendClientIdentity {
+		return s.rootWithoutClientComponent.Copy()
+	}
+
+	clientIdentity, ok := ctx.Value(ClientIdentityKey).(string)
+	if !ok {
+		panic(fmt.Sprintf("ClientIdentityKey context value must be set"))
+	}
+
+	clientRoot, err := clientRoot(s.rootWithoutClientComponent, clientIdentity)
+	if err != nil {
+		panic(fmt.Sprintf("ClientIdentityContextKey must have been validated before invoking Receiver: %s", err))
+	}
+	return clientRoot
 }
 
 type subroot struct {
@@ -179,33 +245,40 @@ func (f subroot) MapToLocal(fs string) (*zfs.DatasetPath, error) {
 	return c, nil
 }
 
-func (e *Receiver) ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error) {
-	filtered, err := zfs.ZFSListMapping(subroot{e.root})
+func (s *Receiver) ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error) {
+	root := s.clientRootFromCtx(ctx)
+	filtered, err := zfs.ZFSListMapping(ctx, subroot{root})
 	if err != nil {
 		return nil, err
 	}
-	// present without prefix, and only those that are not placeholders
+	// present filesystem without the root_fs prefix
 	fss := make([]*pdu.Filesystem, 0, len(filtered))
 	for _, a := range filtered {
-		ph, err := zfs.ZFSIsPlaceholderFilesystem(a)
+		l := getLogger(ctx).WithField("fs", a)
+		ph, err := zfs.ZFSGetFilesystemPlaceholderState(a)
 		if err != nil {
-			getLogger(ctx).
-				WithError(err).
-				WithField("fs", a).
-				Error("inconsistent placeholder property")
-			return nil, errors.New("server error, see logs") // don't leak path
+			l.WithError(err).Error("error getting placeholder state")
+			return nil, errors.Wrapf(err, "cannot get placeholder state for fs %q", a)
 		}
-		if ph {
-			continue
+		l.WithField("placeholder_state", fmt.Sprintf("%#v", ph)).Debug("placeholder state")
+		if !ph.FSExists {
+			l.Error("inconsistent placeholder state: filesystem must exists")
+			err := errors.Errorf("inconsistent placeholder state: filesystem %q must exist in this context", a.ToString())
+			return nil, err
 		}
-		a.TrimPrefix(e.root)
-		fss = append(fss, &pdu.Filesystem{Path: a.ToString()})
+		a.TrimPrefix(root)
+		fss = append(fss, &pdu.Filesystem{Path: a.ToString(), IsPlaceholder: ph.IsPlaceholder})
 	}
-	return fss, nil
+	if len(fss) == 0 {
+		getLogger(ctx).Debug("no filesystems found")
+		return &pdu.ListFilesystemRes{}, nil
+	}
+	return &pdu.ListFilesystemRes{Filesystems: fss}, nil
 }
 
-func (e *Receiver) ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.FilesystemVersion, error) {
-	lp, err := subroot{e.root}.MapToLocal(fs)
+func (s *Receiver) ListFilesystemVersions(ctx context.Context, req *pdu.ListFilesystemVersionsReq) (*pdu.ListFilesystemVersionsRes, error) {
+	root := s.clientRootFromCtx(ctx)
+	lp, err := subroot{root}.MapToLocal(req.GetFilesystem())
 	if err != nil {
 		return nil, err
 	}
@@ -220,77 +293,123 @@ func (e *Receiver) ListFilesystemVersions(ctx context.Context, fs string) ([]*pd
 		rfsvs[i] = pdu.FilesystemVersionFromZFS(&fsvs[i])
 	}
 
-	return rfsvs, nil
+	return &pdu.ListFilesystemVersionsRes{Versions: rfsvs}, nil
 }
 
-func (e *Receiver) Receive(ctx context.Context, req *pdu.ReceiveReq, sendStream io.ReadCloser) error {
-	defer sendStream.Close()
-
-	lp, err := subroot{e.root}.MapToLocal(req.Filesystem)
-	if err != nil {
-		return err
+func (s *Receiver) Ping(ctx context.Context, req *pdu.PingReq) (*pdu.PingRes, error) {
+	res := pdu.PingRes{
+		Echo: req.GetMessage(),
 	}
+	return &res, nil
+}
 
-	getLogger(ctx).Debug("incoming Receive")
+func (s *Receiver) PingDataconn(ctx context.Context, req *pdu.PingReq) (*pdu.PingRes, error) {
+	return s.Ping(ctx, req)
+}
 
-	// create placeholder parent filesystems as appropriate
-	var visitErr error
-	f := zfs.NewDatasetPathForest()
-	f.Add(lp)
-	getLogger(ctx).Debug("begin tree-walk")
-	f.WalkTopDown(func(v zfs.DatasetPathVisit) (visitChildTree bool) {
-		if v.Path.Equal(lp) {
-			return false
-		}
-		_, err := zfs.ZFSGet(v.Path, []string{zfs.ZREPL_PLACEHOLDER_PROPERTY_NAME})
-		if err != nil {
-			// interpret this as an early exit of the zfs binary due to the fs not existing
-			if err := zfs.ZFSCreatePlaceholderFilesystem(v.Path); err != nil {
-				getLogger(ctx).
-					WithError(err).
-					WithField("placeholder_fs", v.Path).
-					Error("cannot create placeholder filesystem")
-				visitErr = err
-				return false
-			}
-		}
-		getLogger(ctx).WithField("filesystem", v.Path.ToString()).Debug("exists")
-		return true // leave this fs as is
-	})
-	getLogger(ctx).WithField("visitErr", visitErr).Debug("complete tree-walk")
-
-	if visitErr != nil {
-		return visitErr
-	}
-
-	needForceRecv := false
-	props, err := zfs.ZFSGet(lp, []string{zfs.ZREPL_PLACEHOLDER_PROPERTY_NAME})
-	if err == nil {
-		if isPlaceholder, _ := zfs.IsPlaceholder(lp, props.Get(zfs.ZREPL_PLACEHOLDER_PROPERTY_NAME)); isPlaceholder {
-			needForceRecv = true
-		}
-	}
-
-	args := make([]string, 0, 1)
-	if needForceRecv {
-		args = append(args, "-F")
-	}
-
-	getLogger(ctx).Debug("start receive command")
-
-	if err := zfs.ZFSRecv(lp.ToString(), sendStream, args...); err != nil {
-		getLogger(ctx).
-			WithError(err).
-			WithField("args", args).
-			Error("zfs receive failed")
-		sendStream.Close()
-		return err
-	}
+func (s *Receiver) WaitForConnectivity(ctx context.Context) error {
 	return nil
 }
 
-func (e *Receiver) DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error) {
-	lp, err := subroot{e.root}.MapToLocal(req.Filesystem)
+func (s *Receiver) ReplicationCursor(context.Context, *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error) {
+	return nil, fmt.Errorf("ReplicationCursor not implemented for Receiver")
+}
+
+func (s *Receiver) Send(ctx context.Context, req *pdu.SendReq) (*pdu.SendRes, zfs.StreamCopier, error) {
+	return nil, nil, fmt.Errorf("receiver does not implement Send()")
+}
+
+func (s *Receiver) Receive(ctx context.Context, req *pdu.ReceiveReq, receive zfs.StreamCopier) (*pdu.ReceiveRes, error) {
+	getLogger(ctx).Debug("incoming Receive")
+	defer receive.Close()
+
+	root := s.clientRootFromCtx(ctx)
+	lp, err := subroot{root}.MapToLocal(req.Filesystem)
+	if err != nil {
+		return nil, err
+	}
+
+	// create placeholder parent filesystems as appropriate
+	//
+	// Manipulating the ZFS dataset hierarchy must happen exclusively.
+	// TODO: Use fine-grained locking to allow separate clients / requests to pass
+	// 		 through the following section concurrently when operating on disjoint
+	//       ZFS dataset hierarchy subtrees.
+	var visitErr error
+	func() {
+		getLogger(ctx).Debug("begin aquire recvParentCreationMtx")
+		defer s.recvParentCreationMtx.Lock().Unlock()
+		getLogger(ctx).Debug("end aquire recvParentCreationMtx")
+		defer getLogger(ctx).Debug("release recvParentCreationMtx")
+
+		f := zfs.NewDatasetPathForest()
+		f.Add(lp)
+		getLogger(ctx).Debug("begin tree-walk")
+		f.WalkTopDown(func(v zfs.DatasetPathVisit) (visitChildTree bool) {
+			if v.Path.Equal(lp) {
+				return false
+			}
+			ph, err := zfs.ZFSGetFilesystemPlaceholderState(v.Path)
+			getLogger(ctx).
+				WithField("fs", v.Path.ToString()).
+				WithField("placeholder_state", fmt.Sprintf("%#v", ph)).
+				WithField("err", fmt.Sprintf("%s", err)).
+				WithField("errType", fmt.Sprintf("%T", err)).
+				Debug("placeholder state for filesystem")
+			if err != nil {
+				visitErr = err
+				return false
+			}
+
+			if !ph.FSExists {
+				l := getLogger(ctx).WithField("placeholder_fs", v.Path)
+				l.Debug("create placeholder filesystem")
+				err := zfs.ZFSCreatePlaceholderFilesystem(v.Path)
+				if err != nil {
+					l.WithError(err).Error("cannot create placeholder filesystem")
+					visitErr = err
+					return false
+				}
+				return true
+			}
+			getLogger(ctx).WithField("filesystem", v.Path.ToString()).Debug("exists")
+			return true // leave this fs as is
+		})
+	}()
+	getLogger(ctx).WithField("visitErr", visitErr).Debug("complete tree-walk")
+	if visitErr != nil {
+		return nil, visitErr
+	}
+
+	// determine whether we need to rollback the filesystem / change its placeholder state
+	var clearPlaceholderProperty bool
+	var recvOpts zfs.RecvOptions
+	ph, err := zfs.ZFSGetFilesystemPlaceholderState(lp)
+	if err == nil && ph.FSExists && ph.IsPlaceholder {
+		recvOpts.RollbackAndForceRecv = true
+		clearPlaceholderProperty = true
+	}
+	if clearPlaceholderProperty {
+		if err := zfs.ZFSSetPlaceholder(lp, false); err != nil {
+			return nil, fmt.Errorf("cannot clear placeholder property for forced receive: %s", err)
+		}
+	}
+
+	getLogger(ctx).WithField("opts", fmt.Sprintf("%#v", recvOpts)).Debug("start receive command")
+
+	if err := zfs.ZFSRecv(ctx, lp.ToString(), receive, recvOpts); err != nil {
+		getLogger(ctx).
+			WithError(err).
+			WithField("opts", recvOpts).
+			Error("zfs receive failed")
+		return nil, err
+	}
+	return &pdu.ReceiveRes{}, nil
+}
+
+func (s *Receiver) DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error) {
+	root := s.clientRootFromCtx(ctx)
+	lp, err := subroot{root}.MapToLocal(req.Filesystem)
 	if err != nil {
 		return nil, err
 	}
@@ -325,289 +444,3 @@ func doDestroySnapshots(ctx context.Context, lp *zfs.DatasetPath, snaps []*pdu.F
 	}
 	return res, nil
 }
-
-// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-// RPC STUBS
-// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-const (
-	RPCListFilesystems        = "ListFilesystems"
-	RPCListFilesystemVersions = "ListFilesystemVersions"
-	RPCReceive                = "Receive"
-	RPCSend                   = "Send"
-	RPCSDestroySnapshots      = "DestroySnapshots"
-	RPCReplicationCursor      = "ReplicationCursor"
-)
-
-// Remote implements an endpoint stub that uses streamrpc as a transport.
-type Remote struct {
-	c *streamrpc.Client
-}
-
-func NewRemote(c *streamrpc.Client) Remote {
-	return Remote{c}
-}
-
-func (s Remote) ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error) {
-	req := pdu.ListFilesystemReq{}
-	b, err := proto.Marshal(&req)
-	if err != nil {
-		return nil, err
-	}
-	rb, rs, err := s.c.RequestReply(ctx, RPCListFilesystems, bytes.NewBuffer(b), nil)
-	if err != nil {
-		return nil, err
-	}
-	if rs != nil {
-		rs.Close()
-		return nil, errors.New("response contains unexpected stream")
-	}
-	var res pdu.ListFilesystemRes
-	if err := proto.Unmarshal(rb.Bytes(), &res); err != nil {
-		return nil, err
-	}
-	return res.Filesystems, nil
-}
-
-func (s Remote) ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.FilesystemVersion, error) {
-	req := pdu.ListFilesystemVersionsReq{
-		Filesystem: fs,
-	}
-	b, err := proto.Marshal(&req)
-	if err != nil {
-		return nil, err
-	}
-	rb, rs, err := s.c.RequestReply(ctx, RPCListFilesystemVersions, bytes.NewBuffer(b), nil)
-	if err != nil {
-		return nil, err
-	}
-	if rs != nil {
-		rs.Close()
-		return nil, errors.New("response contains unexpected stream")
-	}
-	var res pdu.ListFilesystemVersionsRes
-	if err := proto.Unmarshal(rb.Bytes(), &res); err != nil {
-		return nil, err
-	}
-	return res.Versions, nil
-}
-
-func (s Remote) Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, io.ReadCloser, error) {
-	b, err := proto.Marshal(r)
-	if err != nil {
-		return nil, nil, err
-	}
-	rb, rs, err := s.c.RequestReply(ctx, RPCSend, bytes.NewBuffer(b), nil)
-	if err != nil {
-		return nil, nil, err
-	}
-	if !r.DryRun && rs == nil {
-		return nil, nil, errors.New("response does not contain a stream")
-	}
-	if r.DryRun && rs != nil {
-		rs.Close()
-		return nil, nil, errors.New("response contains unexpected stream (was dry run)")
-	}
-	var res pdu.SendRes
-	if err := proto.Unmarshal(rb.Bytes(), &res); err != nil {
-		rs.Close()
-		return nil, nil, err
-	}
-	return &res, rs, nil
-}
-
-func (s Remote) Receive(ctx context.Context, r *pdu.ReceiveReq, sendStream io.ReadCloser) error {
-	defer sendStream.Close()
-	b, err := proto.Marshal(r)
-	if err != nil {
-		return err
-	}
-	rb, rs, err := s.c.RequestReply(ctx, RPCReceive, bytes.NewBuffer(b), sendStream)
-	getLogger(ctx).WithField("err", err).Debug("Remote.Receive RequestReplyReturned")
-	if err != nil {
-		return err
-	}
-	if rs != nil {
-		rs.Close()
-		return errors.New("response contains unexpected stream")
-	}
-	var res pdu.ReceiveRes
-	if err := proto.Unmarshal(rb.Bytes(), &res); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (s Remote) DestroySnapshots(ctx context.Context, r *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error) {
-	b, err := proto.Marshal(r)
-	if err != nil {
-		return nil, err
-	}
-	rb, rs, err := s.c.RequestReply(ctx, RPCSDestroySnapshots, bytes.NewBuffer(b), nil)
-	if err != nil {
-		return nil, err
-	}
-	if rs != nil {
-		rs.Close()
-		return nil, errors.New("response contains unexpected stream")
-	}
-	var res pdu.DestroySnapshotsRes
-	if err := proto.Unmarshal(rb.Bytes(), &res); err != nil {
-		return nil, err
-	}
-	return &res, nil
-}
-
-func (s Remote) ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error) {
-	b, err := proto.Marshal(req)
-	if err != nil {
-		return nil, err
-	}
-	rb, rs, err := s.c.RequestReply(ctx, RPCReplicationCursor, bytes.NewBuffer(b), nil)
-	if err != nil {
-		return nil, err
-	}
-	if rs != nil {
-		rs.Close()
-		return nil, errors.New("response contains unexpected stream")
-	}
-	var res pdu.ReplicationCursorRes
-	if err := proto.Unmarshal(rb.Bytes(), &res); err != nil {
-		return nil, err
-	}
-	return &res, nil
-}
-
-// Handler implements the server-side streamrpc.HandlerFunc for a Remote endpoint stub.
-type Handler struct {
-	ep replication.Endpoint
-}
-
-func NewHandler(ep replication.Endpoint) Handler {
-	return Handler{ep}
-}
-
-func (a *Handler) Handle(ctx context.Context, endpoint string, reqStructured *bytes.Buffer, reqStream io.ReadCloser) (resStructured *bytes.Buffer, resStream io.ReadCloser, err error) {
-
-	switch endpoint {
-	case RPCListFilesystems:
-		var req pdu.ListFilesystemReq
-		if err := proto.Unmarshal(reqStructured.Bytes(), &req); err != nil {
-			return nil, nil, err
-		}
-		fsses, err := a.ep.ListFilesystems(ctx)
-		if err != nil {
-			return nil, nil, err
-		}
-		res := &pdu.ListFilesystemRes{
-			Filesystems: fsses,
-		}
-		b, err := proto.Marshal(res)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bytes.NewBuffer(b), nil, nil
-
-	case RPCListFilesystemVersions:
-
-		var req pdu.ListFilesystemVersionsReq
-		if err := proto.Unmarshal(reqStructured.Bytes(), &req); err != nil {
-			return nil, nil, err
-		}
-		fsvs, err := a.ep.ListFilesystemVersions(ctx, req.Filesystem)
-		if err != nil {
-			return nil, nil, err
-		}
-		res := &pdu.ListFilesystemVersionsRes{
-			Versions: fsvs,
-		}
-		b, err := proto.Marshal(res)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bytes.NewBuffer(b), nil, nil
-
-	case RPCSend:
-
-		sender, ok := a.ep.(replication.Sender)
-		if !ok {
-			goto Err
-		}
-
-		var req pdu.SendReq
-		if err := proto.Unmarshal(reqStructured.Bytes(), &req); err != nil {
-			return nil, nil, err
-		}
-		res, sendStream, err := sender.Send(ctx, &req)
-		if err != nil {
-			return nil, nil, err
-		}
-		b, err := proto.Marshal(res)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bytes.NewBuffer(b), sendStream, err
-
-	case RPCReceive:
-
-		receiver, ok := a.ep.(replication.Receiver)
-		if !ok {
-			goto Err
-		}
-
-		var req pdu.ReceiveReq
-		if err := proto.Unmarshal(reqStructured.Bytes(), &req); err != nil {
-			return nil, nil, err
-		}
-		err := receiver.Receive(ctx, &req, reqStream)
-		if err != nil {
-			return nil, nil, err
-		}
-		b, err := proto.Marshal(&pdu.ReceiveRes{})
-		if err != nil {
-			return nil, nil, err
-		}
-		return bytes.NewBuffer(b), nil, err
-
-	case RPCSDestroySnapshots:
-
-		var req pdu.DestroySnapshotsReq
-		if err := proto.Unmarshal(reqStructured.Bytes(), &req); err != nil {
-			return nil, nil, err
-		}
-
-		res, err := a.ep.DestroySnapshots(ctx, &req)
-		if err != nil {
-			return nil, nil, err
-		}
-		b, err := proto.Marshal(res)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bytes.NewBuffer(b), nil, nil
-
-	case RPCReplicationCursor:
-
-		sender, ok := a.ep.(replication.Sender)
-		if !ok {
-			goto Err
-		}
-
-		var req pdu.ReplicationCursorReq
-		if err := proto.Unmarshal(reqStructured.Bytes(), &req); err != nil {
-			return nil, nil, err
-		}
-		res, err := sender.ReplicationCursor(ctx, &req)
-		if err != nil {
-			return nil, nil, err
-		}
-		b, err := proto.Marshal(res)
-		if err != nil {
-			return nil, nil, err
-		}
-		return bytes.NewBuffer(b), nil, nil
-
-	}
-Err:
-	return nil, nil, errors.New("no handler for given endpoint")
-}

lazy.sh

@@ -25,23 +25,26 @@ fi
 
 CHECKOUTPATH="${GOPATH}/src/github.com/zrepl/zrepl"
 
-builddep() {
-    step "Install build depdencies using 'go get' to \$GOPATH/bin"
-    go get -u golang.org/x/tools/cmd/stringer
+godep() {
+    step "Install go dep using 'go get' to \$GOPATH/bin"
     go get -u github.com/golang/dep/cmd/dep
-    go get -u github.com/golang/protobuf/protoc-gen-go
-    go get -u github.com/alvaroloes/enumer
-    if ! type stringer || ! type dep || ! type protoc-gen-go || ! type enumer ; then
+    if ! type dep ; then
+        echo "Unable to install go dep" 1>&2
+        exit 1
+    fi
+    step "Fetching dependencies using 'dep ensure'"
+    dep ensure -v -vendor-only
+    step "go install build dependencies fetched using dep"
+    # these will be in the vendor directory
+    go build -o "$GOPATH/bin/stringer"      ./vendor/golang.org/x/tools/cmd/stringer
+    go build -o "$GOPATH/bin/protoc-gen-go" ./vendor/github.com/golang/protobuf/protoc-gen-go
+    go build -o "$GOPATH/bin/enumer"        ./vendor/github.com/alvaroloes/enumer
+    if ! type stringer || ! type protoc-gen-go || ! type enumer ; then
         echo "Installed dependencies but can't find them in \$PATH, adjust it to contain \$GOPATH/bin" 1>&2
         exit 1
     fi
 }
 
-godep() {
-    step "Fetching dependencies using 'dep ensure'"
-    dep ensure
-}
-
 docdep() {
     if ! type pip3; then
         step "pip3 binary not installed or not in \$PATH" 1>&2
@@ -62,13 +65,13 @@ release() {
 
 for cmd in "$@"; do
     case "$cmd" in
-        builddep|godep|docdep|release_bins|docs)
+        godep|docdep|release_bins|docs)
             eval $cmd
             continue
             ;;
         devsetup)
             step "Installing development dependencies"
-            builddep
+            godep
             docdep
             step "Development dependencies installed"
             continue

logger/stderrlogger.go

@@ -0,0 +1,27 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+)
+
+type stderrLogger struct {
+	Logger
+}
+
+type stderrLoggerOutlet struct {}
+
+func (stderrLoggerOutlet) WriteEntry(entry Entry) error {
+	fmt.Fprintf(os.Stderr, "%#v\n", entry)
+	return nil
+}
+
+var _ Logger = testLogger{}
+
+func NewStderrDebugLogger() Logger {
+	outlets := NewOutlets()
+	outlets.Add(&stderrLoggerOutlet{}, Debug)
+	return &testLogger{
+		Logger: NewLogger(outlets, 0),
+	}
+}

main.go

@@ -16,6 +16,7 @@ func init() {
 	cli.AddSubcommand(client.VersionCmd)
 	cli.AddSubcommand(client.PprofCmd)
 	cli.AddSubcommand(client.TestCmd)
+	cli.AddSubcommand(client.MigrateCmd)
 }
 
 func main() {

pruning/keep_regex.go

@@ -6,20 +6,21 @@ import (
 
 type KeepRegex struct {
 	expr *regexp.Regexp
+	negate bool
 }
 
 var _ KeepRule = &KeepRegex{}
 
-func NewKeepRegex(expr string) (*KeepRegex, error) {
+func NewKeepRegex(expr string, negate bool) (*KeepRegex, error) {
 	re, err := regexp.Compile(expr)
 	if err != nil {
 		return nil, err
 	}
-	return &KeepRegex{re}, nil
+	return &KeepRegex{re, negate}, nil
 }
 
-func MustKeepRegex(expr string) *KeepRegex {
-	k, err := NewKeepRegex(expr)
+func MustKeepRegex(expr string, negate bool) *KeepRegex {
+	k, err := NewKeepRegex(expr, negate)
 	if err != nil {
 		panic(err)
 	}
@@ -28,6 +29,10 @@ func MustKeepRegex(expr string) *KeepRegex {
 
 func (k *KeepRegex) KeepRule(snaps []Snapshot) []Snapshot {
 	return filterSnapList(snaps, func(s Snapshot) bool {
-		return k.expr.FindStringIndex(s.Name()) == nil
+		if k.negate {
+			return k.expr.FindStringIndex(s.Name()) != nil
+		} else {
+			return k.expr.FindStringIndex(s.Name()) == nil
+		}
 	})
 }

pruning/keep_regex_test.go

@@ -0,0 +1,32 @@
+package pruning
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKeepRegexNegation(t *testing.T) {
+
+	noneg := MustKeepRegex("^zrepl_", false)
+	neg := MustKeepRegex("^zrepl_", true)
+
+	snaps := []Snapshot{
+		stubSnap{name: "zrepl_foobar"},
+		stubSnap{name: "zrepl"},
+		stubSnap{name: "barfoo"},
+	}
+
+	destroyNonNeg := snapshotList(noneg.KeepRule(snaps))
+	t.Logf("non-negated rule destroys: %#v", destroyNonNeg.NameList())
+	assert.True(t, destroyNonNeg.ContainsName("zrepl"))
+	assert.True(t, destroyNonNeg.ContainsName("barfoo"))
+	assert.False(t, destroyNonNeg.ContainsName("zrepl_foobar"))
+
+	destroyNeg := snapshotList(neg.KeepRule(snaps))
+	t.Logf("negated rule destroys: %#v", destroyNeg.NameList())
+	assert.False(t, destroyNeg.ContainsName("zrepl"))
+	assert.False(t, destroyNeg.ContainsName("barfoo"))
+	assert.True(t, destroyNeg.ContainsName("zrepl_foobar"))
+
+}

pruning/pruning.go

@@ -60,7 +60,7 @@ func RuleFromConfig(in config.PruningEnum) (KeepRule, error) {
 	case *config.PruneKeepLastN:
 		return NewKeepLastN(v.Count)
 	case *config.PruneKeepRegex:
-		return NewKeepRegex(v.Regex)
+		return NewKeepRegex(v.Regex, v.Negate)
 	case *config.PruneGrid:
 		return NewKeepGrid(v)
 	default:

pruning/pruning_test.go

@@ -24,6 +24,25 @@ type testCase struct {
 	expDestroyAlternatives []map[string]bool
 }
 
+type snapshotList []Snapshot
+
+func (l snapshotList) ContainsName(n string) bool {
+	for _, s := range l {
+		if s.Name() == n {
+			return true
+		}
+	}
+	return false
+}
+
+func (l snapshotList) NameList() []string {
+	res := make([]string, len(l))
+	for i, s := range l {
+		res[i] = s.Name()
+	}
+	return res
+}
+
 func testTable(tcs map[string]testCase, t *testing.T) {
 	mapEqual := func(a, b map[string]bool) bool {
 		if len(a) != len(b) {
@@ -79,7 +98,7 @@ func TestPruneSnapshots(t *testing.T) {
 		"simple": {
 			inputs: inputs["s1"],
 			rules: []KeepRule{
-				MustKeepRegex("foo_"),
+				MustKeepRegex("foo_", false),
 			},
 			expDestroy: map[string]bool{
 				"bar_123": true,
@@ -88,16 +107,16 @@ func TestPruneSnapshots(t *testing.T) {
 		"multipleRules": {
 			inputs: inputs["s1"],
 			rules: []KeepRule{
-				MustKeepRegex("foo_"),
-				MustKeepRegex("bar_"),
+				MustKeepRegex("foo_", false),
+				MustKeepRegex("bar_", false),
 			},
 			expDestroy: map[string]bool{},
 		},
 		"onlyThoseRemovedByAllAreRemoved": {
 			inputs: inputs["s1"],
 			rules: []KeepRule{
-				MustKeepRegex("notInS1"), // would remove all
-				MustKeepRegex("bar_"),    // would remove all but bar_, i.e. foo_.*
+				MustKeepRegex("notInS1", false), // would remove all
+				MustKeepRegex("bar_", false),    // would remove all but bar_, i.e. foo_.*
 			},
 			expDestroy: map[string]bool{
 				"foo_123": true,
@@ -117,7 +136,7 @@ func TestPruneSnapshots(t *testing.T) {
 		"noSnaps": {
 			inputs: []Snapshot{},
 			rules: []KeepRule{
-				MustKeepRegex("foo_"),
+				MustKeepRegex("foo_", false),
 			},
 			expDestroy: map[string]bool{},
 		},

replication/driver/errorclass_enumer.go

@@ -0,0 +1,50 @@
+// Code generated by "enumer -type=errorClass"; DO NOT EDIT.
+
+package driver
+
+import (
+	"fmt"
+)
+
+const _errorClassName = "errorClassUnknownerrorClassPermanenterrorClassTemporaryConnectivityRelated"
+
+var _errorClassIndex = [...]uint8{0, 17, 36, 74}
+
+func (i errorClass) String() string {
+	if i < 0 || i >= errorClass(len(_errorClassIndex)-1) {
+		return fmt.Sprintf("errorClass(%d)", i)
+	}
+	return _errorClassName[_errorClassIndex[i]:_errorClassIndex[i+1]]
+}
+
+var _errorClassValues = []errorClass{0, 1, 2}
+
+var _errorClassNameToValueMap = map[string]errorClass{
+	_errorClassName[0:17]:  0,
+	_errorClassName[17:36]: 1,
+	_errorClassName[36:74]: 2,
+}
+
+// errorClassString retrieves an enum value from the enum constants string name.
+// Throws an error if the param is not part of the enum.
+func errorClassString(s string) (errorClass, error) {
+	if val, ok := _errorClassNameToValueMap[s]; ok {
+		return val, nil
+	}
+	return 0, fmt.Errorf("%s does not belong to errorClass values", s)
+}
+
+// errorClassValues returns all values of the enum
+func errorClassValues() []errorClass {
+	return _errorClassValues
+}
+
+// IsAerrorClass returns "true" if the value is listed in the enum definition. "false" otherwise
+func (i errorClass) IsAerrorClass() bool {
+	for _, v := range _errorClassValues {
+		if i == v {
+			return true
+		}
+	}
+	return false
+}

replication/driver/replication_driver.go

@@ -0,0 +1,638 @@
+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/zrepl/zrepl/replication/report"
+	"github.com/zrepl/zrepl/util/chainlock"
+	"github.com/zrepl/zrepl/util/envconst"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type interval struct {
+	begin time.Time
+	end   time.Time
+}
+
+func (w *interval) SetZero() {
+	w.begin = time.Time{}
+	w.end = time.Time{}
+}
+
+// Duration of 0 means indefinite length
+func (w *interval) Set(begin time.Time, duration time.Duration) {
+	if begin.IsZero() {
+		panic("zero begin time now allowed")
+	}
+	w.begin = begin
+	w.end = begin.Add(duration)
+}
+
+// Returns the End of the interval if it has a defined length.
+// For indefinite lengths, returns the zero value.
+func (w *interval) End() time.Time {
+	return w.end
+}
+
+// Return a context with a deadline at the interval's end.
+// If the interval has indefinite length (duration 0 on Set), return ctx as is.
+// The returned context.CancelFunc can be called either way.
+func (w *interval) ContextWithDeadlineAtEnd(ctx context.Context) (context.Context, context.CancelFunc) {
+	if w.begin.IsZero() {
+		panic("must call Set before ContextWIthDeadlineAtEnd")
+	}
+	if w.end.IsZero() {
+		// indefinite length, just return context as is
+		return ctx, func() {}
+	} else {
+		return context.WithDeadline(ctx, w.end)
+	}
+}
+
+type run struct {
+	l *chainlock.L
+
+	startedAt, finishedAt time.Time
+
+	waitReconnect      interval
+	waitReconnectError *timedError
+
+	// the attempts attempted so far:
+	// All but the last in this slice must have finished with some errors.
+	// The last attempt may not be finished and may not have errors.
+	attempts []*attempt
+}
+
+type Planner interface {
+	Plan(context.Context) ([]FS, error)
+	WaitForConnectivity(context.Context) error
+}
+
+// an attempt represents a single planning & execution of fs replications
+type attempt struct {
+	planner Planner
+
+	l *chainlock.L
+
+	startedAt, finishedAt time.Time
+
+	// after Planner.Plan was called, planErr and fss are mutually exclusive with regards to nil-ness
+	// if both are nil, it must be assumed that Planner.Plan is active
+	planErr *timedError
+	fss     []*fs
+}
+
+type timedError struct {
+	Err  error
+	Time time.Time
+}
+
+func newTimedError(err error, t time.Time) *timedError {
+	if err == nil {
+		panic("error must be non-nil")
+	}
+	if t.IsZero() {
+		panic("t must be non-zero")
+	}
+	return &timedError{err, t}
+}
+
+func (e *timedError) IntoReportError() *report.TimedError {
+	if e == nil {
+		return nil
+	}
+	return report.NewTimedError(e.Err.Error(), e.Time)
+}
+
+type FS interface {
+	// Returns true if this FS and fs refer to the same filesystem returned
+	// by Planner.Plan in a previous attempt.
+	EqualToPreviousAttempt(fs FS) bool
+	// The returned steps are assumed to be dependent on exactly
+	// their direct predecessors in the returned list.
+	PlanFS(context.Context) ([]Step, error)
+	ReportInfo() *report.FilesystemInfo
+}
+
+type Step interface {
+	// Returns true iff the target snapshot is the same for this Step and other.
+	// We do not use TargetDate to avoid problems with wrong system time on
+	// snapshot creation.
+	//
+	// Implementations can assume that `other` is a step of the same filesystem,
+	// although maybe from a previous attempt.
+	// (`same` as defined by FS.EqualToPreviousAttempt)
+	//
+	// Note that TargetEquals should return true in a situation with one
+	// originally sent snapshot and a subsequent attempt's step that uses
+	// resumable send & recv.
+	TargetEquals(other Step) bool
+	TargetDate() time.Time
+	Step(context.Context) error
+	ReportInfo() *report.StepInfo
+}
+
+type fs struct {
+	fs FS
+
+	l *chainlock.L
+
+	planning struct {
+		done bool
+		err  *timedError
+	}
+
+	// valid iff planning.done && planning.err == nil
+	planned struct {
+		// valid iff planning.done && planning.err == nil
+		stepErr *timedError
+		// all steps, in the order in which they must be completed
+		steps []*step
+		// index into steps, pointing at the step that is currently executing
+		// if step >= len(steps), no more work needs to be done
+		step int
+	}
+}
+
+type step struct {
+	l    *chainlock.L
+	step Step
+}
+
+type ReportFunc func() *report.Report
+type WaitFunc func(block bool) (done bool)
+
+var maxAttempts = envconst.Int64("ZREPL_REPLICATION_MAX_ATTEMPTS", 3)
+var reconnectHardFailTimeout = envconst.Duration("ZREPL_REPLICATION_RECONNECT_HARD_FAIL_TIMEOUT", 10*time.Minute)
+
+func Do(ctx context.Context, planner Planner) (ReportFunc, WaitFunc) {
+	log := getLog(ctx)
+	l := chainlock.New()
+	run := &run{
+		l:         l,
+		startedAt: time.Now(),
+	}
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+
+		defer run.l.Lock().Unlock()
+		log.Debug("begin run")
+		defer log.Debug("run ended")
+		var prev *attempt
+		mainLog := log
+		for ano := 0; ano < int(maxAttempts) || maxAttempts == 0; ano++ {
+			log := mainLog.WithField("attempt_number", ano)
+			log.Debug("start attempt")
+
+			run.waitReconnect.SetZero()
+			run.waitReconnectError = nil
+
+			// do current attempt
+			cur := &attempt{
+				l:         l,
+				startedAt: time.Now(),
+				planner:   planner,
+			}
+			run.attempts = append(run.attempts, cur)
+			run.l.DropWhile(func() {
+				cur.do(ctx, prev)
+			})
+			prev = cur
+			if ctx.Err() != nil {
+				log.WithError(ctx.Err()).Info("context error")
+				return
+			}
+
+			// error classification, bail out if done / permanent error
+			rep := cur.report()
+			log.WithField("attempt_state", rep.State).Debug("attempt state")
+			errRep := cur.errorReport()
+
+			if rep.State == report.AttemptDone {
+				log.Debug("attempt completed successfully")
+				break
+			}
+
+			mostRecentErr, mostRecentErrClass := errRep.MostRecent()
+			log.WithField("most_recent_err", mostRecentErr).WithField("most_recent_err_class", mostRecentErrClass).Debug("most recent error used for re-connect decision")
+			if mostRecentErr == nil {
+				// inconsistent reporting, let's bail out
+				log.Warn("attempt does not report done but error report does not report errors, aborting run")
+				break
+			}
+			log.WithError(mostRecentErr.Err).Error("most recent error in this attempt")
+			shouldReconnect := mostRecentErrClass == errorClassTemporaryConnectivityRelated
+			log.WithField("reconnect_decision", shouldReconnect).Debug("reconnect decision made")
+			if shouldReconnect {
+				run.waitReconnect.Set(time.Now(), reconnectHardFailTimeout)
+				log.WithField("deadline", run.waitReconnect.End()).Error("temporary connectivity-related error identified, start waiting for reconnect")
+				var connectErr error
+				var connectErrTime time.Time
+				run.l.DropWhile(func() {
+					ctx, cancel := run.waitReconnect.ContextWithDeadlineAtEnd(ctx)
+					defer cancel()
+					connectErr = planner.WaitForConnectivity(ctx)
+					connectErrTime = time.Now()
+				})
+				if connectErr == nil {
+					log.Error("reconnect successful") // same level as 'begin with reconnect' message above
+					continue
+				} else {
+					run.waitReconnectError = newTimedError(connectErr, connectErrTime)
+					log.WithError(connectErr).Error("reconnecting failed, aborting run")
+					break
+				}
+			} else {
+				log.Error("most recent error cannot be solved by reconnecting, aborting run")
+				return
+			}
+
+		}
+
+	}()
+
+	wait := func(block bool) bool {
+		if block {
+			<-done
+		}
+		select {
+		case <-done:
+			return true
+		default:
+			return false
+		}
+	}
+	report := func() *report.Report {
+		defer run.l.Lock().Unlock()
+		return run.report()
+	}
+	return report, wait
+}
+
+func (a *attempt) do(ctx context.Context, prev *attempt) {
+	pfss, err := a.planner.Plan(ctx)
+	errTime := time.Now()
+	defer a.l.Lock().Unlock()
+	if err != nil {
+		a.planErr = newTimedError(err, errTime)
+		a.fss = nil
+		a.finishedAt = time.Now()
+		return
+	}
+
+	for _, pfs := range pfss {
+		fs := &fs{
+			fs: pfs,
+			l:  a.l,
+		}
+		a.fss = append(a.fss, fs)
+	}
+
+	prevs := make(map[*fs]*fs)
+	{
+		prevFSs := make(map[*fs][]*fs, len(pfss))
+		if prev != nil {
+			debug("previous attempt has %d fss", len(a.fss))
+			for _, fs := range a.fss {
+				for _, prevFS := range prev.fss {
+					if fs.fs.EqualToPreviousAttempt(prevFS.fs) {
+						l := prevFSs[fs]
+						l = append(l, prevFS)
+						prevFSs[fs] = l
+					}
+				}
+			}
+		}
+		type inconsistency struct {
+			cur   *fs
+			prevs []*fs
+		}
+		var inconsistencies []inconsistency
+		for cur, fss := range prevFSs {
+			if len(fss) > 1 {
+				inconsistencies = append(inconsistencies, inconsistency{cur, fss})
+			}
+		}
+		sort.SliceStable(inconsistencies, func(i, j int) bool {
+			return inconsistencies[i].cur.fs.ReportInfo().Name < inconsistencies[j].cur.fs.ReportInfo().Name
+		})
+		if len(inconsistencies) > 0 {
+			var msg strings.Builder
+			msg.WriteString("cannot determine filesystem correspondences between different attempts:\n")
+			var inconsistencyLines []string
+			for _, i := range inconsistencies {
+				var prevNames []string
+				for _, prev := range i.prevs {
+					prevNames = append(prevNames, prev.fs.ReportInfo().Name)
+				}
+				l := fmt.Sprintf("  %s => %v", i.cur.fs.ReportInfo().Name, prevNames)
+				inconsistencyLines = append(inconsistencyLines, l)
+			}
+			fmt.Fprintf(&msg, strings.Join(inconsistencyLines, "\n"))
+			now := time.Now()
+			a.planErr = newTimedError(errors.New(msg.String()), now)
+			a.fss = nil
+			a.finishedAt = now
+			return
+		}
+		for cur, fss := range prevFSs {
+			if len(fss) > 0 {
+				prevs[cur] = fss[0]
+			}
+		}
+	}
+	// invariant: prevs contains an entry for each unambigious correspondence
+
+	stepQueue := newStepQueue()
+	defer stepQueue.Start(1)() // TODO parallel replication
+	var fssesDone sync.WaitGroup
+	for _, f := range a.fss {
+		fssesDone.Add(1)
+		go func(f *fs) {
+			defer fssesDone.Done()
+			f.do(ctx, stepQueue, prevs[f])
+		}(f)
+	}
+	a.l.DropWhile(func() {
+		fssesDone.Wait()
+	})
+	a.finishedAt = time.Now()
+}
+
+func (fs *fs) do(ctx context.Context, pq *stepQueue, prev *fs) {
+	psteps, err := fs.fs.PlanFS(ctx)
+	errTime := time.Now()
+	defer fs.l.Lock().Unlock()
+	debug := debugPrefix("fs=%s", fs.fs.ReportInfo().Name)
+	fs.planning.done = true
+	if err != nil {
+		fs.planning.err = newTimedError(err, errTime)
+		return
+	}
+	for _, pstep := range psteps {
+		step := &step{
+			l:    fs.l,
+			step: pstep,
+		}
+		fs.planned.steps = append(fs.planned.steps, step)
+	}
+	debug("iniital len(fs.planned.steps) = %d", len(fs.planned.steps))
+
+	// for not-first attempts, only allow fs.planned.steps
+	// up to including the originally planned target snapshot
+	if prev != nil && prev.planning.done && prev.planning.err == nil {
+		prevUncompleted := prev.planned.steps[prev.planned.step:]
+		if len(prevUncompleted) == 0 {
+			debug("prevUncompleted is empty")
+			return
+		}
+		if len(fs.planned.steps) == 0 {
+			debug("fs.planned.steps is empty")
+			return
+		}
+		prevFailed := prevUncompleted[0]
+		curFirst := fs.planned.steps[0]
+		// we assume that PlanFS retries prevFailed (using curFirst)
+		if !prevFailed.step.TargetEquals(curFirst.step) {
+			debug("Targets don't match")
+			// Two options:
+			// A: planning algorithm is broken
+			// B: manual user intervention inbetween
+			// Neither way will we make progress, so let's error out
+			stepFmt := func(step *step) string {
+				r := step.report()
+				s := r.Info
+				if r.IsIncremental() {
+					return fmt.Sprintf("%s=>%s", s.From, s.To)
+				} else {
+					return fmt.Sprintf("full=>%s", s.To)
+				}
+			}
+			msg := fmt.Sprintf("last attempt's uncompleted step %s does not correspond to this attempt's first planned step %s",
+				stepFmt(prevFailed), stepFmt(curFirst))
+			fs.planned.stepErr = newTimedError(errors.New(msg), time.Now())
+			return
+		}
+		// only allow until step targets diverge
+		min := len(prevUncompleted)
+		if min > len(fs.planned.steps) {
+			min = len(fs.planned.steps)
+		}
+		diverge := 0
+		for ; diverge < min; diverge++ {
+			debug("diverge compare iteration %d", diverge)
+			if !fs.planned.steps[diverge].step.TargetEquals(prevUncompleted[diverge].step) {
+				break
+			}
+		}
+		debug("diverge is %d", diverge)
+		fs.planned.steps = fs.planned.steps[0:diverge]
+	}
+	debug("post-prev-merge len(fs.planned.steps) = %d", len(fs.planned.steps))
+
+	for i, s := range fs.planned.steps {
+		var (
+			err     error
+			errTime time.Time
+		)
+		// lock must not be held while executing step in order for reporting to work
+		fs.l.DropWhile(func() {
+			targetDate := s.step.TargetDate()
+			defer pq.WaitReady(fs, targetDate)()
+			err = s.step.Step(ctx) // no shadow
+			errTime = time.Now()   // no shadow
+		})
+		if err != nil {
+			fs.planned.stepErr = newTimedError(err, errTime)
+			break
+		}
+		fs.planned.step = i + 1 // fs.planned.step must be == len(fs.planned.steps) if all went OK
+	}
+}
+
+// caller must hold lock l
+func (r *run) report() *report.Report {
+	report := &report.Report{
+		Attempts:           make([]*report.AttemptReport, len(r.attempts)),
+		StartAt:            r.startedAt,
+		FinishAt:           r.finishedAt,
+		WaitReconnectSince: r.waitReconnect.begin,
+		WaitReconnectUntil: r.waitReconnect.end,
+		WaitReconnectError: r.waitReconnectError.IntoReportError(),
+	}
+	for i := range report.Attempts {
+		report.Attempts[i] = r.attempts[i].report()
+	}
+	return report
+}
+
+// caller must hold lock l
+func (a *attempt) report() *report.AttemptReport {
+
+	r := &report.AttemptReport{
+		// State is set below
+		Filesystems: make([]*report.FilesystemReport, len(a.fss)),
+		StartAt:     a.startedAt,
+		FinishAt:    a.finishedAt,
+		PlanError:   a.planErr.IntoReportError(),
+	}
+
+	for i := range r.Filesystems {
+		r.Filesystems[i] = a.fss[i].report()
+	}
+
+	state := report.AttemptPlanning
+	if a.planErr != nil {
+		state = report.AttemptPlanningError
+	} else if a.fss != nil {
+		if a.finishedAt.IsZero() {
+			state = report.AttemptFanOutFSs
+		} else {
+			fsWithError := false
+			for _, s := range r.Filesystems {
+				fsWithError = fsWithError || s.Error() != nil
+			}
+			state = report.AttemptDone
+			if fsWithError {
+				state = report.AttemptFanOutError
+			}
+		}
+	}
+	r.State = state
+
+	return r
+}
+
+// caller must hold lock l
+func (f *fs) report() *report.FilesystemReport {
+	state := report.FilesystemPlanningErrored
+	if f.planning.err == nil {
+		if f.planning.done {
+			if f.planned.stepErr != nil {
+				state = report.FilesystemSteppingErrored
+			} else if f.planned.step < len(f.planned.steps) {
+				state = report.FilesystemStepping
+			} else {
+				state = report.FilesystemDone
+			}
+		} else {
+			state = report.FilesystemPlanning
+		}
+	}
+	r := &report.FilesystemReport{
+		Info:        f.fs.ReportInfo(),
+		State:       state,
+		PlanError:   f.planning.err.IntoReportError(),
+		StepError:   f.planned.stepErr.IntoReportError(),
+		Steps:       make([]*report.StepReport, len(f.planned.steps)),
+		CurrentStep: f.planned.step,
+	}
+	for i := range r.Steps {
+		r.Steps[i] = f.planned.steps[i].report()
+	}
+	return r
+}
+
+// caller must hold lock l
+func (s *step) report() *report.StepReport {
+	r := &report.StepReport{
+		Info: s.step.ReportInfo(),
+	}
+	return r
+}
+
+type stepErrorReport struct {
+	err  *timedError
+	step int
+}
+
+//go:generate enumer -type=errorClass
+type errorClass int
+
+const (
+	errorClassUnknown errorClass = iota
+	errorClassPermanent
+	errorClassTemporaryConnectivityRelated
+)
+
+type errorReport struct {
+	flattened []*timedError
+	// sorted DESCending by err time
+	byClass map[errorClass][]*timedError
+}
+
+// caller must hold lock l
+func (a *attempt) errorReport() *errorReport {
+	r := &errorReport{}
+	if a.planErr != nil {
+		r.flattened = append(r.flattened, a.planErr)
+	}
+	for _, fs := range a.fss {
+		if fs.planning.done && fs.planning.err != nil {
+			r.flattened = append(r.flattened, fs.planning.err)
+		} else if fs.planning.done && fs.planned.stepErr != nil {
+			r.flattened = append(r.flattened, fs.planned.stepErr)
+		}
+	}
+
+	// build byClass
+	{
+		r.byClass = make(map[errorClass][]*timedError)
+		putClass := func(err *timedError, class errorClass) {
+			errs := r.byClass[class]
+			errs = append(errs, err)
+			r.byClass[class] = errs
+		}
+		for _, err := range r.flattened {
+			if neterr, ok := err.Err.(net.Error); ok && neterr.Temporary() {
+				putClass(err, errorClassTemporaryConnectivityRelated)
+				continue
+			}
+			if st, ok := status.FromError(err.Err); ok && st.Code() == codes.Unavailable {
+				// technically, codes.Unavailable could be returned by the gRPC endpoint, indicating overload, etc.
+				// for now, let's assume it only happens for connectivity issues, as specified in
+				// https://grpc.io/grpc/core/md_doc_statuscodes.html
+				putClass(err, errorClassTemporaryConnectivityRelated)
+				continue
+			}
+			putClass(err, errorClassPermanent)
+		}
+		for _, errs := range r.byClass {
+			sort.Slice(errs, func(i, j int) bool {
+				return errs[i].Time.After(errs[j].Time) // sort descendingly
+			})
+		}
+	}
+
+	return r
+}
+
+func (r *errorReport) AnyError() *timedError {
+	for _, err := range r.flattened {
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r *errorReport) MostRecent() (err *timedError, errClass errorClass) {
+	for class, errs := range r.byClass {
+		// errs are sorted descendingly during construction
+		if len(errs) > 0 && (err == nil || errs[0].Time.After(err.Time)) {
+			err = errs[0]
+			errClass = class
+		}
+	}
+	return
+}

replication/driver/replication_driver_debug.go

@@ -0,0 +1,29 @@
+package driver
+
+import (
+	"fmt"
+	"os"
+)
+
+var debugEnabled bool = false
+
+func init() {
+	if os.Getenv("ZREPL_REPLICATION_DRIVER_DEBUG") != "" {
+		debugEnabled = true
+	}
+}
+
+func debug(format string, args ...interface{}) {
+	if debugEnabled {
+		fmt.Fprintf(os.Stderr, "repl: driver: %s\n", fmt.Sprintf(format, args...))
+	}
+}
+
+type debugFunc func(format string, args ...interface{})
+
+func debugPrefix(prefixFormat string, prefixFormatArgs ...interface{}) debugFunc {
+	prefix := fmt.Sprintf(prefixFormat, prefixFormatArgs...)
+	return func(format string, args ...interface{}) {
+		debug("%s: %s", prefix, fmt.Sprintf(format, args))
+	}
+}

replication/driver/replication_driver_logging.go

@@ -0,0 +1,25 @@
+package driver
+
+import (
+	"context"
+
+	"github.com/zrepl/zrepl/logger"
+)
+
+type Logger = logger.Logger
+
+type contexKey int
+
+const contexKeyLogger contexKey = iota + 1
+
+func getLog(ctx context.Context) Logger {
+	l, ok := ctx.Value(contexKeyLogger).(Logger)
+	if !ok {
+		l = logger.NewNullLogger()
+	}
+	return l
+}
+
+func WithLogger(ctx context.Context, log Logger) context.Context {
+	return context.WithValue(ctx, contexKeyLogger, log)
+}

replication/driver/replication_driver_test.go

@@ -0,0 +1,215 @@
+package driver
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/zrepl/zrepl/replication/report"
+
+	"github.com/stretchr/testify/assert"
+
+	jsondiff "github.com/yudai/gojsondiff"
+	jsondiffformatter "github.com/yudai/gojsondiff/formatter"
+)
+
+type mockPlanner struct {
+	stepCounter uint32
+	fss         []FS // *mockFS
+}
+
+func (p *mockPlanner) Plan(ctx context.Context) ([]FS, error) {
+	time.Sleep(1 * time.Second)
+	p.fss = []FS{
+		&mockFS{
+			&p.stepCounter,
+			"zroot/one",
+			nil,
+		},
+		&mockFS{
+			&p.stepCounter,
+			"zroot/two",
+			nil,
+		},
+	}
+	return p.fss, nil
+}
+
+func (p *mockPlanner) WaitForConnectivity(context.Context) error {
+	return nil
+}
+
+type mockFS struct {
+	globalStepCounter *uint32
+	name              string
+	steps             []Step
+}
+
+func (f *mockFS) EqualToPreviousAttempt(other FS) bool {
+	return f.name == other.(*mockFS).name
+}
+
+func (f *mockFS) PlanFS(ctx context.Context) ([]Step, error) {
+	if f.steps != nil {
+		panic("PlanFS used twice")
+	}
+	switch f.name {
+	case "zroot/one":
+		f.steps = []Step{
+			&mockStep{
+				fs:         f,
+				ident:      "a",
+				duration:   1 * time.Second,
+				targetDate: time.Unix(2, 0),
+			},
+			&mockStep{
+				fs:         f,
+				ident:      "b",
+				duration:   1 * time.Second,
+				targetDate: time.Unix(10, 0),
+			},
+			&mockStep{
+				fs:         f,
+				ident:      "c",
+				duration:   1 * time.Second,
+				targetDate: time.Unix(20, 0),
+			},
+		}
+	case "zroot/two":
+		f.steps = []Step{
+			&mockStep{
+				fs:         f,
+				ident:      "u",
+				duration:   500 * time.Millisecond,
+				targetDate: time.Unix(15, 0),
+			},
+			&mockStep{
+				fs:         f,
+				duration:   500 * time.Millisecond,
+				ident:      "v",
+				targetDate: time.Unix(30, 0),
+			},
+		}
+	default:
+		panic("unimplemented")
+	}
+
+	return f.steps, nil
+}
+
+func (f *mockFS) ReportInfo() *report.FilesystemInfo {
+	return &report.FilesystemInfo{Name: f.name}
+}
+
+type mockStep struct {
+	fs         *mockFS
+	ident      string
+	duration   time.Duration
+	targetDate time.Time
+
+	// filled by method Step
+	globalCtr uint32
+}
+
+func (f *mockStep) String() string {
+	return fmt.Sprintf("%s{%s} targetDate=%s globalCtr=%v", f.fs.name, f.ident, f.targetDate, f.globalCtr)
+}
+
+func (f *mockStep) Step(ctx context.Context) error {
+	f.globalCtr = atomic.AddUint32(f.fs.globalStepCounter, 1)
+	time.Sleep(f.duration)
+	return nil
+}
+
+func (f *mockStep) TargetEquals(s Step) bool {
+	return f.ident == s.(*mockStep).ident
+}
+
+func (f *mockStep) TargetDate() time.Time {
+	return f.targetDate
+}
+
+func (f *mockStep) ReportInfo() *report.StepInfo {
+	return &report.StepInfo{From: f.ident, To: f.ident, BytesExpected: 100, BytesReplicated: 25}
+}
+
+// TODO: add meaningful validation (i.e. actual checks)
+// Since the stepqueue is not deterministic due to scheduler jitter,
+// we cannot test for any definitive sequence of steps here.
+// Such checks would further only be sensible for a non-concurrent step-queue,
+// but we're going to have concurrent replication in the future.
+//
+// For the time being, let's just exercise the code a bit.
+func TestReplication(t *testing.T) {
+
+	ctx := context.Background()
+
+	mp := &mockPlanner{}
+	getReport, wait := Do(ctx, mp)
+	begin := time.Now()
+	fireAt := []time.Duration{
+		// the following values are relative to the start
+		500 * time.Millisecond,  // planning
+		1500 * time.Millisecond, // nothing is done, a is running
+		2500 * time.Millisecond, // a done,  b running
+		3250 * time.Millisecond, // a,b done, u running
+		3750 * time.Millisecond, // a,b,u done, c running
+		4750 * time.Millisecond, // a,b,u,c done, v running
+		5250 * time.Millisecond, // a,b,u,c,v done
+	}
+	reports := make([]*report.Report, len(fireAt))
+	for i := range fireAt {
+		sleepUntil := begin.Add(fireAt[i])
+		time.Sleep(sleepUntil.Sub(time.Now()))
+		reports[i] = getReport()
+		// uncomment for viewing non-diffed results
+		// t.Logf("report @ %6.4f:\n%s", fireAt[i].Seconds(), pretty.Sprint(reports[i]))
+	}
+	waitBegin := time.Now()
+	wait(true)
+	waitDuration := time.Now().Sub(waitBegin)
+	assert.True(t, waitDuration < 10*time.Millisecond, "%v", waitDuration) // and that's gratious
+
+	prev, err := json.Marshal(reports[0])
+	require.NoError(t, err)
+	for _, r := range reports[1:] {
+		this, err := json.Marshal(r)
+		require.NoError(t, err)
+		differ := jsondiff.New()
+		diff, err := differ.Compare(prev, this)
+		require.NoError(t, err)
+		df := jsondiffformatter.NewDeltaFormatter()
+		_, err = df.Format(diff)
+		require.NoError(t, err)
+		// uncomment the following line to get json diffs between each captured step
+		// t.Logf("%s", res)
+		prev, err = json.Marshal(r)
+		require.NoError(t, err)
+	}
+
+	steps := make([]*mockStep, 0)
+	for _, fs := range mp.fss {
+		for _, step := range fs.(*mockFS).steps {
+			steps = append(steps, step.(*mockStep))
+		}
+	}
+
+	// sort steps in pq order (although, remember, pq is not deterministic)
+	sort.Slice(steps, func(i, j int) bool {
+		return steps[i].targetDate.Before(steps[j].targetDate)
+	})
+
+	// manual inspection of the globalCtr value should show that, despite
+	// scheduler-dependent behavior of pq, steps should generally be taken
+	// from oldest to newest target date (globally, not per FS).
+	t.Logf("steps sorted by target date:")
+	for _, step := range steps {
+		t.Logf("\t%s", step)
+	}
+
+}

replication/driver/replication_stepqueue.go

@@ -0,0 +1,163 @@
+package driver
+
+import (
+	"container/heap"
+	"time"
+
+	"github.com/zrepl/zrepl/util/chainlock"
+)
+
+type stepQueueRec struct {
+	ident      interface{}
+	targetDate time.Time
+	wakeup     chan StepCompletedFunc
+}
+
+type stepQueue struct {
+	stop chan struct{}
+	reqs chan stepQueueRec
+}
+
+type stepQueueHeapItem struct {
+	idx int
+	req stepQueueRec
+}
+type stepQueueHeap []*stepQueueHeapItem
+
+func (h stepQueueHeap) Less(i, j int) bool {
+	return h[i].req.targetDate.Before(h[j].req.targetDate)
+}
+
+func (h stepQueueHeap) Swap(i, j int) {
+	h[i], h[j] = h[j], h[i]
+	h[i].idx = i
+	h[j].idx = j
+}
+
+func (h stepQueueHeap) Len() int {
+	return len(h)
+}
+
+func (h *stepQueueHeap) Push(elem interface{}) {
+	hitem := elem.(*stepQueueHeapItem)
+	hitem.idx = h.Len()
+	*h = append(*h, hitem)
+}
+
+func (h *stepQueueHeap) Pop() interface{} {
+	elem := (*h)[h.Len()-1]
+	elem.idx = -1
+	*h = (*h)[:h.Len()-1]
+	return elem
+}
+
+// returned stepQueue must be closed with method Close
+func newStepQueue() *stepQueue {
+	q := &stepQueue{
+		stop: make(chan struct{}),
+		reqs: make(chan stepQueueRec),
+	}
+	return q
+}
+
+// the returned done function must be called to free resources
+// allocated by the call to Start
+//
+// No WaitReady calls must be active at the time done is called
+// The behavior of calling WaitReady after done was called is undefined
+func (q *stepQueue) Start(concurrency int) (done func()) {
+	if concurrency < 1 {
+		panic("concurrency must be >= 1")
+	}
+	// l protects pending and queueItems
+	l := chainlock.New()
+	pendingCond := l.NewCond()
+	// priority queue
+	pending := &stepQueueHeap{}
+	// ident => queueItem
+	queueItems := make(map[interface{}]*stepQueueHeapItem)
+	// stopped is used for cancellation of "wake" goroutine
+	stopped := false
+	active := 0
+	go func() { // "stopper" goroutine
+		<-q.stop
+		defer l.Lock().Unlock()
+		stopped = true
+		pendingCond.Broadcast()
+	}()
+	go func() { // "reqs" goroutine
+		for {
+			select {
+			case <-q.stop:
+				select {
+				case <-q.reqs:
+					panic("WaitReady call active while calling Close")
+				default:
+					return
+				}
+			case req := <-q.reqs:
+				func() {
+					defer l.Lock().Unlock()
+					if _, ok := queueItems[req.ident]; ok {
+						panic("WaitReady must not be called twice for the same ident")
+					}
+					qitem := &stepQueueHeapItem{
+						req: req,
+					}
+					queueItems[req.ident] = qitem
+					heap.Push(pending, qitem)
+					pendingCond.Broadcast()
+				}()
+			}
+		}
+	}()
+	go func() { // "wake" goroutine
+		defer l.Lock().Unlock()
+		for {
+
+			for !stopped && (active >= concurrency || pending.Len() == 0) {
+				pendingCond.Wait()
+			}
+			if stopped {
+				return
+			}
+			if pending.Len() <= 0 {
+				return
+			}
+			active++
+			next := heap.Pop(pending).(*stepQueueHeapItem).req
+			delete(queueItems, next.ident)
+
+			next.wakeup <- func() {
+				defer l.Lock().Unlock()
+				active--
+				pendingCond.Broadcast()
+			}
+		}
+	}()
+
+	done = func() {
+		close(q.stop)
+	}
+	return done
+}
+
+type StepCompletedFunc func()
+
+func (q *stepQueue) sendAndWaitForWakeup(ident interface{}, targetDate time.Time) StepCompletedFunc {
+	req := stepQueueRec{
+		ident,
+		targetDate,
+		make(chan StepCompletedFunc),
+	}
+	q.reqs <- req
+	return <-req.wakeup
+}
+
+// Wait for the ident with targetDate to be selected to run.
+func (q *stepQueue) WaitReady(ident interface{}, targetDate time.Time) StepCompletedFunc {
+	if targetDate.IsZero() {
+		panic("targetDate of zero is reserved for marking Done")
+	}
+	return q.sendAndWaitForWakeup(ident, targetDate)
+}

replication/driver/replication_stepqueue_test.go

@@ -0,0 +1,177 @@
+package driver
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/montanaflynn/stats"
+	"github.com/stretchr/testify/assert"
+)
+
+// FIXME: this test relies on timing and is thus rather flaky
+// (relies on scheduler responsivity of < 500ms)
+func TestPqNotconcurrent(t *testing.T) {
+	var ctr uint32
+	q := newStepQueue()
+	var wg sync.WaitGroup
+	wg.Add(4)
+	go func() {
+		defer wg.Done()
+		defer q.WaitReady("1", time.Unix(9999, 0))()
+		ret := atomic.AddUint32(&ctr, 1)
+		assert.Equal(t, uint32(1), ret)
+		time.Sleep(1 * time.Second)
+	}()
+
+	// give goroutine "1" 500ms to enter queue, get the active slot and enter time.Sleep
+	defer q.Start(1)()
+	time.Sleep(500 * time.Millisecond)
+
+	// while "1" is still running, queue in "2", "3" and "4"
+	go func() {
+		defer wg.Done()
+		defer q.WaitReady("2", time.Unix(2, 0))()
+		ret := atomic.AddUint32(&ctr, 1)
+		assert.Equal(t, uint32(2), ret)
+	}()
+	go func() {
+		defer wg.Done()
+		defer q.WaitReady("3", time.Unix(3, 0))()
+		ret := atomic.AddUint32(&ctr, 1)
+		assert.Equal(t, uint32(3), ret)
+	}()
+	go func() {
+		defer wg.Done()
+		defer q.WaitReady("4", time.Unix(4, 0))()
+		ret := atomic.AddUint32(&ctr, 1)
+		assert.Equal(t, uint32(4), ret)
+	}()
+
+	wg.Wait()
+}
+
+type record struct {
+	fs        int
+	step      int
+	globalCtr uint32
+	wakeAt    time.Duration // relative to begin
+}
+
+func (r record) String() string {
+	return fmt.Sprintf("fs %08d step %08d globalCtr %08d wakeAt %2.8f", r.fs, r.step, r.globalCtr, r.wakeAt.Seconds())
+}
+
+// This tests uses stepPq concurrently, simulating the following scenario:
+// Given a number of filesystems F, each filesystem has N steps to take.
+// The number of concurrent steps is limited to C.
+// The target date for each step is the step number N.
+// Hence, there are always F filesystems runnable (calling WaitReady)
+// The priority queue prioritizes steps with lower target data (= lower step number).
+// Hence, all steps with lower numbers should be woken up before steps with higher numbers.
+// However, scheduling is not 100% deterministic (runtime, OS scheduler, etc).
+// Hence, perform some statistics on the wakeup times and assert that the mean wakeup
+// times for each step are close together.
+func TestPqConcurrent(t *testing.T) {
+
+	q := newStepQueue()
+	var wg sync.WaitGroup
+	filesystems := 100
+	stepsPerFS := 20
+	sleepTimePerStep := 50 * time.Millisecond
+	wg.Add(filesystems)
+	var globalCtr uint32
+
+	begin := time.Now()
+	records := make(chan []record, filesystems)
+	for fs := 0; fs < filesystems; fs++ {
+		go func(fs int) {
+			defer wg.Done()
+			recs := make([]record, 0)
+			for step := 0; step < stepsPerFS; step++ {
+				pos := atomic.AddUint32(&globalCtr, 1)
+				t := time.Unix(int64(step), 0)
+				done := q.WaitReady(fs, t)
+				wakeAt := time.Now().Sub(begin)
+				time.Sleep(sleepTimePerStep)
+				done()
+				recs = append(recs, record{fs, step, pos, wakeAt})
+			}
+			records <- recs
+		}(fs)
+	}
+	concurrency := 5
+	defer q.Start(concurrency)()
+	wg.Wait()
+	close(records)
+	t.Logf("loop done")
+
+	flattenedRecs := make([]record, 0)
+	for recs := range records {
+		flattenedRecs = append(flattenedRecs, recs...)
+	}
+
+	sort.Slice(flattenedRecs, func(i, j int) bool {
+		return flattenedRecs[i].globalCtr < flattenedRecs[j].globalCtr
+	})
+
+	wakeTimesByStep := map[int][]float64{}
+	for _, rec := range flattenedRecs {
+		wakeTimes, ok := wakeTimesByStep[rec.step]
+		if !ok {
+			wakeTimes = []float64{}
+		}
+		wakeTimes = append(wakeTimes, rec.wakeAt.Seconds())
+		wakeTimesByStep[rec.step] = wakeTimes
+	}
+
+	meansByStepId := make([]float64, stepsPerFS)
+	interQuartileRangesByStepIdx := make([]float64, stepsPerFS)
+	for step := 0; step < stepsPerFS; step++ {
+		t.Logf("step %d", step)
+		mean, _ := stats.Mean(wakeTimesByStep[step])
+		meansByStepId[step] = mean
+		t.Logf("\tmean: %v", mean)
+		median, _ := stats.Median(wakeTimesByStep[step])
+		t.Logf("\tmedian: %v", median)
+		midhinge, _ := stats.Midhinge(wakeTimesByStep[step])
+		t.Logf("\tmidhinge: %v", midhinge)
+		min, _ := stats.Min(wakeTimesByStep[step])
+		t.Logf("\tmin: %v", min)
+		max, _ := stats.Max(wakeTimesByStep[step])
+		t.Logf("\tmax: %v", max)
+		quartiles, _ := stats.Quartile(wakeTimesByStep[step])
+		t.Logf("\t%#v", quartiles)
+		interQuartileRange, _ := stats.InterQuartileRange(wakeTimesByStep[step])
+		t.Logf("\tinter-quartile range: %v", interQuartileRange)
+		interQuartileRangesByStepIdx[step] = interQuartileRange
+	}
+
+	iqrMean, _ := stats.Mean(interQuartileRangesByStepIdx)
+	t.Logf("inter-quartile-range mean: %v", iqrMean)
+	iqrDev, _ := stats.StandardDeviation(interQuartileRangesByStepIdx)
+	t.Logf("inter-quartile-range deviation: %v", iqrDev)
+
+	// each step should have the same "distribution" (=~ "spread")
+	assert.True(t, iqrDev < 0.01)
+
+	minTimeForAllStepsWithIdxI := sleepTimePerStep.Seconds() * float64(filesystems) / float64(concurrency)
+	t.Logf("minTimeForAllStepsWithIdxI = %11.8f", minTimeForAllStepsWithIdxI)
+	for i, mean := range meansByStepId {
+		// we can't just do (i + 0.5) * minTimeforAllStepsWithIdxI
+		// because this doesn't account for drift
+		idealMean := 0.5 * minTimeForAllStepsWithIdxI
+		if i > 0 {
+			previousMean := meansByStepId[i-1]
+			idealMean = previousMean + minTimeForAllStepsWithIdxI
+		}
+		deltaFromIdeal := idealMean - mean
+		t.Logf("step %02d delta from ideal mean wake time: %11.8f - %11.8f = %11.8f", i, idealMean, mean, deltaFromIdeal)
+		assert.True(t, math.Abs(deltaFromIdeal) < 0.05)
+	}
+
+}

replication/fsrep/fsfsm.go

@@ -1,532 +0,0 @@
-// Package fsrep implements replication of a single file system with existing versions
-// from a sender to a receiver.
-package fsrep
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/prometheus/client_golang/prometheus"
-	"io"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/replication/pdu"
-	"github.com/zrepl/zrepl/util"
-)
-
-type contextKey int
-
-const (
-	contextKeyLogger contextKey = iota
-)
-
-type Logger = logger.Logger
-
-func WithLogger(ctx context.Context, log Logger) context.Context {
-	return context.WithValue(ctx, contextKeyLogger, log)
-}
-
-func getLogger(ctx context.Context) Logger {
-	l, ok := ctx.Value(contextKeyLogger).(Logger)
-	if !ok {
-		l = logger.NewNullLogger()
-	}
-	return l
-}
-
-// A Sender is usually part of a github.com/zrepl/zrepl/replication.Endpoint.
-type Sender interface {
-	// If a non-nil io.ReadCloser is returned, it is guaranteed to be closed before
-	// any next call to the parent github.com/zrepl/zrepl/replication.Endpoint.
-	// If the send request is for dry run the io.ReadCloser will be nil
-	Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, io.ReadCloser, error)
-	ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error)
-}
-
-// A Sender is usually part of a github.com/zrepl/zrepl/replication.Endpoint.
-type Receiver interface {
-	// Receive sends r and sendStream (the latter containing a ZFS send stream)
-	// to the parent github.com/zrepl/zrepl/replication.Endpoint.
-	// Implementors must guarantee that Close was called on sendStream before
-	// the call to Receive returns.
-	Receive(ctx context.Context, r *pdu.ReceiveReq, sendStream io.ReadCloser) error
-}
-
-type StepReport struct {
-	From, To string
-	Status   StepState
-	Problem  string
-	Bytes    int64
-	ExpectedBytes int64 // 0 means no size estimate possible
-}
-
-type Report struct {
-	Filesystem         string
-	Status             string
-	Problem            string
-	Completed, Pending []*StepReport
-}
-
-//go:generate stringer -type=State
-type State uint
-
-const (
-	Ready State = 1 << iota
-	RetryWait
-	PermanentError
-	Completed
-)
-
-func (s State) fsrsf() state {
-	m := map[State]state{
-		Ready:          stateReady,
-		RetryWait:      stateRetryWait,
-		PermanentError: nil,
-		Completed:      nil,
-	}
-	return m[s]
-}
-
-type Replication struct {
-	promBytesReplicated prometheus.Counter
-
-	// lock protects all fields below it in this struct, but not the data behind pointers
-	lock               sync.Mutex
-	state              State
-	fs                 string
-	err                error
-	retryWaitUntil     time.Time
-	completed, pending []*ReplicationStep
-}
-
-func (f *Replication) State() State {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-	return f.state
-}
-
-func (f *Replication) UpdateSizeEsitmate(ctx context.Context, sender Sender) error {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-	for _, e := range f.pending {
-		if err := e.updateSizeEstimate(ctx, sender); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-type ReplicationBuilder struct {
-	r *Replication
-}
-
-func BuildReplication(fs string, promBytesReplicated prometheus.Counter) *ReplicationBuilder {
-	return &ReplicationBuilder{&Replication{fs: fs, promBytesReplicated: promBytesReplicated}}
-}
-
-func (b *ReplicationBuilder) AddStep(from, to FilesystemVersion) *ReplicationBuilder {
-	step := &ReplicationStep{
-		state:  StepReplicationReady,
-		parent: b.r,
-		from:   from,
-		to:     to,
-	}
-	b.r.pending = append(b.r.pending, step)
-	return b
-}
-
-func (b *ReplicationBuilder) Done() (r *Replication) {
-	if len(b.r.pending) > 0 {
-		b.r.state = Ready
-	} else {
-		b.r.state = Completed
-	}
-	r = b.r
-	b.r = nil
-	return r
-}
-
-func NewReplicationWithPermanentError(fs string, err error) *Replication {
-	return &Replication{
-		state: PermanentError,
-		fs:    fs,
-		err:   err,
-	}
-}
-
-//go:generate stringer -type=StepState
-type StepState uint
-
-const (
-	StepReplicationReady StepState = 1 << iota
-	StepReplicationRetry
-	StepMarkReplicatedReady
-	StepMarkReplicatedRetry
-	StepPermanentError
-	StepCompleted
-)
-
-type FilesystemVersion interface {
-	SnapshotTime() time.Time
-	GetName() string // name without @ or #
-	RelName() string // name with @ or #
-}
-
-type ReplicationStep struct {
-	// only protects state, err
-	// from, to and parent are assumed to be immutable
-	lock sync.Mutex
-
-	state    StepState
-	from, to FilesystemVersion
-	parent   *Replication
-
-	// both retry and permanent error
-	err error
-
-	byteCounter  *util.ByteCounterReader
-	expectedSize int64 // 0 means no size estimate present / possible
-}
-
-func (f *Replication) TakeStep(ctx context.Context, sender Sender, receiver Receiver) (post State, nextStepDate, retryWaitUntil time.Time) {
-
-	var u updater = func(fu func(*Replication)) State {
-		f.lock.Lock()
-		defer f.lock.Unlock()
-		if fu != nil {
-			fu(f)
-		}
-		return f.state
-	}
-	var s state = u(nil).fsrsf()
-
-	pre := u(nil)
-	preTime := time.Now()
-	s = s(ctx, sender, receiver, u)
-	delta := time.Now().Sub(preTime)
-
-	post = u(func(f *Replication) {
-		if len(f.pending) == 0 {
-			return
-		}
-		nextStepDate = f.pending[0].to.SnapshotTime()
-		retryWaitUntil = f.retryWaitUntil
-	})
-
-	getLogger(ctx).
-		WithField("fs", f.fs).
-		WithField("transition", fmt.Sprintf("%s => %s", pre, post)).
-		WithField("duration", delta).
-		Debug("fsr step taken")
-
-	return post, nextStepDate, retryWaitUntil
-}
-
-func (f *Replication) RetryWaitUntil() time.Time {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-	return f.retryWaitUntil
-}
-
-type updater func(func(fsr *Replication)) State
-
-type state func(ctx context.Context, sender Sender, receiver Receiver, u updater) state
-
-var RetrySleepDuration = 10 * time.Second // FIXME make configurable
-
-func stateReady(ctx context.Context, sender Sender, receiver Receiver, u updater) state {
-
-	var current *ReplicationStep
-	s := u(func(f *Replication) {
-		if len(f.pending) == 0 {
-			f.state = Completed
-			return
-		}
-		current = f.pending[0]
-	})
-	if s != Ready {
-		return s.fsrsf()
-	}
-
-	stepState := current.doReplication(ctx, sender, receiver)
-
-	return u(func(f *Replication) {
-		switch stepState {
-		case StepCompleted:
-			f.completed = append(f.completed, current)
-			f.pending = f.pending[1:]
-			if len(f.pending) > 0 {
-				f.state = Ready
-			} else {
-				f.state = Completed
-			}
-		case StepReplicationRetry:
-			fallthrough
-		case StepMarkReplicatedRetry:
-			f.retryWaitUntil = time.Now().Add(RetrySleepDuration)
-			f.state = RetryWait
-		case StepPermanentError:
-			f.state = PermanentError
-			f.err = errors.New("a replication step failed with a permanent error")
-		default:
-			panic(f)
-		}
-	}).fsrsf()
-}
-
-func stateRetryWait(ctx context.Context, sender Sender, receiver Receiver, u updater) state {
-	var sleepUntil time.Time
-	u(func(f *Replication) {
-		sleepUntil = f.retryWaitUntil
-	})
-	if time.Now().Before(sleepUntil) {
-		return u(nil).fsrsf()
-	}
-	return u(func(f *Replication) {
-		f.state = Ready
-	}).fsrsf()
-}
-
-func (fsr *Replication) Report() *Report {
-	fsr.lock.Lock()
-	defer fsr.lock.Unlock()
-
-	rep := Report{
-		Filesystem: fsr.fs,
-		Status:     fsr.state.String(),
-	}
-
-	if fsr.state&PermanentError != 0 {
-		rep.Problem = fsr.err.Error()
-		return &rep
-	}
-
-	rep.Completed = make([]*StepReport, len(fsr.completed))
-	for i := range fsr.completed {
-		rep.Completed[i] = fsr.completed[i].Report()
-	}
-	rep.Pending = make([]*StepReport, len(fsr.pending))
-	for i := range fsr.pending {
-		rep.Pending[i] = fsr.pending[i].Report()
-	}
-
-	if fsr.state&RetryWait != 0 {
-		if len(rep.Pending) != 0 { // should always be true for RetryWait == true?
-			rep.Problem = rep.Pending[0].Problem
-		}
-	}
-
-	return &rep
-}
-
-func shouldRetry(err error) bool {
-	switch err {
-	case io.EOF:
-		fallthrough
-	case io.ErrUnexpectedEOF:
-		fallthrough
-	case io.ErrClosedPipe:
-		return true
-	}
-	if _, ok := err.(net.Error); ok {
-		return true
-	}
-	return false
-}
-
-func (s *ReplicationStep) doReplication(ctx context.Context, sender Sender, receiver Receiver) StepState {
-
-	fs := s.parent.fs
-
-	log := getLogger(ctx).
-		WithField("filesystem", fs).
-		WithField("step", s.String())
-
-	updateStateError := func(err error) StepState {
-		s.lock.Lock()
-		defer s.lock.Unlock()
-
-		s.err = err
-		if shouldRetry(s.err) {
-			s.state = StepReplicationRetry
-			return s.state
-		}
-		s.state = StepPermanentError
-		return s.state
-	}
-
-	updateStateCompleted := func() StepState {
-		s.lock.Lock()
-		defer s.lock.Unlock()
-		s.err = nil
-		s.state = StepMarkReplicatedReady
-		return s.state
-	}
-
-	sr := s.buildSendRequest(false)
-
-	log.Debug("initiate send request")
-	sres, sstream, err := sender.Send(ctx, sr)
-	if err != nil {
-		log.WithError(err).Error("send request failed")
-		return updateStateError(err)
-	}
-	if sstream == nil {
-		err := errors.New("send request did not return a stream, broken endpoint implementation")
-		return updateStateError(err)
-	}
-
-	s.byteCounter = util.NewByteCounterReader(sstream)
-	defer func() {
-		s.parent.promBytesReplicated.Add(float64(s.byteCounter.Bytes()))
-	}()
-	sstream = s.byteCounter
-
-	rr := &pdu.ReceiveReq{
-		Filesystem:       fs,
-		ClearResumeToken: !sres.UsedResumeToken,
-	}
-	log.Debug("initiate receive request")
-	err = receiver.Receive(ctx, rr, sstream)
-	if err != nil {
-		log.
-			WithError(err).
-			WithField("errType", fmt.Sprintf("%T", err)).
-			Error("receive request failed (might also be error on sender)")
-		sstream.Close()
-		// This failure could be due to
-		// 	- an unexpected exit of ZFS on the sending side
-		//  - an unexpected exit of ZFS on the receiving side
-		//  - a connectivity issue
-		return updateStateError(err)
-	}
-	log.Debug("receive finished")
-
-	updateStateCompleted()
-
-	return s.doMarkReplicated(ctx, sender)
-
-}
-
-func (s *ReplicationStep) doMarkReplicated(ctx context.Context, sender Sender) StepState {
-
-	log := getLogger(ctx).
-		WithField("filesystem", s.parent.fs).
-		WithField("step", s.String())
-
-	updateStateError := func(err error) StepState {
-		s.lock.Lock()
-		defer s.lock.Unlock()
-
-		s.err = err
-		if shouldRetry(s.err) {
-			s.state = StepMarkReplicatedRetry
-			return s.state
-		}
-		s.state = StepPermanentError
-		return s.state
-	}
-
-	updateStateCompleted := func() StepState {
-		s.lock.Lock()
-		defer s.lock.Unlock()
-		s.state = StepCompleted
-		return s.state
-	}
-
-	log.Debug("advance replication cursor")
-	req := &pdu.ReplicationCursorReq{
-		Filesystem: s.parent.fs,
-		Op: &pdu.ReplicationCursorReq_Set{
-			Set: &pdu.ReplicationCursorReq_SetOp{
-				Snapshot:   s.to.GetName(),
-			},
-		},
-	}
-	res, err := sender.ReplicationCursor(ctx, req)
-	if err != nil {
-		log.WithError(err).Error("error advancing replication cursor")
-		return updateStateError(err)
-	}
-	if res.GetError() != "" {
-		err := fmt.Errorf("cannot advance replication cursor: %s", res.GetError())
-		log.Error(err.Error())
-		return updateStateError(err)
-	}
-
-	return updateStateCompleted()
-}
-
-func (s *ReplicationStep) updateSizeEstimate(ctx context.Context, sender Sender) error {
-
-	fs := s.parent.fs
-
-	log := getLogger(ctx).
-		WithField("filesystem", fs).
-		WithField("step", s.String())
-
-	sr := s.buildSendRequest(true)
-
-	log.Debug("initiate dry run send request")
-	sres, _, err := sender.Send(ctx, sr)
-	if err != nil {
-		log.WithError(err).Error("dry run send request failed")
-		return err
-	}
-	s.expectedSize = sres.ExpectedSize
-	return nil
-}
-
-func (s *ReplicationStep) buildSendRequest(dryRun bool) (sr *pdu.SendReq) {
-	fs := s.parent.fs
-	if s.from == nil {
-		sr = &pdu.SendReq{
-			Filesystem: fs,
-			From:       s.to.RelName(), // FIXME fix protocol to use To, like zfs does internally
-			DryRun:     dryRun,
-		}
-	} else {
-		sr = &pdu.SendReq{
-			Filesystem: fs,
-			From:       s.from.RelName(),
-			To:         s.to.RelName(),
-			DryRun:     dryRun,
-		}
-	}
-	return sr
-}
-
-func (s *ReplicationStep) String() string {
-	if s.from == nil { // FIXME: ZFS semantics are that to is nil on non-incremental send
-		return fmt.Sprintf("%s%s (full)", s.parent.fs, s.to.RelName())
-	} else {
-		return fmt.Sprintf("%s(%s => %s)", s.parent.fs, s.from.RelName(), s.to.RelName())
-	}
-}
-
-func (s *ReplicationStep) Report() *StepReport {
-	var from string // FIXME follow same convention as ZFS: to should be nil on full send
-	if s.from != nil {
-		from = s.from.RelName()
-	}
-	bytes := int64(0)
-	if s.byteCounter != nil {
-		bytes = s.byteCounter.Bytes()
-	}
-	problem := ""
-	if s.err != nil {
-		problem = s.err.Error()
-	}
-	rep := StepReport{
-		From:   from,
-		To:     s.to.RelName(),
-		Status: s.state,
-		Problem: problem,
-		Bytes:  bytes,
-		ExpectedBytes: s.expectedSize,
-	}
-	return &rep
-}

replication/fsrep/state_string.go

@@ -1,29 +0,0 @@
-// Code generated by "stringer -type=State"; DO NOT EDIT.
-
-package fsrep
-
-import "strconv"
-
-const (
-	_State_name_0 = "ReadyRetryWait"
-	_State_name_1 = "PermanentError"
-	_State_name_2 = "Completed"
-)
-
-var (
-	_State_index_0 = [...]uint8{0, 5, 14}
-)
-
-func (i State) String() string {
-	switch {
-	case 1 <= i && i <= 2:
-		i -= 1
-		return _State_name_0[_State_index_0[i]:_State_index_0[i+1]]
-	case i == 4:
-		return _State_name_1
-	case i == 8:
-		return _State_name_2
-	default:
-		return "State(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}

replication/fsrep/stepstate_string.go

@@ -1,35 +0,0 @@
-// Code generated by "stringer -type=StepState"; DO NOT EDIT.
-
-package fsrep
-
-import "strconv"
-
-const (
-	_StepState_name_0 = "StepReplicationReadyStepReplicationRetry"
-	_StepState_name_1 = "StepMarkReplicatedReady"
-	_StepState_name_2 = "StepMarkReplicatedRetry"
-	_StepState_name_3 = "StepPermanentError"
-	_StepState_name_4 = "StepCompleted"
-)
-
-var (
-	_StepState_index_0 = [...]uint8{0, 20, 40}
-)
-
-func (i StepState) String() string {
-	switch {
-	case 1 <= i && i <= 2:
-		i -= 1
-		return _StepState_name_0[_StepState_index_0[i]:_StepState_index_0[i+1]]
-	case i == 4:
-		return _StepState_name_1
-	case i == 8:
-		return _StepState_name_2
-	case i == 16:
-		return _StepState_name_3
-	case i == 32:
-		return _StepState_name_4
-	default:
-		return "StepState(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}

replication/internal/queue/queue.go

@@ -1,121 +0,0 @@
-package queue
-
-import (
-	"sort"
-	"time"
-
-	. "github.com/zrepl/zrepl/replication/fsrep"
-)
-
-type replicationQueueItem struct {
-	// duplicates fsr.state to avoid accessing and locking fsr
-	state State
-	// duplicates fsr.current.nextStepDate to avoid accessing & locking fsr
-	nextStepDate time.Time
-	// duplicates fsr.retryWaitUntil to avoid accessing & locking fsr
-	retryWaitUntil time.Time
-
-	fsr *Replication
-}
-
-type ReplicationQueue []*replicationQueueItem
-
-func NewReplicationQueue() *ReplicationQueue {
-	q := make(ReplicationQueue, 0)
-	return &q
-}
-
-func (q ReplicationQueue) Len() int      { return len(q) }
-func (q ReplicationQueue) Swap(i, j int) { q[i], q[j] = q[j], q[i] }
-
-type lessmapEntry struct {
-	prio int
-	less func(a, b *replicationQueueItem) bool
-}
-
-var lessmap = map[State]lessmapEntry{
-	Ready: {
-		prio: 0,
-		less: func(a, b *replicationQueueItem) bool {
-			return a.nextStepDate.Before(b.nextStepDate)
-		},
-	},
-	RetryWait: {
-		prio: 1,
-		less: func(a, b *replicationQueueItem) bool {
-			return a.retryWaitUntil.Before(b.retryWaitUntil)
-		},
-	},
-}
-
-func (q ReplicationQueue) Less(i, j int) bool {
-
-	a, b := q[i], q[j]
-	al, aok := lessmap[a.state]
-	if !aok {
-		panic(a)
-	}
-	bl, bok := lessmap[b.state]
-	if !bok {
-		panic(b)
-	}
-
-	if al.prio != bl.prio {
-		return al.prio < bl.prio
-	}
-
-	return al.less(a, b)
-}
-
-func (q *ReplicationQueue) sort() (done []*Replication) {
-	// pre-scan for everything that is not ready
-	newq := make(ReplicationQueue, 0, len(*q))
-	done = make([]*Replication, 0, len(*q))
-	for _, qitem := range *q {
-		if _, ok := lessmap[qitem.state]; !ok {
-			done = append(done, qitem.fsr)
-		} else {
-			newq = append(newq, qitem)
-		}
-	}
-	sort.Stable(newq) // stable to avoid flickering in reports
-	*q = newq
-	return done
-}
-
-// next remains valid until the next call to GetNext()
-func (q *ReplicationQueue) GetNext() (done []*Replication, next *ReplicationQueueItemHandle) {
-	done = q.sort()
-	if len(*q) == 0 {
-		return done, nil
-	}
-	next = &ReplicationQueueItemHandle{(*q)[0]}
-	return done, next
-}
-
-func (q *ReplicationQueue) Add(fsr *Replication) {
-	*q = append(*q, &replicationQueueItem{
-		fsr:   fsr,
-		state: fsr.State(),
-	})
-}
-
-func (q *ReplicationQueue) Foreach(fu func(*ReplicationQueueItemHandle)) {
-	for _, qitem := range *q {
-		fu(&ReplicationQueueItemHandle{qitem})
-	}
-}
-
-type ReplicationQueueItemHandle struct {
-	i *replicationQueueItem
-}
-
-func (h ReplicationQueueItemHandle) GetFSReplication() *Replication {
-	return h.i.fsr
-}
-
-func (h ReplicationQueueItemHandle) Update(newState State, nextStepDate, retryWaitUntil time.Time) {
-	h.i.state = newState
-	h.i.nextStepDate = nextStepDate
-	h.i.retryWaitUntil = retryWaitUntil
-}

replication/logic/diff/diff.go

@@ -1,9 +1,11 @@
-package mainfsm
+package diff
 
 import (
+	"fmt"
 	"sort"
+	"strings"
 
-	. "github.com/zrepl/zrepl/replication/pdu"
+	. "github.com/zrepl/zrepl/replication/logic/pdu"
 )
 
 type ConflictNoCommonAncestor struct {
@@ -11,7 +13,19 @@ type ConflictNoCommonAncestor struct {
 }
 
 func (c *ConflictNoCommonAncestor) Error() string {
-	return "no common snapshot or suitable bookmark between sender and receiver"
+	var buf strings.Builder
+	buf.WriteString("no common snapshot or suitable bookmark between sender and receiver")
+	if len(c.SortedReceiverVersions) > 0 || len(c.SortedSenderVersions) > 0 {
+		buf.WriteString(":\n  sorted sender versions:\n")
+		for _, v := range c.SortedSenderVersions {
+			fmt.Fprintf(&buf, "    %s\n", v.RelName())
+		}
+		buf.WriteString("  sorted receiver versions:\n")
+		for _, v := range c.SortedReceiverVersions {
+			fmt.Fprintf(&buf, "    %s\n", v.RelName())
+		}
+	}
+	return buf.String()
 }
 
 type ConflictDiverged struct {
@@ -21,7 +35,18 @@ type ConflictDiverged struct {
 }
 
 func (c *ConflictDiverged) Error() string {
-	return "the receiver's latest snapshot is not present on sender"
+	var buf strings.Builder
+	buf.WriteString("the receiver's latest snapshot is not present on sender:\n")
+	fmt.Fprintf(&buf, "  last common: %s\n", c.CommonAncestor.RelName())
+	fmt.Fprintf(&buf, "  sender-only:\n")
+	for _, v := range c.SenderOnly {
+		fmt.Fprintf(&buf, "    %s\n", v.RelName())
+	}
+	fmt.Fprintf(&buf, "  receiver-only:\n")
+	for _, v := range c.ReceiverOnly {
+		fmt.Fprintf(&buf, "    %s\n", v.RelName())
+	}
+	return buf.String()
 }
 
 func SortVersionListByCreateTXGThenBookmarkLTSnapshot(fsvslice []*FilesystemVersion) []*FilesystemVersion {

replication/logic/diff/diff_test.go

@@ -0,0 +1,130 @@
+package diff
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	. "github.com/zrepl/zrepl/replication/logic/pdu"
+)
+
+func fsvlist(fsv ...string) (r []*FilesystemVersion) {
+
+	r = make([]*FilesystemVersion, len(fsv))
+	for i, f := range fsv {
+
+		// parse the id from fsvlist. it is used to derivce Guid,CreateTXG and Creation attrs
+		split := strings.Split(f, ",")
+		if len(split) != 2 {
+			panic("invalid fsv spec")
+		}
+		id, err := strconv.Atoi(split[1])
+		if err != nil {
+			panic(err)
+		}
+		creation := func(id int) string {
+			return FilesystemVersionCreation(time.Unix(0, 0).Add(time.Duration(id) * time.Second))
+		}
+		if strings.HasPrefix(f, "#") {
+			r[i] = &FilesystemVersion{
+				Name:      strings.TrimPrefix(f, "#"),
+				Type:      FilesystemVersion_Bookmark,
+				Guid:      uint64(id),
+				CreateTXG: uint64(id),
+				Creation:  creation(id),
+			}
+		} else if strings.HasPrefix(f, "@") {
+			r[i] = &FilesystemVersion{
+				Name:      strings.TrimPrefix(f, "@"),
+				Type:      FilesystemVersion_Snapshot,
+				Guid:      uint64(id),
+				CreateTXG: uint64(id),
+				Creation:  creation(id),
+			}
+		} else {
+			panic("invalid character")
+		}
+	}
+	return
+}
+
+func doTest(receiver, sender []*FilesystemVersion, validate func(incpath []*FilesystemVersion, conflict error)) {
+	p, err := IncrementalPath(receiver, sender)
+	validate(p, err)
+}
+
+func TestIncrementalPath_SnapshotsOnly(t *testing.T) {
+
+	l := fsvlist
+
+	// basic functionality
+	doTest(l("@a,1", "@b,2"), l("@a,1", "@b,2", "@c,3", "@d,4"), func(path []*FilesystemVersion, conflict error) {
+		assert.Equal(t, l("@b,2", "@c,3", "@d,4"), path)
+	})
+
+	// no common ancestor
+	doTest(l(), l("@a,1"), func(path []*FilesystemVersion, conflict error) {
+		assert.Nil(t, path)
+		ca, ok := conflict.(*ConflictNoCommonAncestor)
+		require.True(t, ok)
+		assert.Equal(t, l("@a,1"), ca.SortedSenderVersions)
+	})
+	doTest(l("@a,1", "@b,2"), l("@c,3", "@d,4"), func(path []*FilesystemVersion, conflict error) {
+		assert.Nil(t, path)
+		ca, ok := conflict.(*ConflictNoCommonAncestor)
+		require.True(t, ok)
+		assert.Equal(t, l("@a,1", "@b,2"), ca.SortedReceiverVersions)
+		assert.Equal(t, l("@c,3", "@d,4"), ca.SortedSenderVersions)
+	})
+
+	// divergence is detected
+	doTest(l("@a,1", "@b1,2"), l("@a,1", "@b2,3"), func(path []*FilesystemVersion, conflict error) {
+		assert.Nil(t, path)
+		cd, ok := conflict.(*ConflictDiverged)
+		require.True(t, ok)
+		assert.Equal(t, l("@a,1")[0], cd.CommonAncestor)
+		assert.Equal(t, l("@b1,2"), cd.ReceiverOnly)
+		assert.Equal(t, l("@b2,3"), cd.SenderOnly)
+	})
+
+	// gaps before most recent common ancestor do not matter
+	doTest(l("@a,1", "@b,2", "@c,3"), l("@a,1", "@c,3", "@d,4"), func(path []*FilesystemVersion, conflict error) {
+		assert.Equal(t, l("@c,3", "@d,4"), path)
+	})
+
+	// sender with earlier but also current version as sender is not a conflict
+	doTest(l("@c,3"), l("@a,1", "@b,2", "@c,3") , func(path []*FilesystemVersion, conflict error) {
+		t.Logf("path: %#v", path)
+		t.Logf("conflict: %#v", conflict)
+		assert.Empty(t, path)
+		assert.Nil(t, conflict)
+	})
+
+}
+
+func TestIncrementalPath_BookmarkSupport(t *testing.T) {
+	l := fsvlist
+
+	// bookmarks are used
+	doTest(l("@a,1"), l("#a,1", "@b,2"), func(path []*FilesystemVersion, conflict error) {
+		assert.Equal(t, l("#a,1", "@b,2"), path)
+	})
+
+	// boomarks are stripped from IncrementalPath (cannot send incrementally)
+	doTest(l("@a,1"), l("#a,1", "#b,2", "@c,3"), func(path []*FilesystemVersion, conflict error) {
+		assert.Equal(t, l("#a,1", "@c,3"), path)
+	})
+
+	// test that snapshots are preferred over bookmarks in IncrementalPath
+	doTest(l("@a,1"), l("#a,1", "@a,1", "@b,2"), func(path []*FilesystemVersion, conflict error) {
+		assert.Equal(t, l("@a,1", "@b,2"), path)
+	})
+	doTest(l("@a,1"), l("@a,1", "#a,1", "@b,2"), func(path []*FilesystemVersion, conflict error) {
+		assert.Equal(t, l("@a,1", "@b,2"), path)
+	})
+
+}

replication/logic/pdu/pdu.pb.go

@@ -3,10 +3,13 @@
 
 package pdu
 
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
 import (
-	fmt "fmt"
-	proto "github.com/golang/protobuf/proto"
-	math "math"
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -31,7 +34,6 @@ var FilesystemVersion_VersionType_name = map[int32]string{
 	0: "Snapshot",
 	1: "Bookmark",
 }
-
 var FilesystemVersion_VersionType_value = map[string]int32{
 	"Snapshot": 0,
 	"Bookmark": 1,
@@ -40,9 +42,8 @@ var FilesystemVersion_VersionType_value = map[string]int32{
 func (x FilesystemVersion_VersionType) String() string {
 	return proto.EnumName(FilesystemVersion_VersionType_name, int32(x))
 }
-
 func (FilesystemVersion_VersionType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{5, 0}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{5, 0}
 }
 
 type ListFilesystemReq struct {
@@ -55,17 +56,16 @@ func (m *ListFilesystemReq) Reset()         { *m = ListFilesystemReq{} }
 func (m *ListFilesystemReq) String() string { return proto.CompactTextString(m) }
 func (*ListFilesystemReq) ProtoMessage()    {}
 func (*ListFilesystemReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{0}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{0}
 }
-
 func (m *ListFilesystemReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesystemReq.Unmarshal(m, b)
 }
 func (m *ListFilesystemReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ListFilesystemReq.Marshal(b, m, deterministic)
 }
-func (m *ListFilesystemReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListFilesystemReq.Merge(m, src)
+func (dst *ListFilesystemReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListFilesystemReq.Merge(dst, src)
 }
 func (m *ListFilesystemReq) XXX_Size() int {
 	return xxx_messageInfo_ListFilesystemReq.Size(m)
@@ -87,17 +87,16 @@ func (m *ListFilesystemRes) Reset()         { *m = ListFilesystemRes{} }
 func (m *ListFilesystemRes) String() string { return proto.CompactTextString(m) }
 func (*ListFilesystemRes) ProtoMessage()    {}
 func (*ListFilesystemRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{1}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{1}
 }
-
 func (m *ListFilesystemRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesystemRes.Unmarshal(m, b)
 }
 func (m *ListFilesystemRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ListFilesystemRes.Marshal(b, m, deterministic)
 }
-func (m *ListFilesystemRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListFilesystemRes.Merge(m, src)
+func (dst *ListFilesystemRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListFilesystemRes.Merge(dst, src)
 }
 func (m *ListFilesystemRes) XXX_Size() int {
 	return xxx_messageInfo_ListFilesystemRes.Size(m)
@@ -118,6 +117,7 @@ func (m *ListFilesystemRes) GetFilesystems() []*Filesystem {
 type Filesystem struct {
 	Path                 string   `protobuf:"bytes,1,opt,name=Path,proto3" json:"Path,omitempty"`
 	ResumeToken          string   `protobuf:"bytes,2,opt,name=ResumeToken,proto3" json:"ResumeToken,omitempty"`
+	IsPlaceholder        bool     `protobuf:"varint,3,opt,name=IsPlaceholder,proto3" json:"IsPlaceholder,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -127,17 +127,16 @@ func (m *Filesystem) Reset()         { *m = Filesystem{} }
 func (m *Filesystem) String() string { return proto.CompactTextString(m) }
 func (*Filesystem) ProtoMessage()    {}
 func (*Filesystem) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{2}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{2}
 }
-
 func (m *Filesystem) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Filesystem.Unmarshal(m, b)
 }
 func (m *Filesystem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Filesystem.Marshal(b, m, deterministic)
 }
-func (m *Filesystem) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Filesystem.Merge(m, src)
+func (dst *Filesystem) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Filesystem.Merge(dst, src)
 }
 func (m *Filesystem) XXX_Size() int {
 	return xxx_messageInfo_Filesystem.Size(m)
@@ -162,6 +161,13 @@ func (m *Filesystem) GetResumeToken() string {
 	return ""
 }
 
+func (m *Filesystem) GetIsPlaceholder() bool {
+	if m != nil {
+		return m.IsPlaceholder
+	}
+	return false
+}
+
 type ListFilesystemVersionsReq struct {
 	Filesystem           string   `protobuf:"bytes,1,opt,name=Filesystem,proto3" json:"Filesystem,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -173,17 +179,16 @@ func (m *ListFilesystemVersionsReq) Reset()         { *m = ListFilesystemVersion
 func (m *ListFilesystemVersionsReq) String() string { return proto.CompactTextString(m) }
 func (*ListFilesystemVersionsReq) ProtoMessage()    {}
 func (*ListFilesystemVersionsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{3}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{3}
 }
-
 func (m *ListFilesystemVersionsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesystemVersionsReq.Unmarshal(m, b)
 }
 func (m *ListFilesystemVersionsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ListFilesystemVersionsReq.Marshal(b, m, deterministic)
 }
-func (m *ListFilesystemVersionsReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListFilesystemVersionsReq.Merge(m, src)
+func (dst *ListFilesystemVersionsReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListFilesystemVersionsReq.Merge(dst, src)
 }
 func (m *ListFilesystemVersionsReq) XXX_Size() int {
 	return xxx_messageInfo_ListFilesystemVersionsReq.Size(m)
@@ -212,17 +217,16 @@ func (m *ListFilesystemVersionsRes) Reset()         { *m = ListFilesystemVersion
 func (m *ListFilesystemVersionsRes) String() string { return proto.CompactTextString(m) }
 func (*ListFilesystemVersionsRes) ProtoMessage()    {}
 func (*ListFilesystemVersionsRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{4}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{4}
 }
-
 func (m *ListFilesystemVersionsRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesystemVersionsRes.Unmarshal(m, b)
 }
 func (m *ListFilesystemVersionsRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ListFilesystemVersionsRes.Marshal(b, m, deterministic)
 }
-func (m *ListFilesystemVersionsRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ListFilesystemVersionsRes.Merge(m, src)
+func (dst *ListFilesystemVersionsRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ListFilesystemVersionsRes.Merge(dst, src)
 }
 func (m *ListFilesystemVersionsRes) XXX_Size() int {
 	return xxx_messageInfo_ListFilesystemVersionsRes.Size(m)
@@ -241,7 +245,7 @@ func (m *ListFilesystemVersionsRes) GetVersions() []*FilesystemVersion {
 }
 
 type FilesystemVersion struct {
-	Type                 FilesystemVersion_VersionType `protobuf:"varint,1,opt,name=Type,proto3,enum=pdu.FilesystemVersion_VersionType" json:"Type,omitempty"`
+	Type                 FilesystemVersion_VersionType `protobuf:"varint,1,opt,name=Type,proto3,enum=FilesystemVersion_VersionType" json:"Type,omitempty"`
 	Name                 string                        `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
 	Guid                 uint64                        `protobuf:"varint,3,opt,name=Guid,proto3" json:"Guid,omitempty"`
 	CreateTXG            uint64                        `protobuf:"varint,4,opt,name=CreateTXG,proto3" json:"CreateTXG,omitempty"`
@@ -255,17 +259,16 @@ func (m *FilesystemVersion) Reset()         { *m = FilesystemVersion{} }
 func (m *FilesystemVersion) String() string { return proto.CompactTextString(m) }
 func (*FilesystemVersion) ProtoMessage()    {}
 func (*FilesystemVersion) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{5}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{5}
 }
-
 func (m *FilesystemVersion) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FilesystemVersion.Unmarshal(m, b)
 }
 func (m *FilesystemVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_FilesystemVersion.Marshal(b, m, deterministic)
 }
-func (m *FilesystemVersion) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_FilesystemVersion.Merge(m, src)
+func (dst *FilesystemVersion) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FilesystemVersion.Merge(dst, src)
 }
 func (m *FilesystemVersion) XXX_Size() int {
 	return xxx_messageInfo_FilesystemVersion.Size(m)
@@ -336,17 +339,16 @@ func (m *SendReq) Reset()         { *m = SendReq{} }
 func (m *SendReq) String() string { return proto.CompactTextString(m) }
 func (*SendReq) ProtoMessage()    {}
 func (*SendReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{6}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{6}
 }
-
 func (m *SendReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SendReq.Unmarshal(m, b)
 }
 func (m *SendReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_SendReq.Marshal(b, m, deterministic)
 }
-func (m *SendReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SendReq.Merge(m, src)
+func (dst *SendReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SendReq.Merge(dst, src)
 }
 func (m *SendReq) XXX_Size() int {
 	return xxx_messageInfo_SendReq.Size(m)
@@ -418,17 +420,16 @@ func (m *Property) Reset()         { *m = Property{} }
 func (m *Property) String() string { return proto.CompactTextString(m) }
 func (*Property) ProtoMessage()    {}
 func (*Property) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{7}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{7}
 }
-
 func (m *Property) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Property.Unmarshal(m, b)
 }
 func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_Property.Marshal(b, m, deterministic)
 }
-func (m *Property) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Property.Merge(m, src)
+func (dst *Property) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Property.Merge(dst, src)
 }
 func (m *Property) XXX_Size() int {
 	return xxx_messageInfo_Property.Size(m)
@@ -455,11 +456,11 @@ func (m *Property) GetValue() string {
 
 type SendRes struct {
 	// Whether the resume token provided in the request has been used or not.
-	UsedResumeToken bool `protobuf:"varint,1,opt,name=UsedResumeToken,proto3" json:"UsedResumeToken,omitempty"`
+	UsedResumeToken bool `protobuf:"varint,2,opt,name=UsedResumeToken,proto3" json:"UsedResumeToken,omitempty"`
 	// Expected stream size determined by dry run, not exact.
 	// 0 indicates that for the given SendReq, no size estimate could be made.
-	ExpectedSize         int64       `protobuf:"varint,2,opt,name=ExpectedSize,proto3" json:"ExpectedSize,omitempty"`
-	Properties           []*Property `protobuf:"bytes,3,rep,name=Properties,proto3" json:"Properties,omitempty"`
+	ExpectedSize         int64       `protobuf:"varint,3,opt,name=ExpectedSize,proto3" json:"ExpectedSize,omitempty"`
+	Properties           []*Property `protobuf:"bytes,4,rep,name=Properties,proto3" json:"Properties,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
 	XXX_unrecognized     []byte      `json:"-"`
 	XXX_sizecache        int32       `json:"-"`
@@ -469,17 +470,16 @@ func (m *SendRes) Reset()         { *m = SendRes{} }
 func (m *SendRes) String() string { return proto.CompactTextString(m) }
 func (*SendRes) ProtoMessage()    {}
 func (*SendRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{8}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{8}
 }
-
 func (m *SendRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SendRes.Unmarshal(m, b)
 }
 func (m *SendRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_SendRes.Marshal(b, m, deterministic)
 }
-func (m *SendRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_SendRes.Merge(m, src)
+func (dst *SendRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SendRes.Merge(dst, src)
 }
 func (m *SendRes) XXX_Size() int {
 	return xxx_messageInfo_SendRes.Size(m)
@@ -524,17 +524,16 @@ func (m *ReceiveReq) Reset()         { *m = ReceiveReq{} }
 func (m *ReceiveReq) String() string { return proto.CompactTextString(m) }
 func (*ReceiveReq) ProtoMessage()    {}
 func (*ReceiveReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{9}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{9}
 }
-
 func (m *ReceiveReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReceiveReq.Unmarshal(m, b)
 }
 func (m *ReceiveReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ReceiveReq.Marshal(b, m, deterministic)
 }
-func (m *ReceiveReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReceiveReq.Merge(m, src)
+func (dst *ReceiveReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiveReq.Merge(dst, src)
 }
 func (m *ReceiveReq) XXX_Size() int {
 	return xxx_messageInfo_ReceiveReq.Size(m)
@@ -569,17 +568,16 @@ func (m *ReceiveRes) Reset()         { *m = ReceiveRes{} }
 func (m *ReceiveRes) String() string { return proto.CompactTextString(m) }
 func (*ReceiveRes) ProtoMessage()    {}
 func (*ReceiveRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{10}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{10}
 }
-
 func (m *ReceiveRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReceiveRes.Unmarshal(m, b)
 }
 func (m *ReceiveRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ReceiveRes.Marshal(b, m, deterministic)
 }
-func (m *ReceiveRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReceiveRes.Merge(m, src)
+func (dst *ReceiveRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiveRes.Merge(dst, src)
 }
 func (m *ReceiveRes) XXX_Size() int {
 	return xxx_messageInfo_ReceiveRes.Size(m)
@@ -603,17 +601,16 @@ func (m *DestroySnapshotsReq) Reset()         { *m = DestroySnapshotsReq{} }
 func (m *DestroySnapshotsReq) String() string { return proto.CompactTextString(m) }
 func (*DestroySnapshotsReq) ProtoMessage()    {}
 func (*DestroySnapshotsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{11}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{11}
 }
-
 func (m *DestroySnapshotsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DestroySnapshotsReq.Unmarshal(m, b)
 }
 func (m *DestroySnapshotsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_DestroySnapshotsReq.Marshal(b, m, deterministic)
 }
-func (m *DestroySnapshotsReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DestroySnapshotsReq.Merge(m, src)
+func (dst *DestroySnapshotsReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DestroySnapshotsReq.Merge(dst, src)
 }
 func (m *DestroySnapshotsReq) XXX_Size() int {
 	return xxx_messageInfo_DestroySnapshotsReq.Size(m)
@@ -650,17 +647,16 @@ func (m *DestroySnapshotRes) Reset()         { *m = DestroySnapshotRes{} }
 func (m *DestroySnapshotRes) String() string { return proto.CompactTextString(m) }
 func (*DestroySnapshotRes) ProtoMessage()    {}
 func (*DestroySnapshotRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{12}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{12}
 }
-
 func (m *DestroySnapshotRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DestroySnapshotRes.Unmarshal(m, b)
 }
 func (m *DestroySnapshotRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_DestroySnapshotRes.Marshal(b, m, deterministic)
 }
-func (m *DestroySnapshotRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DestroySnapshotRes.Merge(m, src)
+func (dst *DestroySnapshotRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DestroySnapshotRes.Merge(dst, src)
 }
 func (m *DestroySnapshotRes) XXX_Size() int {
 	return xxx_messageInfo_DestroySnapshotRes.Size(m)
@@ -696,17 +692,16 @@ func (m *DestroySnapshotsRes) Reset()         { *m = DestroySnapshotsRes{} }
 func (m *DestroySnapshotsRes) String() string { return proto.CompactTextString(m) }
 func (*DestroySnapshotsRes) ProtoMessage()    {}
 func (*DestroySnapshotsRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{13}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{13}
 }
-
 func (m *DestroySnapshotsRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DestroySnapshotsRes.Unmarshal(m, b)
 }
 func (m *DestroySnapshotsRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_DestroySnapshotsRes.Marshal(b, m, deterministic)
 }
-func (m *DestroySnapshotsRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DestroySnapshotsRes.Merge(m, src)
+func (dst *DestroySnapshotsRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DestroySnapshotsRes.Merge(dst, src)
 }
 func (m *DestroySnapshotsRes) XXX_Size() int {
 	return xxx_messageInfo_DestroySnapshotsRes.Size(m)
@@ -739,17 +734,16 @@ func (m *ReplicationCursorReq) Reset()         { *m = ReplicationCursorReq{} }
 func (m *ReplicationCursorReq) String() string { return proto.CompactTextString(m) }
 func (*ReplicationCursorReq) ProtoMessage()    {}
 func (*ReplicationCursorReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{14}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{14}
 }
-
 func (m *ReplicationCursorReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplicationCursorReq.Unmarshal(m, b)
 }
 func (m *ReplicationCursorReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ReplicationCursorReq.Marshal(b, m, deterministic)
 }
-func (m *ReplicationCursorReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplicationCursorReq.Merge(m, src)
+func (dst *ReplicationCursorReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplicationCursorReq.Merge(dst, src)
 }
 func (m *ReplicationCursorReq) XXX_Size() int {
 	return xxx_messageInfo_ReplicationCursorReq.Size(m)
@@ -888,17 +882,16 @@ func (m *ReplicationCursorReq_GetOp) Reset()         { *m = ReplicationCursorReq
 func (m *ReplicationCursorReq_GetOp) String() string { return proto.CompactTextString(m) }
 func (*ReplicationCursorReq_GetOp) ProtoMessage()    {}
 func (*ReplicationCursorReq_GetOp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{14, 0}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{14, 0}
 }
-
 func (m *ReplicationCursorReq_GetOp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplicationCursorReq_GetOp.Unmarshal(m, b)
 }
 func (m *ReplicationCursorReq_GetOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ReplicationCursorReq_GetOp.Marshal(b, m, deterministic)
 }
-func (m *ReplicationCursorReq_GetOp) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplicationCursorReq_GetOp.Merge(m, src)
+func (dst *ReplicationCursorReq_GetOp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplicationCursorReq_GetOp.Merge(dst, src)
 }
 func (m *ReplicationCursorReq_GetOp) XXX_Size() int {
 	return xxx_messageInfo_ReplicationCursorReq_GetOp.Size(m)
@@ -920,17 +913,16 @@ func (m *ReplicationCursorReq_SetOp) Reset()         { *m = ReplicationCursorReq
 func (m *ReplicationCursorReq_SetOp) String() string { return proto.CompactTextString(m) }
 func (*ReplicationCursorReq_SetOp) ProtoMessage()    {}
 func (*ReplicationCursorReq_SetOp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{14, 1}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{14, 1}
 }
-
 func (m *ReplicationCursorReq_SetOp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplicationCursorReq_SetOp.Unmarshal(m, b)
 }
 func (m *ReplicationCursorReq_SetOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ReplicationCursorReq_SetOp.Marshal(b, m, deterministic)
 }
-func (m *ReplicationCursorReq_SetOp) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplicationCursorReq_SetOp.Merge(m, src)
+func (dst *ReplicationCursorReq_SetOp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplicationCursorReq_SetOp.Merge(dst, src)
 }
 func (m *ReplicationCursorReq_SetOp) XXX_Size() int {
 	return xxx_messageInfo_ReplicationCursorReq_SetOp.Size(m)
@@ -951,7 +943,7 @@ func (m *ReplicationCursorReq_SetOp) GetSnapshot() string {
 type ReplicationCursorRes struct {
 	// Types that are valid to be assigned to Result:
 	//	*ReplicationCursorRes_Guid
-	//	*ReplicationCursorRes_Error
+	//	*ReplicationCursorRes_Notexist
 	Result               isReplicationCursorRes_Result `protobuf_oneof:"Result"`
 	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
 	XXX_unrecognized     []byte                        `json:"-"`
@@ -962,17 +954,16 @@ func (m *ReplicationCursorRes) Reset()         { *m = ReplicationCursorRes{} }
 func (m *ReplicationCursorRes) String() string { return proto.CompactTextString(m) }
 func (*ReplicationCursorRes) ProtoMessage()    {}
 func (*ReplicationCursorRes) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5e683fe3d6db3968, []int{15}
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{15}
 }
-
 func (m *ReplicationCursorRes) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplicationCursorRes.Unmarshal(m, b)
 }
 func (m *ReplicationCursorRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	return xxx_messageInfo_ReplicationCursorRes.Marshal(b, m, deterministic)
 }
-func (m *ReplicationCursorRes) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReplicationCursorRes.Merge(m, src)
+func (dst *ReplicationCursorRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplicationCursorRes.Merge(dst, src)
 }
 func (m *ReplicationCursorRes) XXX_Size() int {
 	return xxx_messageInfo_ReplicationCursorRes.Size(m)
@@ -991,13 +982,13 @@ type ReplicationCursorRes_Guid struct {
 	Guid uint64 `protobuf:"varint,1,opt,name=Guid,proto3,oneof"`
 }
 
-type ReplicationCursorRes_Error struct {
-	Error string `protobuf:"bytes,2,opt,name=Error,proto3,oneof"`
+type ReplicationCursorRes_Notexist struct {
+	Notexist bool `protobuf:"varint,2,opt,name=Notexist,proto3,oneof"`
 }
 
 func (*ReplicationCursorRes_Guid) isReplicationCursorRes_Result() {}
 
-func (*ReplicationCursorRes_Error) isReplicationCursorRes_Result() {}
+func (*ReplicationCursorRes_Notexist) isReplicationCursorRes_Result() {}
 
 func (m *ReplicationCursorRes) GetResult() isReplicationCursorRes_Result {
 	if m != nil {
@@ -1013,18 +1004,18 @@ func (m *ReplicationCursorRes) GetGuid() uint64 {
 	return 0
 }
 
-func (m *ReplicationCursorRes) GetError() string {
-	if x, ok := m.GetResult().(*ReplicationCursorRes_Error); ok {
-		return x.Error
+func (m *ReplicationCursorRes) GetNotexist() bool {
+	if x, ok := m.GetResult().(*ReplicationCursorRes_Notexist); ok {
+		return x.Notexist
 	}
-	return ""
+	return false
 }
 
 // XXX_OneofFuncs is for the internal use of the proto package.
 func (*ReplicationCursorRes) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 	return _ReplicationCursorRes_OneofMarshaler, _ReplicationCursorRes_OneofUnmarshaler, _ReplicationCursorRes_OneofSizer, []interface{}{
 		(*ReplicationCursorRes_Guid)(nil),
-		(*ReplicationCursorRes_Error)(nil),
+		(*ReplicationCursorRes_Notexist)(nil),
 	}
 }
 
@@ -1035,9 +1026,13 @@ func _ReplicationCursorRes_OneofMarshaler(msg proto.Message, b *proto.Buffer) er
 	case *ReplicationCursorRes_Guid:
 		b.EncodeVarint(1<<3 | proto.WireVarint)
 		b.EncodeVarint(uint64(x.Guid))
-	case *ReplicationCursorRes_Error:
-		b.EncodeVarint(2<<3 | proto.WireBytes)
-		b.EncodeStringBytes(x.Error)
+	case *ReplicationCursorRes_Notexist:
+		t := uint64(0)
+		if x.Notexist {
+			t = 1
+		}
+		b.EncodeVarint(2<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
 	case nil:
 	default:
 		return fmt.Errorf("ReplicationCursorRes.Result has unexpected type %T", x)
@@ -1055,12 +1050,12 @@ func _ReplicationCursorRes_OneofUnmarshaler(msg proto.Message, tag, wire int, b
 		x, err := b.DecodeVarint()
 		m.Result = &ReplicationCursorRes_Guid{x}
 		return true, err
-	case 2: // Result.Error
-		if wire != proto.WireBytes {
+	case 2: // Result.Notexist
+		if wire != proto.WireVarint {
 			return true, proto.ErrInternalBadWireType
 		}
-		x, err := b.DecodeStringBytes()
-		m.Result = &ReplicationCursorRes_Error{x}
+		x, err := b.DecodeVarint()
+		m.Result = &ReplicationCursorRes_Notexist{x != 0}
 		return true, err
 	default:
 		return false, nil
@@ -1074,10 +1069,9 @@ func _ReplicationCursorRes_OneofSizer(msg proto.Message) (n int) {
 	case *ReplicationCursorRes_Guid:
 		n += 1 // tag and wire
 		n += proto.SizeVarint(uint64(x.Guid))
-	case *ReplicationCursorRes_Error:
+	case *ReplicationCursorRes_Notexist:
 		n += 1 // tag and wire
-		n += proto.SizeVarint(uint64(len(x.Error)))
-		n += len(x.Error)
+		n += 1
 	case nil:
 	default:
 		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
@@ -1085,72 +1079,363 @@ func _ReplicationCursorRes_OneofSizer(msg proto.Message) (n int) {
 	return n
 }
 
-func init() {
-	proto.RegisterEnum("pdu.FilesystemVersion_VersionType", FilesystemVersion_VersionType_name, FilesystemVersion_VersionType_value)
-	proto.RegisterType((*ListFilesystemReq)(nil), "pdu.ListFilesystemReq")
-	proto.RegisterType((*ListFilesystemRes)(nil), "pdu.ListFilesystemRes")
-	proto.RegisterType((*Filesystem)(nil), "pdu.Filesystem")
-	proto.RegisterType((*ListFilesystemVersionsReq)(nil), "pdu.ListFilesystemVersionsReq")
-	proto.RegisterType((*ListFilesystemVersionsRes)(nil), "pdu.ListFilesystemVersionsRes")
-	proto.RegisterType((*FilesystemVersion)(nil), "pdu.FilesystemVersion")
-	proto.RegisterType((*SendReq)(nil), "pdu.SendReq")
-	proto.RegisterType((*Property)(nil), "pdu.Property")
-	proto.RegisterType((*SendRes)(nil), "pdu.SendRes")
-	proto.RegisterType((*ReceiveReq)(nil), "pdu.ReceiveReq")
-	proto.RegisterType((*ReceiveRes)(nil), "pdu.ReceiveRes")
-	proto.RegisterType((*DestroySnapshotsReq)(nil), "pdu.DestroySnapshotsReq")
-	proto.RegisterType((*DestroySnapshotRes)(nil), "pdu.DestroySnapshotRes")
-	proto.RegisterType((*DestroySnapshotsRes)(nil), "pdu.DestroySnapshotsRes")
-	proto.RegisterType((*ReplicationCursorReq)(nil), "pdu.ReplicationCursorReq")
-	proto.RegisterType((*ReplicationCursorReq_GetOp)(nil), "pdu.ReplicationCursorReq.GetOp")
-	proto.RegisterType((*ReplicationCursorReq_SetOp)(nil), "pdu.ReplicationCursorReq.SetOp")
-	proto.RegisterType((*ReplicationCursorRes)(nil), "pdu.ReplicationCursorRes")
+type PingReq struct {
+	Message              string   `protobuf:"bytes,1,opt,name=Message,proto3" json:"Message,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
-func init() { proto.RegisterFile("pdu.proto", fileDescriptor_5e683fe3d6db3968) }
+func (m *PingReq) Reset()         { *m = PingReq{} }
+func (m *PingReq) String() string { return proto.CompactTextString(m) }
+func (*PingReq) ProtoMessage()    {}
+func (*PingReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{16}
+}
+func (m *PingReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PingReq.Unmarshal(m, b)
+}
+func (m *PingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PingReq.Marshal(b, m, deterministic)
+}
+func (dst *PingReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PingReq.Merge(dst, src)
+}
+func (m *PingReq) XXX_Size() int {
+	return xxx_messageInfo_PingReq.Size(m)
+}
+func (m *PingReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_PingReq.DiscardUnknown(m)
+}
 
-var fileDescriptor_5e683fe3d6db3968 = []byte{
-	// 657 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xcb, 0x6e, 0xdb, 0x3a,
-	0x10, 0xb5, 0x6c, 0xd9, 0x96, 0xc7, 0xb9, 0x79, 0x30, 0x41, 0xae, 0x6e, 0x70, 0x71, 0xaf, 0xc1,
-	0x6e, 0xdc, 0x02, 0x35, 0x50, 0x27, 0xe8, 0xa6, 0x3b, 0xe7, 0xe5, 0x45, 0x91, 0x04, 0xb4, 0x1b,
-	0x64, 0x55, 0x40, 0x8d, 0x06, 0x8d, 0xe0, 0x07, 0x15, 0x92, 0x2a, 0xea, 0x7e, 0x40, 0xff, 0xa9,
-	0xff, 0xd1, 0x45, 0x3f, 0xa7, 0xe0, 0x58, 0x92, 0x15, 0xdb, 0x0d, 0xbc, 0x32, 0xcf, 0xf0, 0x70,
-	0xe6, 0xcc, 0xa1, 0x86, 0x86, 0x46, 0x1c, 0x26, 0x9d, 0x58, 0x49, 0x23, 0x59, 0x25, 0x0e, 0x13,
-	0xbe, 0x0f, 0x7b, 0xef, 0x23, 0x6d, 0x2e, 0xa2, 0x31, 0xea, 0x99, 0x36, 0x38, 0x11, 0xf8, 0xc8,
-	0x2f, 0x56, 0x83, 0x9a, 0xbd, 0x81, 0xe6, 0x22, 0xa0, 0x7d, 0xa7, 0x55, 0x69, 0x37, 0xbb, 0x3b,
-	0x1d, 0x9b, 0xaf, 0x40, 0x2c, 0x72, 0x78, 0x0f, 0x60, 0x01, 0x19, 0x03, 0xf7, 0x26, 0x30, 0x0f,
-	0xbe, 0xd3, 0x72, 0xda, 0x0d, 0x41, 0x6b, 0xd6, 0x82, 0xa6, 0x40, 0x9d, 0x4c, 0x70, 0x28, 0x47,
-	0x38, 0xf5, 0xcb, 0xb4, 0x55, 0x0c, 0xf1, 0x77, 0xf0, 0xcf, 0x53, 0x2d, 0xb7, 0xa8, 0x74, 0x24,
-	0xa7, 0x5a, 0xe0, 0x23, 0xfb, 0xaf, 0x58, 0x20, 0x4d, 0x5c, 0x88, 0xf0, 0xeb, 0x3f, 0x1f, 0xd6,
-	0xac, 0x0b, 0x5e, 0x06, 0xd3, 0x6e, 0x0e, 0x97, 0xba, 0x49, 0xb7, 0x45, 0xce, 0xe3, 0xbf, 0x1c,
-	0xd8, 0x5b, 0xd9, 0x67, 0x6f, 0xc1, 0x1d, 0xce, 0x62, 0x24, 0x01, 0xdb, 0x5d, 0xbe, 0x3e, 0x4b,
-	0x27, 0xfd, 0xb5, 0x4c, 0x41, 0x7c, 0xeb, 0xc8, 0x55, 0x30, 0xc1, 0xb4, 0x6d, 0x5a, 0xdb, 0xd8,
-	0x65, 0x12, 0x85, 0x7e, 0xa5, 0xe5, 0xb4, 0x5d, 0x41, 0x6b, 0xf6, 0x2f, 0x34, 0x4e, 0x15, 0x06,
-	0x06, 0x87, 0x77, 0x97, 0xbe, 0x4b, 0x1b, 0x8b, 0x00, 0x3b, 0x02, 0x8f, 0x40, 0x24, 0xa7, 0x7e,
-	0x95, 0x32, 0xe5, 0x98, 0xbf, 0x84, 0x66, 0xa1, 0x2c, 0xdb, 0x02, 0x6f, 0x30, 0x0d, 0x62, 0xfd,
-	0x20, 0xcd, 0x6e, 0xc9, 0xa2, 0x9e, 0x94, 0xa3, 0x49, 0xa0, 0x46, 0xbb, 0x0e, 0xff, 0xe1, 0x40,
-	0x7d, 0x80, 0xd3, 0x70, 0x03, 0x5f, 0xad, 0xc8, 0x0b, 0x25, 0x27, 0x99, 0x70, 0xbb, 0x66, 0xdb,
-	0x50, 0x1e, 0x4a, 0x92, 0xdd, 0x10, 0xe5, 0xa1, 0x5c, 0xbe, 0x5a, 0x77, 0xe5, 0x6a, 0x49, 0xb8,
-	0x9c, 0xc4, 0x0a, 0xb5, 0x26, 0xe1, 0x9e, 0xc8, 0x31, 0x3b, 0x80, 0xea, 0x19, 0x86, 0x49, 0xec,
-	0xd7, 0x68, 0x63, 0x0e, 0xd8, 0x21, 0xd4, 0xce, 0xd4, 0x4c, 0x24, 0x53, 0xbf, 0x4e, 0xe1, 0x14,
-	0xf1, 0x13, 0xf0, 0x6e, 0x94, 0x8c, 0x51, 0x99, 0x59, 0x6e, 0xaa, 0x53, 0x30, 0xf5, 0x00, 0xaa,
-	0xb7, 0xc1, 0x38, 0xc9, 0x9c, 0x9e, 0x03, 0xfe, 0x3d, 0xef, 0x58, 0xb3, 0x36, 0xec, 0x7c, 0xd0,
-	0x18, 0x16, 0x15, 0x3b, 0x54, 0x62, 0x39, 0xcc, 0x38, 0x6c, 0x9d, 0x7f, 0x8d, 0xf1, 0xde, 0x60,
-	0x38, 0x88, 0xbe, 0xcd, 0x53, 0x56, 0xc4, 0x93, 0x18, 0x7b, 0x0d, 0x90, 0xea, 0x89, 0x50, 0xfb,
-	0x15, 0xfa, 0xb8, 0xfe, 0xa2, 0xcf, 0x22, 0x93, 0x29, 0x0a, 0x04, 0x7e, 0x07, 0x20, 0xf0, 0x1e,
-	0xa3, 0x2f, 0xb8, 0x89, 0xf9, 0xaf, 0x60, 0xf7, 0x74, 0x8c, 0x81, 0x5a, 0x1e, 0x1c, 0x4f, 0xac,
-	0xc4, 0xf9, 0x56, 0x21, 0xb3, 0xe6, 0x23, 0xd8, 0x3f, 0x43, 0x6d, 0x94, 0x9c, 0x65, 0x5f, 0xc1,
-	0x26, 0x53, 0xc4, 0x4e, 0xa0, 0x91, 0xf3, 0xfd, 0xf2, 0xb3, 0x93, 0xb2, 0x20, 0xf2, 0x8f, 0xc0,
-	0x96, 0x8a, 0xa5, 0x43, 0x97, 0x41, 0xaa, 0xf4, 0xcc, 0xd0, 0x65, 0x3c, 0x7b, 0x7b, 0xe7, 0x4a,
-	0x49, 0x95, 0xdd, 0x1e, 0x01, 0xde, 0x5f, 0xd7, 0x8c, 0x7d, 0xa6, 0xea, 0xd6, 0x80, 0xb1, 0xc9,
-	0x86, 0xfa, 0x6f, 0xca, 0xbf, 0x2a, 0x45, 0x64, 0x3c, 0xfe, 0xd3, 0x81, 0x03, 0x81, 0xf1, 0x38,
-	0xba, 0xa7, 0xa1, 0x39, 0x4d, 0x94, 0x96, 0x6a, 0x13, 0x63, 0x8e, 0xa1, 0xf2, 0x19, 0x0d, 0xc9,
-	0x6a, 0x76, 0xff, 0xa7, 0x3a, 0xeb, 0xf2, 0x74, 0x2e, 0xd1, 0x5c, 0xc7, 0xfd, 0x92, 0xb0, 0x6c,
-	0x7b, 0x48, 0xa3, 0xa1, 0x41, 0x79, 0xf6, 0xd0, 0x20, 0x3b, 0xa4, 0xd1, 0x1c, 0xd5, 0xa1, 0x4a,
-	0x49, 0x8e, 0x5e, 0x40, 0x95, 0x36, 0xec, 0xf0, 0xe4, 0x46, 0xce, 0x7d, 0xc9, 0x71, 0xcf, 0x85,
-	0xb2, 0x8c, 0xf9, 0xd5, 0xda, 0xae, 0xec, 0x68, 0xcd, 0x5f, 0x18, 0xdb, 0x8f, 0xdb, 0x2f, 0xa5,
-	0x6f, 0xcc, 0xe1, 0x13, 0x93, 0xfb, 0xa5, 0xd4, 0xe6, 0x9e, 0x07, 0xb5, 0xb9, 0x4f, 0x9f, 0x6a,
-	0xf4, 0xb7, 0x71, 0xfc, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x02, 0x35, 0xe7, 0x43, 0x43, 0x06, 0x00,
+var xxx_messageInfo_PingReq proto.InternalMessageInfo
+
+func (m *PingReq) GetMessage() string {
+	if m != nil {
+		return m.Message
+	}
+	return ""
+}
+
+type PingRes struct {
+	// Echo must be PingReq.Message
+	Echo                 string   `protobuf:"bytes,1,opt,name=Echo,proto3" json:"Echo,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PingRes) Reset()         { *m = PingRes{} }
+func (m *PingRes) String() string { return proto.CompactTextString(m) }
+func (*PingRes) ProtoMessage()    {}
+func (*PingRes) Descriptor() ([]byte, []int) {
+	return fileDescriptor_pdu_83b7e2a28d820622, []int{17}
+}
+func (m *PingRes) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PingRes.Unmarshal(m, b)
+}
+func (m *PingRes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PingRes.Marshal(b, m, deterministic)
+}
+func (dst *PingRes) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PingRes.Merge(dst, src)
+}
+func (m *PingRes) XXX_Size() int {
+	return xxx_messageInfo_PingRes.Size(m)
+}
+func (m *PingRes) XXX_DiscardUnknown() {
+	xxx_messageInfo_PingRes.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PingRes proto.InternalMessageInfo
+
+func (m *PingRes) GetEcho() string {
+	if m != nil {
+		return m.Echo
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*ListFilesystemReq)(nil), "ListFilesystemReq")
+	proto.RegisterType((*ListFilesystemRes)(nil), "ListFilesystemRes")
+	proto.RegisterType((*Filesystem)(nil), "Filesystem")
+	proto.RegisterType((*ListFilesystemVersionsReq)(nil), "ListFilesystemVersionsReq")
+	proto.RegisterType((*ListFilesystemVersionsRes)(nil), "ListFilesystemVersionsRes")
+	proto.RegisterType((*FilesystemVersion)(nil), "FilesystemVersion")
+	proto.RegisterType((*SendReq)(nil), "SendReq")
+	proto.RegisterType((*Property)(nil), "Property")
+	proto.RegisterType((*SendRes)(nil), "SendRes")
+	proto.RegisterType((*ReceiveReq)(nil), "ReceiveReq")
+	proto.RegisterType((*ReceiveRes)(nil), "ReceiveRes")
+	proto.RegisterType((*DestroySnapshotsReq)(nil), "DestroySnapshotsReq")
+	proto.RegisterType((*DestroySnapshotRes)(nil), "DestroySnapshotRes")
+	proto.RegisterType((*DestroySnapshotsRes)(nil), "DestroySnapshotsRes")
+	proto.RegisterType((*ReplicationCursorReq)(nil), "ReplicationCursorReq")
+	proto.RegisterType((*ReplicationCursorReq_GetOp)(nil), "ReplicationCursorReq.GetOp")
+	proto.RegisterType((*ReplicationCursorReq_SetOp)(nil), "ReplicationCursorReq.SetOp")
+	proto.RegisterType((*ReplicationCursorRes)(nil), "ReplicationCursorRes")
+	proto.RegisterType((*PingReq)(nil), "PingReq")
+	proto.RegisterType((*PingRes)(nil), "PingRes")
+	proto.RegisterEnum("FilesystemVersion_VersionType", FilesystemVersion_VersionType_name, FilesystemVersion_VersionType_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// ReplicationClient is the client API for Replication service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type ReplicationClient interface {
+	Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingRes, error)
+	ListFilesystems(ctx context.Context, in *ListFilesystemReq, opts ...grpc.CallOption) (*ListFilesystemRes, error)
+	ListFilesystemVersions(ctx context.Context, in *ListFilesystemVersionsReq, opts ...grpc.CallOption) (*ListFilesystemVersionsRes, error)
+	DestroySnapshots(ctx context.Context, in *DestroySnapshotsReq, opts ...grpc.CallOption) (*DestroySnapshotsRes, error)
+	ReplicationCursor(ctx context.Context, in *ReplicationCursorReq, opts ...grpc.CallOption) (*ReplicationCursorRes, error)
+}
+
+type replicationClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewReplicationClient(cc *grpc.ClientConn) ReplicationClient {
+	return &replicationClient{cc}
+}
+
+func (c *replicationClient) Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingRes, error) {
+	out := new(PingRes)
+	err := c.cc.Invoke(ctx, "/Replication/Ping", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *replicationClient) ListFilesystems(ctx context.Context, in *ListFilesystemReq, opts ...grpc.CallOption) (*ListFilesystemRes, error) {
+	out := new(ListFilesystemRes)
+	err := c.cc.Invoke(ctx, "/Replication/ListFilesystems", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *replicationClient) ListFilesystemVersions(ctx context.Context, in *ListFilesystemVersionsReq, opts ...grpc.CallOption) (*ListFilesystemVersionsRes, error) {
+	out := new(ListFilesystemVersionsRes)
+	err := c.cc.Invoke(ctx, "/Replication/ListFilesystemVersions", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *replicationClient) DestroySnapshots(ctx context.Context, in *DestroySnapshotsReq, opts ...grpc.CallOption) (*DestroySnapshotsRes, error) {
+	out := new(DestroySnapshotsRes)
+	err := c.cc.Invoke(ctx, "/Replication/DestroySnapshots", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *replicationClient) ReplicationCursor(ctx context.Context, in *ReplicationCursorReq, opts ...grpc.CallOption) (*ReplicationCursorRes, error) {
+	out := new(ReplicationCursorRes)
+	err := c.cc.Invoke(ctx, "/Replication/ReplicationCursor", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ReplicationServer is the server API for Replication service.
+type ReplicationServer interface {
+	Ping(context.Context, *PingReq) (*PingRes, error)
+	ListFilesystems(context.Context, *ListFilesystemReq) (*ListFilesystemRes, error)
+	ListFilesystemVersions(context.Context, *ListFilesystemVersionsReq) (*ListFilesystemVersionsRes, error)
+	DestroySnapshots(context.Context, *DestroySnapshotsReq) (*DestroySnapshotsRes, error)
+	ReplicationCursor(context.Context, *ReplicationCursorReq) (*ReplicationCursorRes, error)
+}
+
+func RegisterReplicationServer(s *grpc.Server, srv ReplicationServer) {
+	s.RegisterService(&_Replication_serviceDesc, srv)
+}
+
+func _Replication_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PingReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReplicationServer).Ping(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Replication/Ping",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReplicationServer).Ping(ctx, req.(*PingReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Replication_ListFilesystems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListFilesystemReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReplicationServer).ListFilesystems(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Replication/ListFilesystems",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReplicationServer).ListFilesystems(ctx, req.(*ListFilesystemReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Replication_ListFilesystemVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ListFilesystemVersionsReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReplicationServer).ListFilesystemVersions(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Replication/ListFilesystemVersions",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReplicationServer).ListFilesystemVersions(ctx, req.(*ListFilesystemVersionsReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Replication_DestroySnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DestroySnapshotsReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReplicationServer).DestroySnapshots(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Replication/DestroySnapshots",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReplicationServer).DestroySnapshots(ctx, req.(*DestroySnapshotsReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Replication_ReplicationCursor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReplicationCursorReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ReplicationServer).ReplicationCursor(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/Replication/ReplicationCursor",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ReplicationServer).ReplicationCursor(ctx, req.(*ReplicationCursorReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Replication_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "Replication",
+	HandlerType: (*ReplicationServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Ping",
+			Handler:    _Replication_Ping_Handler,
+		},
+		{
+			MethodName: "ListFilesystems",
+			Handler:    _Replication_ListFilesystems_Handler,
+		},
+		{
+			MethodName: "ListFilesystemVersions",
+			Handler:    _Replication_ListFilesystemVersions_Handler,
+		},
+		{
+			MethodName: "DestroySnapshots",
+			Handler:    _Replication_DestroySnapshots_Handler,
+		},
+		{
+			MethodName: "ReplicationCursor",
+			Handler:    _Replication_ReplicationCursor_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "pdu.proto",
+}
+
+func init() { proto.RegisterFile("pdu.proto", fileDescriptor_pdu_83b7e2a28d820622) }
+
+var fileDescriptor_pdu_83b7e2a28d820622 = []byte{
+	// 785 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xd1, 0x8e, 0xe3, 0x34,
+	0x14, 0x9d, 0xb4, 0x69, 0x9b, 0xde, 0x0e, 0xbb, 0x1d, 0x4f, 0x59, 0x85, 0x00, 0xab, 0xca, 0xcb,
+	0x43, 0x17, 0x89, 0x80, 0x0a, 0x2f, 0x08, 0x09, 0x89, 0x4e, 0x67, 0x67, 0x10, 0xb0, 0x54, 0x6e,
+	0x59, 0xad, 0xf6, 0x2d, 0x34, 0x57, 0x6d, 0x34, 0x6d, 0x9d, 0xb5, 0x13, 0xb4, 0xe5, 0x91, 0xbf,
+	0x9a, 0x7f, 0xe0, 0x91, 0x0f, 0x42, 0x76, 0xe3, 0x34, 0x6d, 0x52, 0xa9, 0x4f, 0xf1, 0x39, 0xf7,
+	0xda, 0x3e, 0xf7, 0xd8, 0xd7, 0x81, 0x76, 0x1c, 0xa6, 0x7e, 0x2c, 0x78, 0xc2, 0xe9, 0x35, 0x5c,
+	0xfd, 0x1a, 0xc9, 0xe4, 0x55, 0xb4, 0x42, 0xb9, 0x95, 0x09, 0xae, 0x19, 0xbe, 0xa7, 0xa3, 0x32,
+	0x29, 0xc9, 0x57, 0xd0, 0xd9, 0x13, 0xd2, 0xb5, 0xfa, 0xf5, 0x41, 0x67, 0xd8, 0xf1, 0x0b, 0x49,
+	0xc5, 0x38, 0x5d, 0x02, 0xec, 0x21, 0x21, 0x60, 0x4f, 0x82, 0x64, 0xe9, 0x5a, 0x7d, 0x6b, 0xd0,
+	0x66, 0x7a, 0x4c, 0xfa, 0xd0, 0x61, 0x28, 0xd3, 0x35, 0xce, 0xf8, 0x03, 0x6e, 0xdc, 0x9a, 0x0e,
+	0x15, 0x29, 0xf2, 0x05, 0x7c, 0xf4, 0xb3, 0x9c, 0xac, 0x82, 0x39, 0x2e, 0xf9, 0x2a, 0x44, 0xe1,
+	0xd6, 0xfb, 0xd6, 0xc0, 0x61, 0x87, 0x24, 0xfd, 0x01, 0x3e, 0x39, 0x54, 0xfb, 0x06, 0x85, 0x8c,
+	0xf8, 0x46, 0x32, 0x7c, 0x4f, 0x9e, 0x17, 0x65, 0x64, 0xdb, 0x17, 0x18, 0xfa, 0xcb, 0xe9, 0xc9,
+	0x92, 0xf8, 0xe0, 0x18, 0x98, 0xd5, 0x4b, 0xfc, 0x52, 0x26, 0xcb, 0x73, 0xe8, 0x7f, 0x16, 0x5c,
+	0x95, 0xe2, 0x64, 0x08, 0xf6, 0x6c, 0x1b, 0xa3, 0xde, 0xfc, 0xc9, 0xf0, 0x79, 0x79, 0x05, 0x3f,
+	0xfb, 0xaa, 0x2c, 0xa6, 0x73, 0x95, 0x5f, 0xaf, 0x83, 0x35, 0x66, 0xa6, 0xe8, 0xb1, 0xe2, 0xee,
+	0xd2, 0x28, 0xd4, 0x26, 0xd8, 0x4c, 0x8f, 0xc9, 0x67, 0xd0, 0xbe, 0x11, 0x18, 0x24, 0x38, 0x7b,
+	0x7b, 0xe7, 0xda, 0x3a, 0xb0, 0x27, 0x88, 0x07, 0x8e, 0x06, 0x11, 0xdf, 0xb8, 0x0d, 0xbd, 0x52,
+	0x8e, 0xe9, 0x4b, 0xe8, 0x14, 0xb6, 0x25, 0x97, 0xe0, 0x4c, 0x37, 0x41, 0x2c, 0x97, 0x3c, 0xe9,
+	0x5e, 0x28, 0x34, 0xe2, 0xfc, 0x61, 0x1d, 0x88, 0x87, 0xae, 0x45, 0x1f, 0x2d, 0x68, 0x4d, 0x71,
+	0x13, 0x9e, 0xe1, 0xa7, 0x12, 0xf9, 0x4a, 0xf0, 0xb5, 0x11, 0xae, 0xc6, 0xe4, 0x09, 0xd4, 0x66,
+	0x5c, 0xcb, 0x6e, 0xb3, 0xda, 0x8c, 0x1f, 0x1f, 0xbc, 0x5d, 0x3e, 0x78, 0x25, 0x9c, 0xaf, 0x63,
+	0x81, 0x52, 0x6a, 0xe1, 0x0e, 0xcb, 0x31, 0xe9, 0x41, 0x63, 0x8c, 0x61, 0x1a, 0xbb, 0x4d, 0x1d,
+	0xd8, 0x01, 0xf2, 0x0c, 0x9a, 0x63, 0xb1, 0x65, 0xe9, 0xc6, 0x6d, 0x69, 0x3a, 0x43, 0xf4, 0x3b,
+	0x70, 0x26, 0x82, 0xc7, 0x28, 0x92, 0x6d, 0x6e, 0xaa, 0x55, 0x30, 0xb5, 0x07, 0x8d, 0x37, 0xc1,
+	0x2a, 0x35, 0x4e, 0xef, 0x00, 0xfd, 0x27, 0xaf, 0x58, 0x92, 0x01, 0x3c, 0xfd, 0x43, 0x62, 0x78,
+	0x7c, 0x55, 0x1d, 0x76, 0x4c, 0x13, 0x0a, 0x97, 0xb7, 0x1f, 0x62, 0x9c, 0x27, 0x18, 0x4e, 0xa3,
+	0xbf, 0x51, 0x57, 0x5c, 0x67, 0x07, 0x1c, 0x79, 0x09, 0x90, 0xe9, 0x89, 0x50, 0xba, 0xb6, 0xbe,
+	0x54, 0x6d, 0xdf, 0x48, 0x64, 0x85, 0x20, 0x7d, 0x0b, 0xc0, 0x70, 0x8e, 0xd1, 0x5f, 0x78, 0x8e,
+	0xf1, 0x5f, 0x42, 0xf7, 0x66, 0x85, 0x81, 0x28, 0xeb, 0x2c, 0xf1, 0xf4, 0xb2, 0xb0, 0xb2, 0xa4,
+	0x0b, 0xb8, 0x1e, 0xa3, 0x4c, 0x04, 0xdf, 0x9a, 0x1b, 0x70, 0x4e, 0xe7, 0x90, 0x6f, 0xa0, 0x9d,
+	0xe7, 0xbb, 0xb5, 0x93, 0xdd, 0xb1, 0x4f, 0xa2, 0xef, 0x80, 0x1c, 0x6d, 0x94, 0x35, 0x99, 0x81,
+	0x7a, 0x97, 0x13, 0x4d, 0x66, 0x72, 0xd4, 0x89, 0xdd, 0x0a, 0xc1, 0x85, 0x39, 0x31, 0x0d, 0xe8,
+	0xb8, 0xaa, 0x08, 0xf5, 0x68, 0xb5, 0x54, 0xe1, 0xab, 0xc4, 0x34, 0xf0, 0xb5, 0x5f, 0x96, 0xc0,
+	0x4c, 0x0e, 0xfd, 0xd7, 0x82, 0x1e, 0xc3, 0x78, 0x15, 0xcd, 0x75, 0x93, 0xdc, 0xa4, 0x42, 0x72,
+	0x71, 0x8e, 0x19, 0x5f, 0x43, 0x7d, 0x81, 0x89, 0x96, 0xd4, 0x19, 0x7e, 0xea, 0x57, 0xad, 0xe1,
+	0xdf, 0x61, 0xf2, 0x7b, 0x7c, 0x7f, 0xc1, 0x54, 0xa6, 0x9a, 0x20, 0x31, 0xd1, 0x57, 0xe4, 0xe4,
+	0x84, 0xa9, 0x99, 0x20, 0x31, 0xf1, 0x5a, 0xd0, 0xd0, 0x0b, 0x78, 0x2f, 0xa0, 0xa1, 0x03, 0xaa,
+	0x49, 0x72, 0xe3, 0x76, 0x5e, 0xe4, 0x78, 0x64, 0x43, 0x8d, 0xc7, 0x74, 0x56, 0x59, 0x8d, 0x6a,
+	0xa1, 0xdd, 0x4b, 0xa2, 0xea, 0xb0, 0xef, 0x2f, 0xf2, 0xb7, 0xc4, 0x79, 0xcd, 0x13, 0xfc, 0x10,
+	0xc9, 0xdd, 0x7a, 0xce, 0xfd, 0x05, 0xcb, 0x99, 0x91, 0x03, 0xcd, 0x9d, 0x4b, 0xf4, 0x05, 0xb4,
+	0x26, 0xd1, 0x66, 0xa1, 0x6c, 0x71, 0xa1, 0xf5, 0x1b, 0x4a, 0x19, 0x2c, 0x4c, 0x53, 0x19, 0x48,
+	0x3f, 0x37, 0x49, 0x52, 0xb5, 0xdd, 0xed, 0x7c, 0xc9, 0x4d, 0xdb, 0xa9, 0xf1, 0xf0, 0xb1, 0xa6,
+	0xde, 0x80, 0x5c, 0x1a, 0xf1, 0xc0, 0x56, 0xe9, 0xc4, 0xf1, 0xb3, 0xa5, 0x3d, 0x33, 0x92, 0xe4,
+	0x7b, 0x78, 0x7a, 0xf8, 0x44, 0x4b, 0x42, 0xfc, 0xd2, 0x4f, 0xcb, 0x2b, 0x73, 0x92, 0x4c, 0xe0,
+	0x59, 0xf5, 0xeb, 0x4e, 0x3c, 0xff, 0xe4, 0x3f, 0xc3, 0x3b, 0x1d, 0x93, 0xe4, 0x47, 0xe8, 0x1e,
+	0xdf, 0x33, 0xd2, 0xf3, 0x2b, 0xfa, 0xc7, 0xab, 0x62, 0x25, 0xf9, 0x09, 0xae, 0x4a, 0x47, 0x42,
+	0x3e, 0xae, 0x3c, 0x7f, 0xaf, 0x92, 0x96, 0xa3, 0xc6, 0xbb, 0x7a, 0x1c, 0xa6, 0x7f, 0x36, 0xf5,
+	0x0f, 0xfc, 0xdb, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x37, 0x0e, 0xf2, 0xe4, 0xcd, 0x07, 0x00,
 	0x00,
 }

replication/logic/pdu/pdu.proto

@@ -1,6 +1,14 @@
 syntax = "proto3";
+option go_package = "pdu";
 
-package pdu;
+service Replication {
+    rpc Ping (PingReq) returns (PingRes);
+    rpc ListFilesystems (ListFilesystemReq) returns (ListFilesystemRes);
+    rpc ListFilesystemVersions (ListFilesystemVersionsReq) returns (ListFilesystemVersionsRes);
+    rpc DestroySnapshots (DestroySnapshotsReq) returns (DestroySnapshotsRes);
+    rpc ReplicationCursor (ReplicationCursorReq) returns (ReplicationCursorRes);
+    // for Send and Recv, see package rpc
+}
 
 message ListFilesystemReq {}
 
@@ -11,6 +19,7 @@ message ListFilesystemRes {
 message Filesystem {
     string Path = 1;
     string ResumeToken = 2;
+    bool IsPlaceholder = 3;
 }
 
 message ListFilesystemVersionsReq {
@@ -60,22 +69,18 @@ message Property {
 }
 
 message SendRes {
-    // The actual stream is in the stream part of the streamrpc response
-
     // Whether the resume token provided in the request has been used or not.
-    bool UsedResumeToken = 1;
+    bool UsedResumeToken = 2;
 
     // Expected stream size determined by dry run, not exact.
     // 0 indicates that for the given SendReq, no size estimate could be made.
-    int64 ExpectedSize = 2;
+    int64 ExpectedSize = 3;
 
-    repeated Property Properties = 3;
+    repeated Property Properties = 4;
 }
 
 message ReceiveReq {
-    // The stream part of the streamrpc request contains the zfs send stream
-
-    string Filesystem = 1;
+    string Filesystem = 1; // FIXME should be snapshot name, we can enforce that on recv
 
     // If true, the receiver should clear the resume token before perfoming the zfs recv of the stream in the request
     bool ClearResumeToken = 2;
@@ -113,6 +118,15 @@ message ReplicationCursorReq {
 message ReplicationCursorRes {
     oneof Result {
         uint64 Guid = 1;
-        string Error = 2;
+        bool Notexist = 2;
     }
 }
+
+message PingReq {
+    string Message = 1;
+}
+
+message PingRes {
+    // Echo must be PingReq.Message
+    string Echo = 1;
+}

replication/logic/replication_logic.go

@@ -0,0 +1,495 @@
+package logic
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/zrepl/zrepl/replication/driver"
+	. "github.com/zrepl/zrepl/replication/logic/diff"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
+	"github.com/zrepl/zrepl/replication/report"
+	"github.com/zrepl/zrepl/util/bytecounter"
+	"github.com/zrepl/zrepl/zfs"
+)
+
+// Endpoint represents one side of the replication.
+//
+// An endpoint is either in Sender or Receiver mode, represented by the correspondingly
+// named interfaces defined in this package.
+type Endpoint interface {
+	// Does not include placeholder filesystems
+	ListFilesystems(ctx context.Context, req *pdu.ListFilesystemReq) (*pdu.ListFilesystemRes, error)
+	ListFilesystemVersions(ctx context.Context, req *pdu.ListFilesystemVersionsReq) (*pdu.ListFilesystemVersionsRes, error)
+	DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error)
+	WaitForConnectivity(ctx context.Context) (error)
+}
+
+type Sender interface {
+	Endpoint
+	// If a non-nil io.ReadCloser is returned, it is guaranteed to be closed before
+	// any next call to the parent github.com/zrepl/zrepl/replication.Endpoint.
+	// If the send request is for dry run the io.ReadCloser will be nil
+	Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, zfs.StreamCopier, error)
+	ReplicationCursor(ctx context.Context, req *pdu.ReplicationCursorReq) (*pdu.ReplicationCursorRes, error)
+}
+
+type Receiver interface {
+	Endpoint
+	// Receive sends r and sendStream (the latter containing a ZFS send stream)
+	// to the parent github.com/zrepl/zrepl/replication.Endpoint.
+	Receive(ctx context.Context, req *pdu.ReceiveReq, receive zfs.StreamCopier) (*pdu.ReceiveRes, error)
+}
+
+type Planner struct {
+	sender   Sender
+	receiver Receiver
+
+	promSecsPerState    *prometheus.HistogramVec // labels: state
+	promBytesReplicated *prometheus.CounterVec   // labels: filesystem
+}
+
+func (p *Planner) Plan(ctx context.Context) ([]driver.FS, error) {
+	fss, err := p.doPlanning(ctx)
+	if err != nil {
+		return nil, err
+	}
+	dfss := make([]driver.FS, len(fss))
+	for i := range dfss {
+		dfss[i] = fss[i]
+	}
+	return dfss, nil
+}
+
+func (p *Planner) WaitForConnectivity(ctx context.Context) error {
+	var wg sync.WaitGroup
+	doPing := func(endpoint Endpoint, errOut *error) {
+		defer wg.Done()
+		err := endpoint.WaitForConnectivity(ctx)
+		if err != nil {
+			*errOut = err
+		} else {
+			*errOut = nil
+		}
+	}
+	wg.Add(2)
+	var senderErr, receiverErr error
+	go doPing(p.sender, &senderErr)
+	go doPing(p.receiver, &receiverErr)
+	wg.Wait()
+	if senderErr == nil && receiverErr == nil {
+		return nil
+	} else if senderErr != nil && receiverErr != nil {
+		if senderErr.Error() == receiverErr.Error() {
+			return fmt.Errorf("sender and receiver are not reachable: %s", senderErr.Error())
+		} else {
+			return fmt.Errorf("sender and receiver are not reachable:\n  sender: %s\n  receiver: %s", senderErr, receiverErr)
+		}
+	} else {
+		var side string
+		var err *error
+		if senderErr != nil {
+			side = "sender"
+			err = &senderErr
+		} else {
+			side = "receiver"
+			err = &receiverErr
+		}
+		return fmt.Errorf("%s is not reachable: %s", side, *err)
+	}
+}
+
+type Filesystem struct {
+	sender   Sender
+	receiver Receiver
+
+	Path                string             // compat
+	receiverFS          *pdu.Filesystem
+	promBytesReplicated prometheus.Counter // compat
+}
+
+func (f *Filesystem) EqualToPreviousAttempt(other driver.FS) bool {
+	g, ok := other.(*Filesystem)
+	if !ok {
+		return false
+	}
+	// TODO: use GUIDs (issued by zrepl, not those from ZFS)
+	return f.Path == g.Path
+}
+
+func (f *Filesystem) PlanFS(ctx context.Context) ([]driver.Step, error) {
+	steps, err := f.doPlanning(ctx)
+	if err != nil {
+		return nil, err
+	}
+	dsteps := make([]driver.Step, len(steps))
+	for i := range dsteps {
+		dsteps[i] = steps[i]
+	}
+	return dsteps, nil
+}
+func (f *Filesystem) ReportInfo() *report.FilesystemInfo {
+	return &report.FilesystemInfo{Name: f.Path} // FIXME compat name
+}
+
+type Step struct {
+	sender   Sender
+	receiver Receiver
+
+	parent   *Filesystem
+	from, to *pdu.FilesystemVersion // compat
+
+	byteCounter  bytecounter.StreamCopier
+	expectedSize int64 // 0 means no size estimate present / possible
+}
+
+func (s *Step) TargetEquals(other driver.Step) bool {
+	t, ok := other.(*Step)
+	if !ok {
+		return false
+	}
+	if !s.parent.EqualToPreviousAttempt(t.parent) {
+		panic("Step interface promise broken: parent filesystems must be same")
+	}
+	return s.from.GetGuid() == t.from.GetGuid() &&
+		s.to.GetGuid() == t.to.GetGuid()
+}
+
+func (s *Step) TargetDate() time.Time {
+	return s.to.SnapshotTime() // FIXME compat name
+}
+
+func (s *Step) Step(ctx context.Context) error {
+	return s.doReplication(ctx)
+}
+
+func (s *Step) ReportInfo() *report.StepInfo {
+	var byteCounter int64
+	if s.byteCounter != nil {
+		byteCounter = s.byteCounter.Count()
+	}
+	// FIXME stick to zfs convention of from and to
+	from := ""
+	if s.from != nil {
+		from = s.from.RelName()
+	}
+	return &report.StepInfo{
+		From:            from,
+		To:              s.to.RelName(),
+		BytesExpected:   s.expectedSize,
+		BytesReplicated: byteCounter,
+	}
+}
+
+func NewPlanner(secsPerState *prometheus.HistogramVec, bytesReplicated *prometheus.CounterVec, sender Sender, receiver Receiver) *Planner {
+	return &Planner{
+		sender:              sender,
+		receiver:            receiver,
+		promSecsPerState:    secsPerState,
+		promBytesReplicated: bytesReplicated,
+	}
+}
+func resolveConflict(conflict error) (path []*pdu.FilesystemVersion, msg string) {
+	if noCommonAncestor, ok := conflict.(*ConflictNoCommonAncestor); ok {
+		if len(noCommonAncestor.SortedReceiverVersions) == 0 {
+			// TODO this is hard-coded replication policy: most recent snapshot as source
+			var mostRecentSnap *pdu.FilesystemVersion
+			for n := len(noCommonAncestor.SortedSenderVersions) - 1; n >= 0; n-- {
+				if noCommonAncestor.SortedSenderVersions[n].Type == pdu.FilesystemVersion_Snapshot {
+					mostRecentSnap = noCommonAncestor.SortedSenderVersions[n]
+					break
+				}
+			}
+			if mostRecentSnap == nil {
+				return nil, "no snapshots available on sender side"
+			}
+			return []*pdu.FilesystemVersion{mostRecentSnap}, fmt.Sprintf("start replication at most recent snapshot %s", mostRecentSnap.RelName())
+		}
+	}
+	return nil, "no automated way to handle conflict type"
+}
+
+func (p *Planner) doPlanning(ctx context.Context) ([]*Filesystem, error) {
+
+	log := getLogger(ctx)
+
+	log.Info("start planning")
+
+	slfssres, err := p.sender.ListFilesystems(ctx, &pdu.ListFilesystemReq{})
+	if err != nil {
+		log.WithError(err).WithField("errType", fmt.Sprintf("%T", err)).Error("error listing sender filesystems")
+		return nil, err
+	}
+	sfss := slfssres.GetFilesystems()
+	// no progress here since we could run in a live-lock on connectivity issues
+
+	rlfssres, err := p.receiver.ListFilesystems(ctx, &pdu.ListFilesystemReq{})
+	if err != nil {
+		log.WithError(err).WithField("errType", fmt.Sprintf("%T", err)).Error("error listing receiver filesystems")
+		return nil, err
+	}
+	rfss := rlfssres.GetFilesystems()
+
+	q := make([]*Filesystem, 0, len(sfss))
+	for _, fs := range sfss {
+
+		var receiverFS *pdu.Filesystem
+		for _, rfs := range rfss {
+			if rfs.Path == fs.Path {
+				receiverFS = rfs
+			}
+		}
+
+		ctr := p.promBytesReplicated.WithLabelValues(fs.Path)
+
+		q = append(q, &Filesystem{
+			sender:              p.sender,
+			receiver:            p.receiver,
+			Path:                fs.Path,
+			receiverFS:          receiverFS,
+			promBytesReplicated: ctr,
+		})
+	}
+
+	return q, nil
+}
+
+func (fs *Filesystem) doPlanning(ctx context.Context) ([]*Step, error) {
+
+	log := getLogger(ctx).WithField("filesystem", fs.Path)
+
+	log.Debug("assessing filesystem")
+
+	sfsvsres, err := fs.sender.ListFilesystemVersions(ctx, &pdu.ListFilesystemVersionsReq{Filesystem: fs.Path})
+	if err != nil {
+		log.WithError(err).Error("cannot get remote filesystem versions")
+		return nil, err
+	}
+	sfsvs := sfsvsres.GetVersions()
+
+	if len(sfsvs) < 1 {
+		err := errors.New("sender does not have any versions")
+		log.Error(err.Error())
+		return nil, err
+	}
+
+	var rfsvs []*pdu.FilesystemVersion
+	if fs.receiverFS != nil && !fs.receiverFS.GetIsPlaceholder() {
+		rfsvsres, err := fs.receiver.ListFilesystemVersions(ctx, &pdu.ListFilesystemVersionsReq{Filesystem: fs.Path})
+		if err != nil {
+			log.WithError(err).Error("receiver error")
+			return nil, err
+		}
+		rfsvs = rfsvsres.GetVersions()
+	} else {
+		rfsvs = []*pdu.FilesystemVersion{}
+	}
+
+	path, conflict := IncrementalPath(rfsvs, sfsvs)
+	if conflict != nil {
+		var msg string
+		path, msg = resolveConflict(conflict) // no shadowing allowed!
+		if path != nil {
+			log.WithField("conflict", conflict).Info("conflict")
+			log.WithField("resolution", msg).Info("automatically resolved")
+		} else {
+			log.WithField("conflict", conflict).Error("conflict")
+			log.WithField("problem", msg).Error("cannot resolve conflict")
+		}
+	}
+	if len(path) == 0 {
+		return nil, conflict
+	}
+
+	steps := make([]*Step, 0, len(path))
+	// FIXME unify struct declarations => initializer?
+	if len(path) == 1 {
+		steps = append(steps, &Step{
+			parent:   fs,
+			sender:   fs.sender,
+			receiver: fs.receiver,
+			from:     nil,
+			to:       path[0],
+		})
+	} else {
+		for i := 0; i < len(path)-1; i++ {
+			steps = append(steps, &Step{
+				parent:   fs,
+				sender:   fs.sender,
+				receiver: fs.receiver,
+				from:     path[i],
+				to:       path[i+1],
+			})
+		}
+	}
+
+	log.Debug("compute send size estimate")
+	errs := make(chan error, len(steps))
+	var wg sync.WaitGroup
+	fanOutCtx, fanOutCancel := context.WithCancel(ctx)
+	defer fanOutCancel()
+	for _, step := range steps {
+		wg.Add(1)
+		go func(step *Step) {
+			defer wg.Done()
+			err := step.updateSizeEstimate(fanOutCtx)
+			if err != nil {
+				log.WithError(err).WithField("step", step).Error("error computing size estimate")
+				fanOutCancel()
+			}
+			errs <- err
+		}(step)
+	}
+	wg.Wait()
+	close(errs)
+	var significantErr error = nil
+	for err := range errs {
+		if err != nil {
+			if significantErr == nil || significantErr == context.Canceled {
+				significantErr = err
+			}
+		}
+	}
+	if significantErr != nil {
+		return nil, significantErr
+	}
+
+	log.Debug("filesystem planning finished")
+	return steps, nil
+}
+
+// type FilesystemsReplicationFailedError struct {
+// 	FilesystemsWithError []*fsrep.Replication
+// }
+
+// func (e FilesystemsReplicationFailedError) Error() string {
+// 	allSame := true
+// 	lastErr := e.FilesystemsWithError[0].Err().Error()
+// 	for _, fs := range e.FilesystemsWithError {
+// 		fsErr := fs.Err().Error()
+// 		allSame = allSame && lastErr == fsErr
+// 	}
+
+// 	fsstr := "multiple filesystems"
+// 	if len(e.FilesystemsWithError) == 1 {
+// 		fsstr = fmt.Sprintf("filesystem %s", e.FilesystemsWithError[0].FS())
+// 	}
+// 	errorStr := lastErr
+// 	if !allSame {
+// 		errorStr = "multiple different errors"
+// 	}
+// 	return fmt.Sprintf("%s could not be replicated: %s", fsstr, errorStr)
+// }
+
+func (s *Step) updateSizeEstimate(ctx context.Context) error {
+
+	log := getLogger(ctx)
+
+	sr := s.buildSendRequest(true)
+
+	log.Debug("initiate dry run send request")
+	sres, _, err := s.sender.Send(ctx, sr)
+	if err != nil {
+		log.WithError(err).Error("dry run send request failed")
+		return err
+	}
+	s.expectedSize = sres.ExpectedSize
+	return nil
+}
+
+func (s *Step) buildSendRequest(dryRun bool) (sr *pdu.SendReq) {
+	fs := s.parent.Path
+	if s.from == nil {
+		sr = &pdu.SendReq{
+			Filesystem: fs,
+			To:         s.to.RelName(),
+			DryRun:     dryRun,
+		}
+	} else {
+		sr = &pdu.SendReq{
+			Filesystem: fs,
+			From:       s.from.RelName(),
+			To:         s.to.RelName(),
+			DryRun:     dryRun,
+		}
+	}
+	return sr
+}
+
+func (s *Step) doReplication(ctx context.Context) error {
+
+	fs := s.parent.Path
+
+	log := getLogger(ctx)
+	sr := s.buildSendRequest(false)
+
+	log.Debug("initiate send request")
+	sres, sstreamCopier, err := s.sender.Send(ctx, sr)
+	if err != nil {
+		log.WithError(err).Error("send request failed")
+		return err
+	}
+	if sstreamCopier == nil {
+		err := errors.New("send request did not return a stream, broken endpoint implementation")
+		return err
+	}
+	defer sstreamCopier.Close()
+
+	// Install a byte counter to track progress + for status report
+	s.byteCounter = bytecounter.NewStreamCopier(sstreamCopier)
+	defer func() {
+		s.parent.promBytesReplicated.Add(float64(s.byteCounter.Count()))
+	}()
+
+	rr := &pdu.ReceiveReq{
+		Filesystem:       fs,
+		ClearResumeToken: !sres.UsedResumeToken,
+	}
+	log.Debug("initiate receive request")
+	_, err = s.receiver.Receive(ctx, rr, s.byteCounter)
+	if err != nil {
+		log.
+			WithError(err).
+			WithField("errType", fmt.Sprintf("%T", err)).
+			Error("receive request failed (might also be error on sender)")
+		// This failure could be due to
+		// 	- an unexpected exit of ZFS on the sending side
+		//  - an unexpected exit of ZFS on the receiving side
+		//  - a connectivity issue
+		return err
+	}
+	log.Debug("receive finished")
+
+	log.Debug("advance replication cursor")
+	req := &pdu.ReplicationCursorReq{
+		Filesystem: fs,
+		Op: &pdu.ReplicationCursorReq_Set{
+			Set: &pdu.ReplicationCursorReq_SetOp{
+				Snapshot: s.to.GetName(),
+			},
+		},
+	}
+	_, err = s.sender.ReplicationCursor(ctx, req)
+	if err != nil {
+		log.WithError(err).Error("error advancing replication cursor")
+		// If this fails and replication planning restarts, the diff algorithm will find
+		// that cursor out of place. This is not a problem because then, it would just use another FS
+		// However, we FIXME have no means to just update the cursor in a
+		// second replication attempt right after this one where we don't have new snaps yet
+		return err
+	}
+
+	return err
+}
+
+func (s *Step) String() string {
+	if s.from == nil { // FIXME: ZFS semantics are that to is nil on non-incremental send
+		return fmt.Sprintf("%s%s (full)", s.parent.Path, s.to.RelName())
+	} else {
+		return fmt.Sprintf("%s(%s => %s)", s.parent.Path, s.from.RelName(), s.to.RelName())
+	}
+}

replication/logic/replication_logic_context.go

@@ -1,9 +1,9 @@
-package replication
+package logic
 
 import (
 	"context"
+
 	"github.com/zrepl/zrepl/logger"
-	"github.com/zrepl/zrepl/replication/fsrep"
 )
 
 type contextKey int
@@ -16,7 +16,6 @@ type Logger = logger.Logger
 
 func WithLogger(ctx context.Context, l Logger) context.Context {
 	ctx = context.WithValue(ctx, contextKeyLog, l)
-	ctx = fsrep.WithLogger(ctx, l)
 	return ctx
 }
 

replication/mainfsm.go

@@ -1,427 +0,0 @@
-// Package replication implements replication of filesystems with existing
-// versions (snapshots) from a sender to a receiver.
-package replication
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/zrepl/zrepl/daemon/job/wakeup"
-	"math/bits"
-	"sync"
-	"time"
-
-	"github.com/zrepl/zrepl/replication/fsrep"
-	. "github.com/zrepl/zrepl/replication/internal/diff"
-	. "github.com/zrepl/zrepl/replication/internal/queue"
-	"github.com/zrepl/zrepl/replication/pdu"
-)
-
-//go:generate enumer -type=State
-type State uint
-
-const (
-	Planning State = 1 << iota
-	PlanningError
-	Working
-	WorkingWait
-	Completed
-	ContextDone
-)
-
-func (s State) rsf() state {
-	idx := bits.TrailingZeros(uint(s))
-	if idx == bits.UintSize {
-		panic(s) // invalid value
-	}
-	m := []state{
-		statePlanning,
-		statePlanningError,
-		stateWorking,
-		stateWorkingWait,
-		nil,
-		nil,
-	}
-	return m[idx]
-}
-
-// Replication implements the replication of multiple file systems from a Sender to a Receiver.
-//
-// It is a state machine that is driven by the Drive method
-// and provides asynchronous reporting via the Report method (i.e. from another goroutine).
-type Replication struct {
-	// not protected by lock
-	promSecsPerState *prometheus.HistogramVec // labels: state
-	promBytesReplicated *prometheus.CounterVec // labels: filesystem
-
-	// lock protects all fields of this struct (but not the fields behind pointers!)
-	lock sync.Mutex
-
-	state State
-
-	// Working, WorkingWait, Completed, ContextDone
-	queue     *ReplicationQueue
-	completed []*fsrep.Replication
-	active    *ReplicationQueueItemHandle
-
-	// PlanningError
-	planningError error
-
-	// ContextDone
-	contextError error
-
-	// PlanningError, WorkingWait
-	sleepUntil time.Time
-}
-
-type Report struct {
-	Status    string
-	Problem   string
-	SleepUntil time.Time
-	Completed []*fsrep.Report
-	Pending   []*fsrep.Report
-	Active    *fsrep.Report
-}
-
-func NewReplication(secsPerState *prometheus.HistogramVec, bytesReplicated *prometheus.CounterVec) *Replication {
-	r := Replication{
-		promSecsPerState: secsPerState,
-		promBytesReplicated: bytesReplicated,
-		state:            Planning,
-	}
-	return &r
-}
-
-// Endpoint represents one side of the replication.
-//
-// An endpoint is either in Sender or Receiver mode, represented by the correspondingly
-// named interfaces defined in this package.
-type Endpoint interface {
-	// Does not include placeholder filesystems
-	ListFilesystems(ctx context.Context) ([]*pdu.Filesystem, error)
-	// FIXME document FilteredError handling
-	ListFilesystemVersions(ctx context.Context, fs string) ([]*pdu.FilesystemVersion, error) // fix depS
-	DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error)
-}
-
-type Sender interface {
-	Endpoint
-	fsrep.Sender
-}
-
-type Receiver interface {
-	Endpoint
-	fsrep.Receiver
-}
-
-type FilteredError struct{ fs string }
-
-func NewFilteredError(fs string) *FilteredError {
-	return &FilteredError{fs}
-}
-
-func (f FilteredError) Error() string { return "endpoint does not allow access to filesystem " + f.fs }
-
-type updater func(func(*Replication)) (newState State)
-type state func(ctx context.Context, sender Sender, receiver Receiver, u updater) state
-
-// Drive starts the state machine and returns only after replication has finished (with or without errors).
-// The Logger in ctx is used for both debug and error logging, but is not guaranteed to be stable
-// or end-user friendly.
-// User-facing replication progress reports and can be obtained using the Report method,
-// whose output will not change after Drive returns.
-//
-// FIXME: Drive may be only called once per instance of Replication
-func (r *Replication) Drive(ctx context.Context, sender Sender, receiver Receiver) {
-
-	var u updater = func(f func(*Replication)) State {
-		r.lock.Lock()
-		defer r.lock.Unlock()
-		if f != nil {
-			f(r)
-		}
-		return r.state
-	}
-
-	var s state = statePlanning
-	var pre, post State
-	for s != nil {
-		preTime := time.Now()
-		pre = u(nil)
-		s = s(ctx, sender, receiver, u)
-		delta := time.Now().Sub(preTime)
-		r.promSecsPerState.WithLabelValues(pre.String()).Observe(delta.Seconds())
-		post = u(nil)
-		getLogger(ctx).
-			WithField("transition", fmt.Sprintf("%s => %s", pre, post)).
-			WithField("duration", delta).
-			Debug("main state transition")
-		if post == Working && pre != post {
-			getLogger(ctx).Info("start working")
-		}
-	}
-
-	getLogger(ctx).
-		WithField("final_state", post).
-		Debug("main final state")
-}
-
-func resolveConflict(conflict error) (path []*pdu.FilesystemVersion, msg string) {
-	if noCommonAncestor, ok := conflict.(*ConflictNoCommonAncestor); ok {
-		if len(noCommonAncestor.SortedReceiverVersions) == 0 {
-			// TODO this is hard-coded replication policy: most recent snapshot as source
-			var mostRecentSnap *pdu.FilesystemVersion
-			for n := len(noCommonAncestor.SortedSenderVersions) - 1; n >= 0; n-- {
-				if noCommonAncestor.SortedSenderVersions[n].Type == pdu.FilesystemVersion_Snapshot {
-					mostRecentSnap = noCommonAncestor.SortedSenderVersions[n]
-					break
-				}
-			}
-			if mostRecentSnap == nil {
-				return nil, "no snapshots available on sender side"
-			}
-			return []*pdu.FilesystemVersion{mostRecentSnap}, fmt.Sprintf("start replication at most recent snapshot %s", mostRecentSnap.RelName())
-		}
-	}
-	return nil, "no automated way to handle conflict type"
-}
-
-var PlanningRetryInterval = 10 * time.Second // FIXME make constant onfigurable
-
-func statePlanning(ctx context.Context, sender Sender, receiver Receiver, u updater) state {
-
-	log := getLogger(ctx)
-
-	log.Info("start planning")
-
-	handlePlanningError := func(err error) state {
-		// FIXME classify error as temporary or permanent / max retry counter
-		return u(func(r *Replication) {
-			r.sleepUntil = time.Now().Add(PlanningRetryInterval)
-			r.planningError = err
-			r.state = PlanningError
-		}).rsf()
-	}
-
-	sfss, err := sender.ListFilesystems(ctx)
-	if err != nil {
-		log.WithError(err).Error("error listing sender filesystems")
-		return handlePlanningError(err)
-	}
-
-	rfss, err := receiver.ListFilesystems(ctx)
-	if err != nil {
-		log.WithError(err).Error("error listing receiver filesystems")
-		return handlePlanningError(err)
-	}
-
-	q := NewReplicationQueue()
-	mainlog := log
-	for _, fs := range sfss {
-
-		log := mainlog.WithField("filesystem", fs.Path)
-
-		log.Debug("assessing filesystem")
-
-		sfsvs, err := sender.ListFilesystemVersions(ctx, fs.Path)
-		if err != nil {
-			log.WithError(err).Error("cannot get remote filesystem versions")
-			return handlePlanningError(err)
-		}
-
-		if len(sfsvs) < 1 {
-			err := errors.New("sender does not have any versions")
-			log.Error(err.Error())
-			q.Add(fsrep.NewReplicationWithPermanentError(fs.Path, err))
-			continue
-		}
-
-		receiverFSExists := false
-		for _, rfs := range rfss {
-			if rfs.Path == fs.Path {
-				receiverFSExists = true
-			}
-		}
-
-		var rfsvs []*pdu.FilesystemVersion
-		if receiverFSExists {
-			rfsvs, err = receiver.ListFilesystemVersions(ctx, fs.Path)
-			if err != nil {
-				if _, ok := err.(*FilteredError); ok {
-					log.Info("receiver ignores filesystem")
-					continue
-				}
-				log.WithError(err).Error("receiver error")
-				return handlePlanningError(err)
-			}
-		} else {
-			rfsvs = []*pdu.FilesystemVersion{}
-		}
-
-		path, conflict := IncrementalPath(rfsvs, sfsvs)
-		if conflict != nil {
-			var msg string
-			path, msg = resolveConflict(conflict) // no shadowing allowed!
-			if path != nil {
-				log.WithField("conflict", conflict).Info("conflict")
-				log.WithField("resolution", msg).Info("automatically resolved")
-			} else {
-				log.WithField("conflict", conflict).Error("conflict")
-				log.WithField("problem", msg).Error("cannot resolve conflict")
-			}
-		}
-		if path == nil {
-			q.Add(fsrep.NewReplicationWithPermanentError(fs.Path, conflict))
-			continue
-		}
-
-		var promBytesReplicated *prometheus.CounterVec
-		u(func(replication *Replication) { // FIXME args struct like in pruner (also use for sender and receiver)
-			promBytesReplicated = replication.promBytesReplicated
-		})
-		fsrfsm := fsrep.BuildReplication(fs.Path, promBytesReplicated.WithLabelValues(fs.Path))
-		if len(path) == 1 {
-			fsrfsm.AddStep(nil, path[0])
-		} else {
-			for i := 0; i < len(path)-1; i++ {
-				fsrfsm.AddStep(path[i], path[i+1])
-			}
-		}
-		qitem := fsrfsm.Done()
-
-		log.Debug("compute send size estimate")
-		if err = qitem.UpdateSizeEsitmate(ctx, sender); err != nil {
-			log.WithError(err).Error("error computing size estimate")
-			return handlePlanningError(err)
-		}
-		q.Add(qitem)
-	}
-
-	return u(func(r *Replication) {
-		r.completed = nil
-		r.queue = q
-		r.planningError = nil
-		r.state = Working
-	}).rsf()
-}
-
-func statePlanningError(ctx context.Context, sender Sender, receiver Receiver, u updater) state {
-	var sleepUntil time.Time
-	u(func(r *Replication) {
-		sleepUntil = r.sleepUntil
-	})
-	t := time.NewTimer(sleepUntil.Sub(time.Now()))
-	getLogger(ctx).WithField("until", sleepUntil).Info("retry wait after planning error")
-	defer t.Stop()
-	select {
-	case <-ctx.Done():
-		return u(func(r *Replication) {
-			r.state = ContextDone
-			r.contextError = ctx.Err()
-		}).rsf()
-	case <-t.C:
-	case <-wakeup.Wait(ctx):
-	}
-	return u(func(r *Replication) {
-		r.state = Planning
-	}).rsf()
-}
-
-func stateWorking(ctx context.Context, sender Sender, receiver Receiver, u updater) state {
-
-	var active *ReplicationQueueItemHandle
-	rsfNext := u(func(r *Replication) {
-		done, next := r.queue.GetNext()
-		r.completed = append(r.completed, done...)
-		if next == nil {
-			r.state = Completed
-		}
-		r.active = next
-		active = next
-	}).rsf()
-
-	if active == nil {
-		return rsfNext
-	}
-
-	retryWaitUntil := active.GetFSReplication().RetryWaitUntil()
-	if retryWaitUntil.After(time.Now()) {
-		return u(func(r *Replication) {
-			r.sleepUntil = retryWaitUntil
-			r.state = WorkingWait
-		}).rsf()
-	}
-
-	state, nextStepDate, retryWaitUntil := active.GetFSReplication().TakeStep(ctx, sender, receiver)
-	return u(func(r *Replication) {
-		active.Update(state, nextStepDate, retryWaitUntil)
-		r.active = nil
-	}).rsf()
-}
-
-func stateWorkingWait(ctx context.Context, sender Sender, receiver Receiver, u updater) state {
-	var sleepUntil time.Time
-	u(func(r *Replication) {
-		sleepUntil = r.sleepUntil
-	})
-	t := time.NewTimer(PlanningRetryInterval)
-	getLogger(ctx).WithField("until", sleepUntil).Info("retry wait because no filesystems are ready")
-	defer t.Stop()
-	select {
-	case <-ctx.Done():
-		return u(func(r *Replication) {
-			r.state = ContextDone
-			r.contextError = ctx.Err()
-		}).rsf()
-
-	case <-t.C:
-	case <-wakeup.Wait(ctx):
-	}
-	return u(func(r *Replication) {
-		r.state = Working
-	}).rsf()
-}
-
-// Report provides a summary of the progress of the Replication,
-// i.e., a condensed dump of the internal state machine.
-// Report is safe to be called asynchronously while Drive is running.
-func (r *Replication) Report() *Report {
-	r.lock.Lock()
-	defer r.lock.Unlock()
-
-	rep := Report{
-		Status: r.state.String(),
-		SleepUntil: r.sleepUntil,
-	}
-
-	if r.state&(Planning|PlanningError|ContextDone) != 0 {
-		switch r.state {
-		case PlanningError:
-			rep.Problem = r.planningError.Error()
-		case ContextDone:
-			rep.Problem = r.contextError.Error()
-		}
-		return &rep
-	}
-
-	rep.Pending = make([]*fsrep.Report, 0, r.queue.Len())
-	rep.Completed = make([]*fsrep.Report, 0, len(r.completed)) // room for active (potentially)
-
-	var active *fsrep.Replication
-	if r.active != nil {
-		active = r.active.GetFSReplication()
-		rep.Active = active.Report()
-	}
-	r.queue.Foreach(func(h *ReplicationQueueItemHandle) {
-		fsr := h.GetFSReplication()
-		if active != fsr {
-			rep.Pending = append(rep.Pending, fsr.Report())
-		}
-	})
-	for _, fsr := range r.completed {
-		rep.Completed = append(rep.Completed, fsr.Report())
-	}
-
-	return &rep
-}

replication/replication.go

@@ -0,0 +1,13 @@
+// Package replication implements replication of filesystems with existing
+// versions (snapshots) from a sender to a receiver.
+package replication
+
+import (
+	"context"
+
+	"github.com/zrepl/zrepl/replication/driver"
+)
+
+func Do(ctx context.Context, planner driver.Planner) (driver.ReportFunc, driver.WaitFunc) {
+	return driver.Do(ctx, planner)
+}

replication/report/replication_report.go

@@ -0,0 +1,152 @@
+package report
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type Report struct {
+	StartAt, FinishAt                      time.Time
+	WaitReconnectSince, WaitReconnectUntil time.Time
+	WaitReconnectError                     *TimedError
+	Attempts                               []*AttemptReport
+}
+
+var _, _ = json.Marshal(&Report{})
+
+type TimedError struct {
+	Err  string
+	Time time.Time
+}
+
+func NewTimedError(err string, t time.Time) *TimedError {
+	if err == "" {
+		panic("error must be empty")
+	}
+	if t.IsZero() {
+		panic("t must be non-zero")
+	}
+	return &TimedError{err, t}
+}
+
+func (s *TimedError) Error() string {
+	return s.Err
+}
+
+var _, _ = json.Marshal(&TimedError{})
+
+type AttemptReport struct {
+	State             AttemptState
+	StartAt, FinishAt time.Time
+	PlanError         *TimedError
+	Filesystems       []*FilesystemReport
+}
+
+type AttemptState string
+
+const (
+	AttemptPlanning      AttemptState = "planning"
+	AttemptPlanningError AttemptState = "planning-error"
+	AttemptFanOutFSs     AttemptState = "fan-out-filesystems"
+	AttemptFanOutError   AttemptState = "filesystem-error"
+	AttemptDone          AttemptState = "done"
+)
+
+type FilesystemState string
+
+const (
+	FilesystemPlanning        FilesystemState = "planning"
+	FilesystemPlanningErrored FilesystemState = "planning-error"
+	FilesystemStepping        FilesystemState = "stepping"
+	FilesystemSteppingErrored FilesystemState = "step-error"
+	FilesystemDone            FilesystemState = "done"
+)
+
+type FilesystemReport struct {
+	Info *FilesystemInfo
+
+	State FilesystemState
+
+	// Valid in State = FilesystemPlanningErrored
+	PlanError *TimedError
+	// Valid in State = FilesystemSteppingErrored
+	StepError *TimedError
+
+	// Valid in State = FilesystemStepping
+	CurrentStep int
+	Steps       []*StepReport
+}
+
+type FilesystemInfo struct {
+	Name string
+}
+
+type StepReport struct {
+	Info *StepInfo
+}
+
+type StepInfo struct {
+	From, To        string
+	BytesExpected   int64
+	BytesReplicated int64
+}
+
+func (a *AttemptReport) BytesSum() (expected, replicated int64) {
+	for _, fs := range a.Filesystems {
+		e, r := fs.BytesSum()
+		expected += e
+		replicated += r
+	}
+	return expected, replicated
+}
+
+func (f *FilesystemReport) BytesSum() (expected, replicated int64) {
+	for _, step := range f.Steps {
+		expected += step.Info.BytesExpected
+		replicated += step.Info.BytesReplicated
+	}
+	return
+}
+
+func (f *AttemptReport) FilesystemsByState() map[FilesystemState][]*FilesystemReport {
+	r := make(map[FilesystemState][]*FilesystemReport, 4)
+	for _, fs := range f.Filesystems {
+		l := r[fs.State]
+		l = append(l, fs)
+		r[fs.State] = l
+	}
+	return r
+}
+
+func (f *FilesystemReport) Error() *TimedError {
+	switch f.State {
+	case FilesystemPlanningErrored:
+		return f.PlanError
+	case FilesystemSteppingErrored:
+		return f.StepError
+	}
+	return nil
+}
+
+// may return nil
+func (f *FilesystemReport) NextStep() *StepReport {
+	switch f.State {
+	case FilesystemDone:
+		return nil
+	case FilesystemPlanningErrored:
+		return nil
+	case FilesystemSteppingErrored:
+		return nil
+	case FilesystemPlanning:
+		return nil
+	case FilesystemStepping:
+		// invariant is that this is always correct
+		// TODO what about 0-length Steps but short intermediary state?
+		return f.Steps[f.CurrentStep]
+	}
+	panic("unreachable")
+}
+
+func (f *StepReport) IsIncremental() bool {
+	return f.Info.From != "" // FIXME change to ZFS semantics (To != "")
+}

replication/state_enumer.go

@@ -1,76 +0,0 @@
-// Code generated by "enumer -type=State"; DO NOT EDIT.
-
-package replication
-
-import (
-	"fmt"
-)
-
-const (
-	_StateName_0 = "PlanningPlanningError"
-	_StateName_1 = "Working"
-	_StateName_2 = "WorkingWait"
-	_StateName_3 = "Completed"
-	_StateName_4 = "ContextDone"
-)
-
-var (
-	_StateIndex_0 = [...]uint8{0, 8, 21}
-	_StateIndex_1 = [...]uint8{0, 7}
-	_StateIndex_2 = [...]uint8{0, 11}
-	_StateIndex_3 = [...]uint8{0, 9}
-	_StateIndex_4 = [...]uint8{0, 11}
-)
-
-func (i State) String() string {
-	switch {
-	case 1 <= i && i <= 2:
-		i -= 1
-		return _StateName_0[_StateIndex_0[i]:_StateIndex_0[i+1]]
-	case i == 4:
-		return _StateName_1
-	case i == 8:
-		return _StateName_2
-	case i == 16:
-		return _StateName_3
-	case i == 32:
-		return _StateName_4
-	default:
-		return fmt.Sprintf("State(%d)", i)
-	}
-}
-
-var _StateValues = []State{1, 2, 4, 8, 16, 32}
-
-var _StateNameToValueMap = map[string]State{
-	_StateName_0[0:8]:  1,
-	_StateName_0[8:21]: 2,
-	_StateName_1[0:7]:  4,
-	_StateName_2[0:11]: 8,
-	_StateName_3[0:9]:  16,
-	_StateName_4[0:11]: 32,
-}
-
-// StateString retrieves an enum value from the enum constants string name.
-// Throws an error if the param is not part of the enum.
-func StateString(s string) (State, error) {
-	if val, ok := _StateNameToValueMap[s]; ok {
-		return val, nil
-	}
-	return 0, fmt.Errorf("%s does not belong to State values", s)
-}
-
-// StateValues returns all values of the enum
-func StateValues() []State {
-	return _StateValues
-}
-
-// IsAState returns "true" if the value is listed in the enum definition. "false" otherwise
-func (i State) IsAState() bool {
-	for _, v := range _StateValues {
-		if i == v {
-			return true
-		}
-	}
-	return false
-}

rpc/dataconn/base2bufpool/base2bufpool.go

@@ -0,0 +1,169 @@
+package base2bufpool
+
+import (
+	"fmt"
+	"math/bits"
+	"sync"
+)
+
+type pool struct {
+	mtx   sync.Mutex
+	bufs  [][]byte
+	shift uint
+}
+
+func (p *pool) Put(buf []byte) {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	if len(buf) != 1<<p.shift {
+		panic(fmt.Sprintf("implementation error: %v %v", len(buf), 1<<p.shift))
+	}
+	if len(p.bufs) > 10 { // FIXME constant
+		return
+	}
+	p.bufs = append(p.bufs, buf)
+}
+
+func (p *pool) Get() []byte {
+	p.mtx.Lock()
+	defer p.mtx.Unlock()
+	if len(p.bufs) > 0 {
+		ret := p.bufs[len(p.bufs)-1]
+		p.bufs = p.bufs[0 : len(p.bufs)-1]
+		return ret
+	}
+	return make([]byte, 1<<p.shift)
+}
+
+type Pool struct {
+	minShift uint
+	maxShift uint
+	pools    []pool
+	onNoFit  NoFitBehavior
+}
+
+type Buffer struct {
+	// always power of 2, from Pool.pools
+	shiftBuf []byte
+	// presentedLen
+	payloadLen uint
+	// backref too pool for Free
+	pool *Pool
+}
+
+func (b Buffer) Bytes() []byte {
+	return b.shiftBuf[0:b.payloadLen]
+}
+
+func (b *Buffer) Shrink(newPayloadLen uint) {
+	if newPayloadLen > b.payloadLen {
+		panic(fmt.Sprintf("shrink is actually an expand, invalid: %v %v", newPayloadLen, b.payloadLen))
+	}
+	b.payloadLen = newPayloadLen
+}
+
+func (b Buffer) Free() {
+	if b.pool != nil {
+		b.pool.put(b)
+	}
+}
+
+//go:generate enumer -type NoFitBehavior
+type NoFitBehavior uint
+
+const (
+	AllocateSmaller NoFitBehavior = 1 << iota
+	AllocateLarger
+
+	Allocate NoFitBehavior = AllocateSmaller | AllocateLarger
+	Panic    NoFitBehavior = 0
+)
+
+func New(minShift, maxShift uint, noFitBehavior NoFitBehavior) *Pool {
+	if minShift > 63 || maxShift > 63 {
+		panic(fmt.Sprintf("{min|max}Shift are the _exponent_, got minShift=%v maxShift=%v and limit of 63, which amounts to %v bits", minShift, maxShift, uint64(1)<<63))
+	}
+	pools := make([]pool, maxShift-minShift+1)
+	for i := uint(0); i < uint(len(pools)); i++ {
+		i := i // the closure below must copy i
+		pools[i] = pool{
+			shift: minShift + i,
+			bufs:  make([][]byte, 0, 10),
+		}
+	}
+	return &Pool{
+		minShift: minShift,
+		maxShift: maxShift,
+		pools:    pools,
+		onNoFit:  noFitBehavior,
+	}
+}
+
+func fittingShift(x uint) uint {
+	if x == 0 {
+		return 0
+	}
+	blen := uint(bits.Len(x))
+	if 1<<(blen-1) == x {
+		return blen - 1
+	}
+	return blen
+}
+
+func (p *Pool) handlePotentialNoFit(reqShift uint) (buf Buffer, didHandle bool) {
+	if reqShift == 0 {
+		if p.onNoFit&AllocateSmaller != 0 {
+			return Buffer{[]byte{}, 0, nil}, true
+		} else {
+			goto doPanic
+		}
+	}
+	if reqShift < p.minShift {
+		if p.onNoFit&AllocateSmaller != 0 {
+			goto alloc
+		} else {
+			goto doPanic
+		}
+	}
+	if reqShift > p.maxShift {
+		if p.onNoFit&AllocateLarger != 0 {
+			goto alloc
+		} else {
+			goto doPanic
+		}
+	}
+	return Buffer{}, false
+alloc:
+	return Buffer{make([]byte, 1<<reqShift), 1 << reqShift, nil}, true
+doPanic:
+	panic(fmt.Sprintf("base2bufpool: configured to panic on shift=%v (minShift=%v maxShift=%v)", reqShift, p.minShift, p.maxShift))
+}
+
+func (p *Pool) Get(minSize uint) Buffer {
+	shift := fittingShift(minSize)
+	buf, didHandle := p.handlePotentialNoFit(shift)
+	if didHandle {
+		buf.Shrink(minSize)
+		return buf
+	}
+	idx := int64(shift) - int64(p.minShift)
+	return Buffer{p.pools[idx].Get(), minSize, p}
+}
+
+func (p *Pool) put(buffer Buffer) {
+	if buffer.pool != p {
+		panic("putting buffer to pool where it didn't originate from")
+	}
+	buf := buffer.shiftBuf
+	if bits.OnesCount(uint(len(buf))) > 1 {
+		panic(fmt.Sprintf("putting buffer that is not power of two len: %v", len(buf)))
+	}
+	if len(buf) == 0 {
+		return
+	}
+	shift := fittingShift(uint(len(buf)))
+	if shift < p.minShift || shift > p.maxShift {
+		return // drop it
+	}
+	p.pools[shift-p.minShift].Put(buf)
+}

rpc/dataconn/base2bufpool/base2bufpool_test.go

@@ -0,0 +1,98 @@
+package base2bufpool
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPoolAllocBehavior(t *testing.T) {
+
+	type testcase struct {
+		poolMinShift, poolMaxShift uint
+		behavior                   NoFitBehavior
+		get                        uint
+		expShiftBufLen             int64 // -1 if panic expected
+	}
+
+	tcs := []testcase{
+		{
+			15, 20, Allocate,
+			1 << 14, 1 << 14,
+		},
+		{
+			15, 20, Allocate,
+			1 << 22, 1 << 22,
+		},
+		{
+			15, 20, Panic,
+			1 << 16, 1 << 16,
+		},
+		{
+			15, 20, Panic,
+			1 << 14, -1,
+		},
+		{
+			15, 20, Panic,
+			1 << 22, -1,
+		},
+		{
+			15, 20, Panic,
+			(1 << 15) + 23, 1 << 16,
+		},
+		{
+			15, 20, Panic,
+			0, -1, // yep, 0 always works, even
+		},
+		{
+			15, 20, Allocate,
+			0, 0,
+		},
+		{
+			15, 20, AllocateSmaller,
+			1 << 14, 1 << 14,
+		},
+		{
+			15, 20, AllocateSmaller,
+			1 << 22, -1,
+		},
+	}
+
+	for i := range tcs {
+		tc := tcs[i]
+		t.Run(fmt.Sprintf("[%d,%d] behav=%s Get(%d) exp=%d", tc.poolMinShift, tc.poolMaxShift, tc.behavior, tc.get, tc.expShiftBufLen), func(t *testing.T) {
+			pool := New(tc.poolMinShift, tc.poolMaxShift, tc.behavior)
+			if tc.expShiftBufLen == -1 {
+				assert.Panics(t, func() {
+					pool.Get(tc.get)
+				})
+				return
+			}
+			buf := pool.Get(tc.get)
+			assert.True(t, uint(len(buf.Bytes())) == tc.get)
+			assert.True(t, int64(len(buf.shiftBuf)) == tc.expShiftBufLen)
+		})
+	}
+}
+
+func TestFittingShift(t *testing.T) {
+	assert.Equal(t, uint(16), fittingShift(1+1<<15))
+	assert.Equal(t, uint(15), fittingShift(1<<15))
+}
+
+func TestFreeFromPoolRangeDoesNotPanic(t *testing.T) {
+	pool := New(15, 20, Allocate)
+	buf := pool.Get(1 << 16)
+	assert.NotPanics(t, func() {
+		buf.Free()
+	})
+}
+
+func TestFreeFromOutOfPoolRangeDoesNotPanic(t *testing.T) {
+	pool := New(15, 20, Allocate)
+	buf := pool.Get(1 << 23)
+	assert.NotPanics(t, func() {
+		buf.Free()
+	})
+}

rpc/dataconn/base2bufpool/nofitbehavior_enumer.go

@@ -0,0 +1,51 @@
+// Code generated by "enumer -type NoFitBehavior"; DO NOT EDIT.
+
+package base2bufpool
+
+import (
+	"fmt"
+)
+
+const _NoFitBehaviorName = "PanicAllocateSmallerAllocateLargerAllocate"
+
+var _NoFitBehaviorIndex = [...]uint8{0, 5, 20, 34, 42}
+
+func (i NoFitBehavior) String() string {
+	if i >= NoFitBehavior(len(_NoFitBehaviorIndex)-1) {
+		return fmt.Sprintf("NoFitBehavior(%d)", i)
+	}
+	return _NoFitBehaviorName[_NoFitBehaviorIndex[i]:_NoFitBehaviorIndex[i+1]]
+}
+
+var _NoFitBehaviorValues = []NoFitBehavior{0, 1, 2, 3}
+
+var _NoFitBehaviorNameToValueMap = map[string]NoFitBehavior{
+	_NoFitBehaviorName[0:5]:   0,
+	_NoFitBehaviorName[5:20]:  1,
+	_NoFitBehaviorName[20:34]: 2,
+	_NoFitBehaviorName[34:42]: 3,
+}
+
+// NoFitBehaviorString retrieves an enum value from the enum constants string name.
+// Throws an error if the param is not part of the enum.
+func NoFitBehaviorString(s string) (NoFitBehavior, error) {
+	if val, ok := _NoFitBehaviorNameToValueMap[s]; ok {
+		return val, nil
+	}
+	return 0, fmt.Errorf("%s does not belong to NoFitBehavior values", s)
+}
+
+// NoFitBehaviorValues returns all values of the enum
+func NoFitBehaviorValues() []NoFitBehavior {
+	return _NoFitBehaviorValues
+}
+
+// IsANoFitBehavior returns "true" if the value is listed in the enum definition. "false" otherwise
+func (i NoFitBehavior) IsANoFitBehavior() bool {
+	for _, v := range _NoFitBehaviorValues {
+		if i == v {
+			return true
+		}
+	}
+	return false
+}

rpc/dataconn/dataconn_client.go

@@ -0,0 +1,235 @@
+package dataconn
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
+	"github.com/zrepl/zrepl/rpc/dataconn/stream"
+	"github.com/zrepl/zrepl/transport"
+	"github.com/zrepl/zrepl/zfs"
+)
+
+type Client struct {
+	log Logger
+	cn  transport.Connecter
+}
+
+func NewClient(connecter transport.Connecter, log Logger) *Client {
+	return &Client{
+		log: log,
+		cn:  connecter,
+	}
+}
+
+func (c *Client) send(ctx context.Context, conn *stream.Conn, endpoint string, req proto.Message, streamCopier zfs.StreamCopier) error {
+
+	var buf bytes.Buffer
+	_, memErr := buf.WriteString(endpoint)
+	if memErr != nil {
+		panic(memErr)
+	}
+	if err := conn.WriteStreamedMessage(ctx, &buf, ReqHeader); err != nil {
+		return err
+	}
+
+	protobufBytes, err := proto.Marshal(req)
+	if err != nil {
+		return err
+	}
+	protobuf := bytes.NewBuffer(protobufBytes)
+	if err := conn.WriteStreamedMessage(ctx, protobuf, ReqStructured); err != nil {
+		return err
+	}
+
+	if streamCopier != nil {
+		return conn.SendStream(ctx, streamCopier, ZFSStream)
+	} else {
+		return nil
+	}
+}
+
+type RemoteHandlerError struct {
+	msg string
+}
+
+func (e *RemoteHandlerError) Error() string {
+	return fmt.Sprintf("server error: %s", e.msg)
+}
+
+type ProtocolError struct {
+	cause error
+}
+
+func (e *ProtocolError) Error() string {
+	return fmt.Sprintf("protocol error: %s", e)
+}
+
+func (c *Client) recv(ctx context.Context, conn *stream.Conn, res proto.Message) error {
+
+	headerBuf, err := conn.ReadStreamedMessage(ctx, ResponseHeaderMaxSize, ResHeader)
+	if err != nil {
+		return err
+	}
+	header := string(headerBuf)
+	if strings.HasPrefix(header, responseHeaderHandlerErrorPrefix) {
+		// FIXME distinguishable error type
+		return &RemoteHandlerError{strings.TrimPrefix(header, responseHeaderHandlerErrorPrefix)}
+	}
+	if !strings.HasPrefix(header, responseHeaderHandlerOk) {
+		return &ProtocolError{fmt.Errorf("invalid header: %q", header)}
+	}
+
+	protobuf, err := conn.ReadStreamedMessage(ctx, ResponseStructuredMaxSize, ResStructured)
+	if err != nil {
+		return err
+	}
+	if err := proto.Unmarshal(protobuf, res); err != nil {
+		return &ProtocolError{fmt.Errorf("cannot unmarshal structured part of response: %s", err)}
+	}
+	return nil
+}
+
+func (c *Client) getWire(ctx context.Context) (*stream.Conn, error) {
+	nc, err := c.cn.Connect(ctx)
+	if err != nil {
+		return nil, err
+	}
+	conn := stream.Wrap(nc, HeartbeatInterval, HeartbeatPeerTimeout)
+	return conn, nil
+}
+
+func (c *Client) putWire(conn *stream.Conn) {
+	if err := conn.Close(); err != nil {
+		c.log.WithError(err).Error("error closing connection")
+	}
+}
+
+func (c *Client) ReqSend(ctx context.Context, req *pdu.SendReq) (*pdu.SendRes, zfs.StreamCopier, error) {
+	conn, err := c.getWire(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	putWireOnReturn := true
+	defer func() {
+		if putWireOnReturn {
+			c.putWire(conn)
+		}
+	}()
+
+	if err := c.send(ctx, conn, EndpointSend, req, nil); err != nil {
+		return nil, nil, err
+	}
+
+	var res pdu.SendRes
+	if err := c.recv(ctx, conn, &res); err != nil {
+		return nil, nil, err
+	}
+
+	var copier zfs.StreamCopier = nil
+	if !req.DryRun {
+		putWireOnReturn = false
+		copier = &streamCopier{streamConn: conn, closeStreamOnClose: true}
+	}
+
+	return &res, copier, nil
+}
+
+func (c *Client) ReqRecv(ctx context.Context, req *pdu.ReceiveReq, streamCopier zfs.StreamCopier) (*pdu.ReceiveRes, error) {
+
+	defer c.log.Info("ReqRecv returns")
+	conn, err := c.getWire(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	// send and recv response concurrently to catch early exists of remote handler
+	// (e.g. disk full, permission error, etc)
+
+	type recvRes struct {
+		res *pdu.ReceiveRes
+		err error
+	}
+	recvErrChan := make(chan recvRes)
+	go func() {
+		res := &pdu.ReceiveRes{}
+		if err := c.recv(ctx, conn, res); err != nil {
+			recvErrChan <- recvRes{res, err}
+		} else {
+			recvErrChan <- recvRes{res, nil}
+		}
+	}()
+
+	sendErrChan := make(chan error)
+	go func() {
+		if err := c.send(ctx, conn, EndpointRecv, req, streamCopier); err != nil {
+			sendErrChan <- err
+		} else {
+			sendErrChan <- nil
+		}
+	}()
+
+	var res recvRes
+	var sendErr error
+	var cause error // one of the above
+	didTryClose := false
+	for i := 0; i < 2; i++ {
+		select {
+		case res = <-recvErrChan:
+			c.log.WithField("errType", fmt.Sprintf("%T", res.err)).WithError(res.err).Debug("recv goroutine returned")
+			if res.err != nil && cause == nil {
+				cause = res.err
+			}
+		case sendErr = <-sendErrChan:
+			c.log.WithField("errType", fmt.Sprintf("%T", sendErr)).WithError(sendErr).Debug("send goroutine returned")
+			if sendErr != nil && cause == nil {
+				cause = sendErr
+			}
+		}
+		if !didTryClose && (res.err != nil || sendErr != nil) {
+			didTryClose = true
+			if err := conn.Close(); err != nil {
+				c.log.WithError(err).Error("ReqRecv: cannot close connection, will likely block indefinitely")
+			}
+			c.log.WithError(err).Debug("ReqRecv: closed connection, should trigger other goroutine error")
+		}
+	}
+
+	if !didTryClose {
+		// didn't close it in above loop, so we can give it back
+		c.putWire(conn)
+	}
+
+	// if receive failed with a RemoteHandlerError, we know the transport was not broken
+	// => take the remote error as cause for the operation to fail
+	// TODO combine errors if send also failed
+	//      (after all, send could have crashed on our side, rendering res.err a mere symptom of the cause)
+	if _, ok := res.err.(*RemoteHandlerError); ok {
+		cause = res.err
+	}
+
+	return res.res, cause
+}
+
+
+func (c *Client) ReqPing(ctx context.Context, req *pdu.PingReq) (*pdu.PingRes, error) {
+	conn, err := c.getWire(ctx)
+	if err != nil {
+		return nil, err
+	}
+			defer c.putWire(conn)
+
+	if err := c.send(ctx, conn, EndpointPing, req, nil); err != nil {
+		return nil, err
+	}
+
+	var res pdu.PingRes
+	if err := c.recv(ctx, conn, &res); err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}

rpc/dataconn/dataconn_debug.go

@@ -0,0 +1,20 @@
+package dataconn
+
+import (
+	"fmt"
+	"os"
+)
+
+var debugEnabled bool = false
+
+func init() {
+	if os.Getenv("ZREPL_RPC_DATACONN_DEBUG") != "" {
+		debugEnabled = true
+	}
+}
+
+func debug(format string, args ...interface{}) {
+	if debugEnabled {
+		fmt.Fprintf(os.Stderr, "rpc/dataconn: %s\n", fmt.Sprintf(format, args...))
+	}
+}

rpc/dataconn/dataconn_server.go

@@ -0,0 +1,192 @@
+package dataconn
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/zrepl/zrepl/logger"
+	"github.com/zrepl/zrepl/replication/logic/pdu"
+	"github.com/zrepl/zrepl/rpc/dataconn/stream"
+	"github.com/zrepl/zrepl/transport"
+	"github.com/zrepl/zrepl/zfs"
+)
+
+// WireInterceptor has a chance to exchange the context and connection on each client connection.
+type WireInterceptor func(ctx context.Context, rawConn *transport.AuthConn) (context.Context, *transport.AuthConn)
+
+// Handler implements the functionality that is exposed by Server to the Client.
+type Handler interface {
+	// Send handles a SendRequest.
+	// The returned io.ReadCloser is allowed to be nil, for example if the requested Send is a dry-run.
+	Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, zfs.StreamCopier, error)
+	// Receive handles a ReceiveRequest.
+	// It is guaranteed that Server calls Receive with a stream that holds the IdleConnTimeout
+	// configured in ServerConfig.Shared.IdleConnTimeout.
+	Receive(ctx context.Context, r *pdu.ReceiveReq, receive zfs.StreamCopier) (*pdu.ReceiveRes, error)
+	// PingDataconn handles a PingReq
+	PingDataconn(ctx context.Context, r *pdu.PingReq) (*pdu.PingRes, error)
+}
+
+type Logger = logger.Logger
+
+type Server struct {
+	h   Handler
+	wi  WireInterceptor
+	log Logger
+}
+
+func NewServer(wi WireInterceptor, logger Logger, handler Handler) *Server {
+	return &Server{
+		h:   handler,
+		wi:  wi,
+		log: logger,
+	}
+}
+
+// Serve consumes the listener, closes it as soon as ctx is closed.
+// No accept errors are returned: they are logged to the Logger passed
+// to the constructor.
+func (s *Server) Serve(ctx context.Context, l transport.AuthenticatedListener) {
+
+	go func() {
+		<-ctx.Done()
+		s.log.Debug("context done")
+		if err := l.Close(); err != nil {
+			s.log.WithError(err).Error("cannot close listener")
+		}
+	}()
+	conns := make(chan *transport.AuthConn)
+	go func() {
+		for {
+			conn, err := l.Accept(ctx)
+			if err != nil {
+				if ctx.Done() != nil {
+					s.log.Debug("stop accepting after context is done")
+					return
+				}
+				s.log.WithError(err).Error("accept error")
+				continue
+			}
+			conns <- conn
+		}
+	}()
+	for conn := range conns {
+		go s.serveConn(conn)
+	}
+}
+
+func (s *Server) serveConn(nc *transport.AuthConn) {
+	s.log.Debug("serveConn begin")
+	defer s.log.Debug("serveConn done")
+
+	ctx := context.Background()
+	if s.wi != nil {
+		ctx, nc = s.wi(ctx, nc)
+	}
+
+	c := stream.Wrap(nc, HeartbeatInterval, HeartbeatPeerTimeout)
+	defer func() {
+		s.log.Debug("close client connection")
+		if err := c.Close(); err != nil {
+			s.log.WithError(err).Error("cannot close client connection")
+		}
+	}()
+
+	header, err := c.ReadStreamedMessage(ctx, RequestHeaderMaxSize, ReqHeader)
+	if err != nil {
+		s.log.WithError(err).Error("error reading structured part")
+		return
+	}
+	endpoint := string(header)
+
+	reqStructured, err := c.ReadStreamedMessage(ctx, RequestStructuredMaxSize, ReqStructured)
+	if err != nil {
+		s.log.WithError(err).Error("error reading structured part")
+		return
+	}
+
+	s.log.WithField("endpoint", endpoint).Debug("calling handler")
+
+	var res proto.Message
+	var sendStream zfs.StreamCopier
+	var handlerErr error
+	switch endpoint {
+	case EndpointSend:
+		var req pdu.SendReq
+		if err := proto.Unmarshal(reqStructured, &req); err != nil {
+			s.log.WithError(err).Error("cannot unmarshal send request")
+			return
+		}
+		res, sendStream, handlerErr = s.h.Send(ctx, &req) // SHADOWING
+	case EndpointRecv:
+		var req pdu.ReceiveReq
+		if err := proto.Unmarshal(reqStructured, &req); err != nil {
+			s.log.WithError(err).Error("cannot unmarshal receive request")
+			return
+		}
+		res, handlerErr = s.h.Receive(ctx, &req, &streamCopier{streamConn: c, closeStreamOnClose: false}) // SHADOWING
+	case EndpointPing:
+		var req pdu.PingReq
+		if err := proto.Unmarshal(reqStructured, &req); err != nil {
+			s.log.WithError(err).Error("cannot unmarshal ping request")
+			return
+		}
+		res, handlerErr = s.h.PingDataconn(ctx, &req) // SHADOWING
+	default:
+		s.log.WithField("endpoint", endpoint).Error("unknown endpoint")
+		handlerErr = fmt.Errorf("requested endpoint does not exist")
+		return
+	}
+
+	s.log.WithField("endpoint", endpoint).WithField("errType", fmt.Sprintf("%T", handlerErr)).Debug("handler returned")
+
+	// prepare protobuf now to return the protobuf error in the header
+	// if marshaling fails. We consider failed marshaling a handler error
+	var protobuf *bytes.Buffer
+	if handlerErr == nil {
+		if res == nil {
+			handlerErr = fmt.Errorf("implementation error: handler for endpoint %q returns nil error and nil result", endpoint)
+			s.log.WithError(err).Error("handle implementation error")
+		} else {
+			protobufBytes, err := proto.Marshal(res)
+			if err != nil {
+				s.log.WithError(err).Error("cannot marshal handler protobuf")
+				handlerErr = err
+			}
+			protobuf = bytes.NewBuffer(protobufBytes) // SHADOWING
+		}
+	}
+
+	var resHeaderBuf bytes.Buffer
+	if handlerErr == nil {
+		resHeaderBuf.WriteString(responseHeaderHandlerOk)
+	} else {
+		resHeaderBuf.WriteString(responseHeaderHandlerErrorPrefix)
+		resHeaderBuf.WriteString(handlerErr.Error())
+	}
+	if err := c.WriteStreamedMessage(ctx, &resHeaderBuf, ResHeader); err != nil {
+		s.log.WithError(err).Error("cannot write response header")
+		return
+	}
+
+	if handlerErr != nil {
+		s.log.Debug("early exit after handler error")
+		return
+	}
+
+	if err := c.WriteStreamedMessage(ctx, protobuf, ResStructured); err != nil {
+		s.log.WithError(err).Error("cannot write structured part of response")
+		return
+	}
+
+	if sendStream != nil {
+		err := c.SendStream(ctx, sendStream, ZFSStream)
+		if err != nil {
+			s.log.WithError(err).Error("cannot write send stream")
+		}
+	}
+
+	return
+}

rpc/dataconn/dataconn_shared.go

@@ -0,0 +1,71 @@
+package dataconn
+
+import (
+	"io"
+	"sync"
+	"time"
+
+	"github.com/zrepl/zrepl/rpc/dataconn/stream"
+	"github.com/zrepl/zrepl/zfs"
+)
+
+const (
+	EndpointPing string = "/v1/ping"
+	EndpointSend string = "/v1/send"
+	EndpointRecv string = "/v1/recv"
+)
+
+const (
+	ReqHeader uint32 = 1 + iota
+	ReqStructured
+	ResHeader
+	ResStructured
+	ZFSStream
+)
+
+// Note that changing theses constants may break interop with other clients
+// Aggressive with timing, conservative (future compatible) with buffer sizes
+const (
+	HeartbeatInterval         = 5 * time.Second
+	HeartbeatPeerTimeout      = 10 * time.Second
+	RequestHeaderMaxSize      = 1 << 15
+	RequestStructuredMaxSize  = 1 << 22
+	ResponseHeaderMaxSize     = 1 << 15
+	ResponseStructuredMaxSize = 1 << 23
+)
+
+// the following are protocol constants
+const (
+	responseHeaderHandlerOk          = "HANDLER OK\n"
+	responseHeaderHandlerErrorPrefix = "HANDLER ERROR:\n"
+)
+
+type streamCopier struct {
+	mtx                sync.Mutex
+	used               bool
+	streamConn         *stream.Conn
+	closeStreamOnClose bool
+}
+
+// WriteStreamTo implements zfs.StreamCopier
+func (s *streamCopier) WriteStreamTo(w io.Writer) zfs.StreamCopierError {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if s.used {
+		panic("streamCopier used mulitple times")
+	}
+	s.used = true
+	return s.streamConn.ReadStreamInto(w, ZFSStream)
+}
+
+// Close implements zfs.StreamCopier
+func (s *streamCopier) Close() error {
+	// only record the close here, what we do actually depends on whether
+	// the streamCopier is instantiated server-side or client-side
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if s.closeStreamOnClose {
+		return s.streamConn.Close()
+	}
+	return nil
+}

rpc/dataconn/dataconn_test.go

@@ -0,0 +1 @@
+package dataconn

rpc/dataconn/frameconn/frameconn.go

@@ -0,0 +1,346 @@
+package frameconn
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/zrepl/zrepl/rpc/dataconn/base2bufpool"
+	"github.com/zrepl/zrepl/rpc/dataconn/timeoutconn"
+)
+
+type FrameHeader struct {
+	Type       uint32
+	PayloadLen uint32
+}
+
+// The 4 MSBs of ft are reserved for frameconn.
+func IsPublicFrameType(ft uint32) bool {
+	return (0xf<<28)&ft == 0
+}
+
+const (
+	rstFrameType uint32 = 1<<28 + iota
+)
+
+func assertPublicFrameType(frameType uint32) {
+	if !IsPublicFrameType(frameType) {
+		panic(fmt.Sprintf("frameconn: frame type %v cannot be used by consumers of this package", frameType))
+	}
+}
+
+func (f *FrameHeader) Unmarshal(buf []byte) {
+	if len(buf) != 8 {
+		panic(fmt.Sprintf("frame header is 8 bytes long"))
+	}
+	f.Type = binary.BigEndian.Uint32(buf[0:4])
+	f.PayloadLen = binary.BigEndian.Uint32(buf[4:8])
+}
+
+type Conn struct {
+	readMtx, writeMtx sync.Mutex
+	nc                timeoutconn.Conn
+	ncBuf             *bufio.ReadWriter
+	readNextValid     bool
+	readNext          FrameHeader
+	nextReadErr       error
+	bufPool           *base2bufpool.Pool // no need for sync around it
+	shutdown          shutdownFSM
+}
+
+func Wrap(nc timeoutconn.Conn) *Conn {
+	return &Conn{
+		nc: nc,
+		//		ncBuf: bufio.NewReadWriter(bufio.NewReaderSize(nc, 1<<23), bufio.NewWriterSize(nc, 1<<23)),
+		bufPool:       base2bufpool.New(15, 22, base2bufpool.Allocate), // FIXME switch to Panic, but need to enforce the limits in recv for that. => need frameconn config
+		readNext:      FrameHeader{},
+		readNextValid: false,
+	}
+}
+
+var ErrReadFrameLengthShort = errors.New("read frame length too short")
+var ErrFixedFrameLengthMismatch = errors.New("read frame length mismatch")
+
+type Buffer struct {
+	bufpoolBuffer base2bufpool.Buffer
+	payloadLen    uint32
+}
+
+func (b *Buffer) Free() {
+	b.bufpoolBuffer.Free()
+}
+
+func (b *Buffer) Bytes() []byte {
+	return b.bufpoolBuffer.Bytes()[0:b.payloadLen]
+}
+
+type Frame struct {
+	Header FrameHeader
+	Buffer Buffer
+}
+
+var ErrShutdown = fmt.Errorf("frameconn: shutting down")
+
+// ReadFrame reads a frame from the connection.
+//
+// Due to an internal optimization (Readv, specifically), it is not guaranteed that a single call to
+// WriteFrame unblocks a pending ReadFrame on an otherwise idle (empty) connection.
+// The only way to guarantee that all previously written frames can reach the peer's layers on top
+// of frameconn is to send an empty frame (no payload) and to ignore empty frames on the receiving side.
+func (c *Conn) ReadFrame() (Frame, error) {
+
+	if c.shutdown.IsShuttingDown() {
+		return Frame{}, ErrShutdown
+	}
+
+	// only aquire readMtx now to prioritize the draining in Shutdown()
+	// over external callers (= drain public callers)
+
+	c.readMtx.Lock()
+	defer c.readMtx.Unlock()
+	f, err := c.readFrame()
+	if f.Header.Type == rstFrameType {
+		c.shutdown.Begin()
+		return Frame{}, ErrShutdown
+	}
+	return f, err
+}
+
+// callers must have readMtx locked
+func (c *Conn) readFrame() (Frame, error) {
+
+	if c.nextReadErr != nil {
+		ret := c.nextReadErr
+		c.nextReadErr = nil
+		return Frame{}, ret
+	}
+
+	if !c.readNextValid {
+		var buf [8]byte
+		if _, err := io.ReadFull(c.nc, buf[:]); err != nil {
+			return Frame{}, err
+		}
+		c.readNext.Unmarshal(buf[:])
+		c.readNextValid = true
+	}
+
+	// read payload + next header
+	var nextHdrBuf [8]byte
+	buffer := c.bufPool.Get(uint(c.readNext.PayloadLen))
+	bufferBytes := buffer.Bytes()
+
+	if c.readNext.PayloadLen == 0 {
+		// This if statement implements the unlock-by-sending-empty-frame behavior
+		// documented in ReadFrame's public docs.
+		//
+		// It is crucial that we return this empty frame now:
+		// Consider the following plot with x-axis being time,
+		// P being a frame with payload, E one without, X either of P or E
+		//
+		//    P P P P P P P E.....................X
+		//                | |         |           |
+		//                | |         |           F3
+		//                | |         |
+		//                | F2        |signficant time between frames because
+		//                F1           the peer has nothing to say to us
+		//
+		// Assume we're at the point were F2's header is in c.readNext.
+		// That means F2 has not yet been returned.
+		// But because it is empty (no payload), we're already done reading it.
+		// If we omitted this if statement, the following would happen:
+		// Readv below would read [][]byte{[len(0)], [len(8)]).
+
+		c.readNextValid = false
+		frame := Frame{
+			Header: c.readNext,
+			Buffer: Buffer{
+				bufpoolBuffer: buffer,
+				payloadLen:    c.readNext.PayloadLen, // 0
+			},
+		}
+		return frame, nil
+	}
+
+	noNextHeader := false
+	if n, err := c.nc.ReadvFull([][]byte{bufferBytes, nextHdrBuf[:]}); err != nil {
+		noNextHeader = true
+		zeroPayloadAndPeerClosed := n == 0 && c.readNext.PayloadLen == 0 && err == io.EOF
+		zeroPayloadAndNextFrameHeaderThenPeerClosed := err == io.EOF && c.readNext.PayloadLen == 0 && n == int64(len(nextHdrBuf))
+		nonzeroPayloadRecvdButNextHeaderMissing := n > 0 && uint32(n) == c.readNext.PayloadLen
+		if zeroPayloadAndPeerClosed || zeroPayloadAndNextFrameHeaderThenPeerClosed || nonzeroPayloadRecvdButNextHeaderMissing {
+			// This is the last frame on the conn.
+			// Store the error to be returned on the next invocation of ReadFrame.
+			c.nextReadErr = err
+			// NORETURN, this frame is still valid
+		} else {
+			return Frame{}, err
+		}
+	}
+
+	frame := Frame{
+		Header: c.readNext,
+		Buffer: Buffer{
+			bufpoolBuffer: buffer,
+			payloadLen:    c.readNext.PayloadLen,
+		},
+	}
+
+	if !noNextHeader {
+		c.readNext.Unmarshal(nextHdrBuf[:])
+		c.readNextValid = true
+	} else {
+		c.readNextValid = false
+	}
+
+	return frame, nil
+}
+
+func (c *Conn) WriteFrame(payload []byte, frameType uint32) error {
+	assertPublicFrameType(frameType)
+	if c.shutdown.IsShuttingDown() {
+		return ErrShutdown
+	}
+	c.writeMtx.Lock()
+	defer c.writeMtx.Unlock()
+	return c.writeFrame(payload, frameType)
+}
+
+func (c *Conn) writeFrame(payload []byte, frameType uint32) error {
+	var hdrBuf [8]byte
+	binary.BigEndian.PutUint32(hdrBuf[0:4], frameType)
+	binary.BigEndian.PutUint32(hdrBuf[4:8], uint32(len(payload)))
+	bufs := net.Buffers([][]byte{hdrBuf[:], payload})
+	if _, err := c.nc.WritevFull(bufs); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Conn) Shutdown(deadline time.Time) error {
+	// TCP connection teardown is a bit wonky if we are in a situation
+	// where there is still data in flight (DIF) to our side:
+	// If we just close the connection, our kernel will send RSTs
+	// in response to the DIF, and those RSTs may reach the client's
+	// kernel faster than the client app is able to pull the
+	// last bytes from its kernel TCP receive buffer.
+	//
+	// Therefore, we send a frame with type rstFrameType to indicate
+	// that the connection is to be closed immediately, and further
+	// use CloseWrite instead of Close.
+	// As per definition of the wire interface, CloseWrite guarantees
+	// delivery of the data in our kernel TCP send buffer.
+	// Therefore, the client always receives the RST frame.
+	//
+	// Now what are we going to do after that?
+	//
+	// 1. Naive Option: We just call Close() right after CloseWrite.
+	// This yields the same race condition as explained above (DIF, first
+	// paragraph): The situation just becomae a little more unlikely because
+	// our rstFrameType + CloseWrite dance gave the client a full RTT worth of
+	// time to read the data from its TCP recv buffer.
+	//
+	// 2. Correct Option: Drain the read side until io.EOF
+	// We can read from the unclosed read-side of the connection until we get
+	// the io.EOF caused by the (well behaved) client closing the connection
+	// in response to it reading the rstFrameType frame we sent.
+	// However, this wastes resources on our side (we don't care about the
+	// pending data anymore), and has potential for (D)DoS through CPU-time
+	// exhaustion if the client just keeps sending data.
+	// Then again, this option has the advantage with well-behaved clients
+	// that we do not waste precious kernel-memory on the stale receive buffer
+	// on our side (which is still full of data that we do not intend to read).
+	//
+	// 2.1 DoS Mitigation: Bound the number of bytes to drain, then close
+	// At the time of writing, this technique is practiced by the Go http server
+	// implementation, and actually SHOULDed in the HTTP 1.1 RFC.  It is
+	// important to disable the idle timeout of the underlying timeoutconn in
+	// that case and set an absolute deadline by which the socket must have
+	// been fully drained. Not too hard, though ;)
+	//
+	// 2.2: Client sends RST, not FIN when it receives an rstFrameTyp frame.
+	// We can use wire.(*net.TCPConn).SetLinger(0) to force an RST to be sent
+	// on a subsequent close (instead of a FIN + wait for FIN+ACK).
+	// TODO put this into Wire interface as an abstract method.
+	//
+	// 2.3 Only start draining after N*RTT
+	// We have an RTT approximation from Wire.CloseWrite, which by definition
+	// must not return before all to-be-sent-data has been acknowledged by the
+	// client. Give the client a fair chance to react, and only start draining
+	// after a multiple of the RTT has elapsed.
+	// We waste the recv buffer memory a little longer than necessary, iff the
+	// client reacts faster than expected. But we don't wast CPU time.
+	// If we apply 2.2, we'll also have the benefit that our kernel will have
+	// dropped the recv buffer memory as soon as it receives the client's RST.
+	//
+	// 3. TCP-only: OOB-messaging
+	// We can use TCP's 'urgent' flag in the client to acknowledge the receipt
+	// of the rstFrameType to us.
+	// We can thus wait for that signal while leaving the kernel buffer as is.
+
+	// TODO: For now, we just drain the connection (Option 2),
+	// but we enforce deadlines so the _time_ we drain the connection
+	// is bounded, although we do _that_ at full speed
+
+	defer prometheus.NewTimer(prom.ShutdownSeconds).ObserveDuration()
+
+	closeWire := func(step string) error {
+		// TODO SetLinger(0) or similiar (we want RST frames here, not FINS)
+		if closeErr := c.nc.Close(); closeErr != nil {
+			prom.ShutdownCloseErrors.WithLabelValues("close").Inc()
+			return closeErr
+		}
+		return nil
+	}
+
+	hardclose := func(err error, step string) error {
+		prom.ShutdownHardCloses.WithLabelValues(step).Inc()
+		return closeWire(step)
+	}
+
+	c.shutdown.Begin()
+	// new calls to c.ReadFrame and c.WriteFrame will now return ErrShutdown
+	// Aquiring writeMtx and readMtx ensures that the last calls exit successfully
+
+	// disable renewing timeouts now, enforce the requested deadline instead
+	// we need to do this before aquiring locks to enforce the timeout on slow
+	// clients / if something hangs (DoS mitigation)
+	if err := c.nc.DisableTimeouts(); err != nil {
+		return hardclose(err, "disable_timeouts")
+	}
+	if err := c.nc.SetDeadline(deadline); err != nil {
+		return hardclose(err, "set_deadline")
+	}
+
+	c.writeMtx.Lock()
+	defer c.writeMtx.Unlock()
+
+	if err := c.writeFrame([]byte{}, rstFrameType); err != nil {
+		return hardclose(err, "write_frame")
+	}
+
+	if err := c.nc.CloseWrite(); err != nil {
+		return hardclose(err, "close_write")
+	}
+
+	c.readMtx.Lock()
+	defer c.readMtx.Unlock()
+
+	// TODO DoS mitigation: wait for client acknowledgement that they initiated Shutdown,
+	// then perform abortive close on our side. As explained above, probably requires
+	// OOB signaling such as TCP's urgent flag => transport-specific?
+
+	// TODO DoS mitigation by reading limited number of bytes
+	// see discussion above why this is non-trivial
+	defer prometheus.NewTimer(prom.ShutdownDrainSeconds).ObserveDuration()
+	n, _ := io.Copy(ioutil.Discard, c.nc)
+	prom.ShutdownDrainBytesRead.Observe(float64(n))
+
+	return closeWire("close")
+}