Update python-publish.yml

Create python-publish.yml
2021-02-02 20:17:07 +01:00 · 2021-02-02 19:36:20 +01:00 · 2021-02-02 19:22:56 +01:00 · 2021-02-02 18:51:21 +01:00 · 2021-02-02 18:44:31 +01:00 · 2021-02-02 18:43:28 +01:00
21 changed files with 3587 additions and 1024 deletions
--- a/.github/workflows/python-publish.yml
+++ b/.github/workflows/python-publish.yml
@ -0,0 +1,32 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: ${{ secrets.TWINE_USERNAME }}
+        TWINE_PASSWORD: ${{ secrets.TWINE_PASSWORD }}
+      run: |
+        python setup.py sdist bdist_wheel
+        python3 -m twine check dist/*
+        twine upload dist/*
--- a/.github/workflows/regression.yml
+++ b/.github/workflows/regression.yml
@ -0,0 +1,59 @@
+name: Regression tests
+
+
+on: ["push", "pull_request"]
+  
+
+
+jobs:
+     
+  ubuntu20:
+    runs-on: ubuntu-20.04
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2.3.4
+        
+        
+       
+      - name: Prepare
+        run: lsmod && sudo apt update && sudo apt install zfsutils-linux && sudo -H pip3 install coverage unittest2 mock==3.0.5 coveralls
+        
+        
+      - name: Regression test
+        run: sudo -E ./run_tests
+       
+        
+      - name: Coveralls
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: coveralls --service=github
+        
+  ubuntu18:
+    runs-on: ubuntu-18.04
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2.3.4
+        
+        
+       
+      - name: Prepare
+        run: lsmod && sudo apt update && sudo apt install zfsutils-linux python3-setuptools && sudo -H pip3 install coverage unittest2 mock==3.0.5 coveralls
+        
+        
+      - name: Regression test
+        run: sudo -E ./run_tests
+       
+        
+      - name: Coveralls
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: coveralls --service=github
+        
+      
+       
+       
+           
+       
+      
--- a/.gitignore
+++ b/.gitignore
@ -6,3 +6,6 @@ build/
 zfs_autobackup.egg-info
 .eggs/
 __pycache__
+.coverage
+*.pyc
+python2.env
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,32 @@
+#MOVING TO GITHUB ACTIONS
+
+# jobs:
+#   include:
+#     - os: linux
+#       dist: xenial
+#       language: python
+#       python: 2.7
+#     - os: linux
+#       dist: xenial
+#       language: python
+#       python: 3.6
+#     - os: linux
+#       dist: bionic
+#       language: python
+#       python: 2.7
+#     - os: linux
+#       dist: bionic
+#       language: python
+#       python: 3.6
+
+
+
+
+# before_install:
+#   - sudo apt-get update
+#   - sudo apt-get install zfsutils-linux
+
+# script:
+#   # - sudo -E ./ngrok.sh
+#   - sudo -E ./run_tests
+#   # - sudo -E pip --version
--- a/README.md
+++ b/README.md
@ -1,26 +1,34 @@
+
 # ZFS autobackup

+[![Coverage Status](https://coveralls.io/repos/github/psy0rz/zfs_autobackup/badge.svg)](https://coveralls.io/github/psy0rz/zfs_autobackup) [![Regression tests](https://github.com/psy0rz/zfs_autobackup/workflows/Regression%20tests/badge.svg)](https://github.com/psy0rz/zfs_autobackup/actions?query=workflow%3A%22Regression+tests%22)
+
 ## New in v3

 * Complete rewrite, cleaner object oriented code.
 * Python 3 and 2 support.
-* Installable via pip.
+* Automated regression against real ZFS environment.
+* Installable via [pip](https://pypi.org/project/zfs-autobackup/).
 * Backwards compatible with your current backups and parameters.
 * Progressive thinning (via a destroy schedule. default schedule should be fine for most people)
 * Cleaner output, with optional color support (pip install colorama).
 * Clear distinction between local and remote output.
 * Summary at the beginning, displaying what will happen and the current thinning-schedule.
-* More effient destroying/skipping snaphots on the fly. (no more space issues if your backup is way behind)
+* More efficient destroying/skipping snapshots on the fly. (no more space issues if your backup is way behind)
 * Progress indicator (--progress)
 * Better property management (--set-properties and --filter-properties)
-* Better resume handling, automaticly abort invalid resumes.
+* Better resume handling, automatically abort invalid resumes.
 * More robust error handling.
-* Prepared for future enhanchements.
+* Prepared for future enhancements.
 * Supports raw backups for encryption.
+* Custom SSH client config.
+

 ## Introduction

-This is a tool I wrote to make replicating ZFS datasets easy and reliable. You can either use it as a backup tool or as a replication tool.
+This is a tool I wrote to make replicating ZFS datasets easy and reliable. 
+
+You can either use it as a **backup** tool, **replication** tool or **snapshot** tool.

 You can select what to backup by setting a custom `ZFS property`. This allows you to set and forget: Configure it so it backups your entire pool, and you never have to worry about backupping again. Even new datasets you create later will be backupped.

@ -28,15 +36,15 @@ Other settings are just specified on the commandline. This also makes it easier

 Since its using ZFS commands, you can see what its actually doing by specifying `--debug`. This also helps a lot if you run into some strange problem or error. You can just copy-paste the command that fails and play around with it on the commandline. (also something I missed in other tools)

-An imporant feature thats missing from other tools is a reliable `--test` option: This allows you to see what zfs-autobackup will do and tune your parameters. It will do everything, except make changes to your zfs datasets.
+An important feature thats missing from other tools is a reliable `--test` option: This allows you to see what zfs-autobackup will do and tune your parameters. It will do everything, except make changes to your zfs datasets.

-Another nice thing is progress reporting with `--progress`. Its very usefull with HUGE datasets, when you want to know how many hours/days it will take.
+Another nice thing is progress reporting: Its very useful with HUGE datasets, when you want to know how many hours/days it will take.

 zfs-autobackup tries to be the easiest to use backup tool for zfs.

 ## Features

-* Works across operating systems: Tested with Linux, FreeBSD/FreeNAS and SmartOS.
+* Works across operating systems: Tested with **Linux**, **FreeBSD/FreeNAS** and **SmartOS**.
 * Works in combination with existing replication systems. (Like Proxmox HA)
 * Automatically selects filesystems to backup by looking at a simple ZFS property. (recursive)
 * Creates consistent snapshots. (takes all snapshots at once, atomic.)
@ -47,13 +55,16 @@ zfs-autobackup tries to be the easiest to use backup tool for zfs.
  * Or even pull data from a server while pushing the backup to another server.
 * Can be scheduled via a simple cronjob or run directly from commandline.
 * Supports resuming of interrupted transfers. (via the zfs extensible_dataset feature)
-* Backups and snapshots can be named to prevent conflicts. (multiple backups from and to the same filesystems are no problem)
+* Backups and snapshots can be named to prevent conflicts. (multiple backups from and to the same datasets are no problem)
 * Always creates a new snapshot before starting.
 * Checks everything but tries continue on non-fatal errors when possible. (Reports error-count when done)
-* Ability to 'finish' aborted backups to see what goes wrong.
+* Ability to manually 'finish' failed backups to see whats going on.
 * Easy to debug and has a test-mode. Actual unix commands are printed.
-* Keeps latest X snapshots remote and locally. (default 30, configurable)
+* Uses **progressive thinning** for older snapshots.
 * Uses zfs-holds on important snapshots so they cant be accidentally destroyed.
+* Automatic resuming of failed transfers.
+* Can continue from existing common snapshots. (e.g. easy migration)
+* Gracefully handles destroyed datasets on source.
 * Easy installation:
  * Just install zfs-autobackup via pip, or download it manually.
  * Written in python and uses zfs-commands, no 3rd party dependency's or libraries.
@ -63,12 +74,14 @@ zfs-autobackup tries to be the easiest to use backup tool for zfs.

 ### Using pip

-The recommended way on most servers is to use pip:
+The recommended way on most servers is to use [pip](https://pypi.org/project/zfs-autobackup/):

 ```console
-[root@server ~]# pip install zfs-autobackup
+[root@server ~]# pip install --upgrade zfs-autobackup
 ```

+This can also be used to upgrade zfs-autobackup to the newest stable version.
+
 ### Using easy_install

 On older servers you might have to use easy_install
@ -79,44 +92,101 @@ On older servers you might have to use easy_install

 ### Direct download

-Its also possible to just download <https://raw.githubusercontent.com/psy0rz/zfs_autobackup/master/bin/zfs-autobackup> and run it directly.
+Its also possible to just download <https://raw.githubusercontent.com/psy0rz/zfs_autobackup/v3.0/bin/zfs-autobackup> and run it directly.

-The only requirement that is sometimes missing is the `argparse` python module. Optionally you can install `colorma` for colors.
+The only requirement that is sometimes missing is the `argparse` python module. Optionally you can install `colorama` for colors.

 It should work with python 2.7 and higher.

 ## Example

-In this example we're going to backup a machine called `pve` to our backupserver.
+In this example we're going to backup a machine called `server1` to a machine called `backup`.

-Its important to choose a unique and consistent backup name. In this case we name our backup: `offsite1`.
+### Setup SSH login
+
+zfs-autobackup needs passwordless login via ssh. This means generating an ssh key and copying it to the remote server.
+
+#### Generate SSH key on `backup`
+
+On the backup-server that runs zfs-autobackup you need to create an SSH key. You only need to do this once.
+
+Use the `ssh-keygen` command and leave the passphrase empty:
+
+```console
+root@backup:~# ssh-keygen
+Generating public/private rsa key pair.
+Enter file in which to save the key (/root/.ssh/id_rsa):
+Enter passphrase (empty for no passphrase):
+Enter same passphrase again:
+Your identification has been saved in /root/.ssh/id_rsa.
+Your public key has been saved in /root/.ssh/id_rsa.pub.
+The key fingerprint is:
+SHA256:McJhCxvaxvFhO/3e8Lf5gzSrlTWew7/bwrd2U2EHymE root@backup
+The key's randomart image is:
+---[RSA 2048]----+
+|    + =          |
+|   + X *    E .  |
+|  . = B +  o o . |
+|   .   o +  o  o.|
+|        S o   .oo|
+|         . + o= +|
+|          . ++==.|
+|            .+o**|
+|           .. +B@|
+----[SHA256]-----+
+root@backup:~#
+```
+
+#### Copy SSH key to `server1`
+
+Now you need to copy the public part of the key to `server1`
+
+The `ssh-copy-id` command is a handy tool to automate this. It will just ask for your password.
+
+```console
+root@backup:~# ssh-copy-id root@server1.server.com
+/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/root/.ssh/id_rsa.pub"
+/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
+/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
+Password:
+
+Number of key(s) added: 1
+
+Now try logging into the machine, with:   "ssh 'root@server1.server.com'"
+and check to make sure that only the key(s) you wanted were added.
+
+root@backup:~#
+```
+This allows the backup-server to login to `server1` as root without password.

 ### Select filesystems to backup

-On the source zfs system set the ```autobackup:offsite``` zfs property to true:
+Its important to choose a unique and consistent backup name. In this case we name our backup: `offsite1`.
+
+On the source zfs system set the ```autobackup:offsite1``` zfs property to true:

 ```console
-[root@pve ~]# zfs set autobackup:offsite1=true rpool
-[root@pve ~]# zfs get -t filesystem,volume autobackup:offsite1
+[root@server1 ~]# zfs set autobackup:offsite1=true rpool
+[root@server1 ~]# zfs get -t filesystem,volume autobackup:offsite1
 NAME                                    PROPERTY             VALUE                SOURCE
 rpool                                   autobackup:offsite1  true                 local
 rpool/ROOT                              autobackup:offsite1  true                 inherited from rpool
-rpool/ROOT/pve-1                        autobackup:offsite1  true                 inherited from rpool
+rpool/ROOT/server1-1                    autobackup:offsite1  true                 inherited from rpool
 rpool/data                              autobackup:offsite1  true                 inherited from rpool
 rpool/data/vm-100-disk-0                autobackup:offsite1  true                 inherited from rpool
 rpool/swap                              autobackup:offsite1  true                 inherited from rpool
 ...
 ```

-Because we dont want to backup everything, we can exclude certain filesystem by setting the property to false:
+Because we don't want to backup everything, we can exclude certain filesystem by setting the property to false:

 ```console
-[root@pve ~]# zfs set autobackup:offsite1=false rpool/swap
-[root@pve ~]# zfs get -t filesystem,volume autobackup:offsite1
+[root@server1 ~]# zfs set autobackup:offsite1=false rpool/swap
+[root@server1 ~]# zfs get -t filesystem,volume autobackup:offsite1
 NAME                                    PROPERTY             VALUE                SOURCE
 rpool                                   autobackup:offsite1  true                 local
 rpool/ROOT                              autobackup:offsite1  true                 inherited from rpool
-rpool/ROOT/pve-1                        autobackup:offsite1  true                 inherited from rpool
+rpool/ROOT/server1-1                    autobackup:offsite1  true                 inherited from rpool
 rpool/data                              autobackup:offsite1  true                 inherited from rpool
 rpool/data/vm-100-disk-0                autobackup:offsite1  true                 inherited from rpool
 rpool/swap                              autobackup:offsite1  false                local
@ -125,198 +195,212 @@ rpool/swap                              autobackup:offsite1  false

 ### Running zfs-autobackup

-Before you start, make sure you can login to the server without password, by using `SSH keys`. Look at the troubleshooting section for more info.
-
-There are 2 ways to run the backup, but the endresult is always the same. Its just a matter of security (trust relations between the servers) and preference.
-
-#### Method 1: Pull backup
-
-Run the script on the backup server and pull the data from the server specfied by --ssh-source. This is usually the preferred way and prevents a hacked server from accesing the backup-data.
+Run the script on the backup server and pull the data from the server specified by --ssh-source.

 ```console
-[root@backup ~]# zfs-autobackup --ssh-source pve.server.com offsite1 backup/pve --progress --verbose
+[root@backup ~]# zfs-autobackup --ssh-source server1.server.com offsite1 backup/server1 --progress --verbose

  #### Settings summary
-  [Source] Datasets on: pve.server.com
+  [Source] Datasets on: server1.server.com
  [Source] Keep the last 10 snapshots.
-  [Source] Keep oldest of 1 day, delete after 1 week.
-  [Source] Keep oldest of 1 week, delete after 1 month.
-  [Source] Keep oldest of 1 month, delete after 1 year.
+  [Source] Keep every 1 day, delete after 1 week.
+  [Source] Keep every 1 week, delete after 1 month.
+  [Source] Keep every 1 month, delete after 1 year.
  [Source] Send all datasets that have 'autobackup:offsite1=true' or 'autobackup:offsite1=child'
-  
+
  [Target] Datasets are local
  [Target] Keep the last 10 snapshots.
-  [Target] Keep oldest of 1 day, delete after 1 week.
-  [Target] Keep oldest of 1 week, delete after 1 month.
-  [Target] Keep oldest of 1 month, delete after 1 year.
-  [Target] Receive datasets under: backup/pve
-  
+  [Target] Keep every 1 day, delete after 1 week.
+  [Target] Keep every 1 week, delete after 1 month.
+  [Target] Keep every 1 month, delete after 1 year.
+  [Target] Receive datasets under: backup/server1
+
  #### Selecting
  [Source] rpool: Selected (direct selection)
  [Source] rpool/ROOT: Selected (inherited selection)
-  [Source] rpool/ROOT/pve-1: Selected (inherited selection)
+  [Source] rpool/ROOT/server1-1: Selected (inherited selection)
  [Source] rpool/data: Selected (inherited selection)
  [Source] rpool/data/vm-100-disk-0: Selected (inherited selection)
  [Source] rpool/swap: Ignored (disabled)
-  
+
  #### Snapshotting
  [Source] rpool: No changes since offsite1-20200218175435
  [Source] rpool/ROOT: No changes since offsite1-20200218175435
  [Source] rpool/data: No changes since offsite1-20200218175435
  [Source] Creating snapshot offsite1-20200218180123
-  
-  #### Transferring
-  [Target] backup/pve/rpool/ROOT/pve-1@offsite1-20200218175435: receiving full
-  [Target] backup/pve/rpool/ROOT/pve-1@offsite1-20200218175547: receiving incremental
-  [Target] backup/pve/rpool/ROOT/pve-1@offsite1-20200218175706: receiving incremental
-  [Target] backup/pve/rpool/ROOT/pve-1@offsite1-20200218180049: receiving incremental
-  [Target] backup/pve/rpool/ROOT/pve-1@offsite1-20200218180123: receiving incremental
-  [Target] backup/pve/rpool/data@offsite1-20200218175435: receiving full
-  [Target] backup/pve/rpool/data/vm-100-disk-0@offsite1-20200218175435: receiving full
+
+  #### Sending and thinning
+  [Target] backup/server1/rpool/ROOT/server1-1@offsite1-20200218175435: receiving full
+  [Target] backup/server1/rpool/ROOT/server1-1@offsite1-20200218175547: receiving incremental
+  [Target] backup/server1/rpool/ROOT/server1-1@offsite1-20200218175706: receiving incremental
+  [Target] backup/server1/rpool/ROOT/server1-1@offsite1-20200218180049: receiving incremental
+  [Target] backup/server1/rpool/ROOT/server1-1@offsite1-20200218180123: receiving incremental
+  [Target] backup/server1/rpool/data@offsite1-20200218175435: receiving full
+  [Target] backup/server1/rpool/data/vm-100-disk-0@offsite1-20200218175435: receiving full
  ...
 ```

-#### Method 2: push backup
+Note that this is called a "pull" backup: The backup server pulls the backup from the server. This is usually the preferred way.

-Run the script on the server and push the data to the backup server specified by --ssh-target.
-
-```console
-[root@pve ~]# zfs-autobackup --ssh-target backup.server.com offsite1 backup/pve --progress --verbose
-
-  #### Settings summary
-  [Source] Datasets are local
-  [Source] Keep the last 10 snapshots.
-  [Source] Keep oldest of 1 day, delete after 1 week.
-  [Source] Keep oldest of 1 week, delete after 1 month.
-  [Source] Keep oldest of 1 month, delete after 1 year.
-  [Source] Send all datasets that have 'autobackup:offsite1=true' or 'autobackup:offsite1=child'
-  
-  [Target] Datasets on: backup.server.com
-  [Target] Keep the last 10 snapshots.
-  [Target] Keep oldest of 1 day, delete after 1 week.
-  [Target] Keep oldest of 1 week, delete after 1 month.
-  [Target] Keep oldest of 1 month, delete after 1 year.
-  [Target] Receive datasets under: backup/pve
-  ...
-
-```
+Its also possible to let a server push its backup to the backup-server. However this has security implications. In that case you would setup the SSH keys the other way around and use the --ssh-target parameter on the server.

 ### Automatic backups

-Now everytime you run the command, zfs-autobackup will create a new snapshot and replicate your data.
+Now every time you run the command, zfs-autobackup will create a new snapshot and replicate your data.

-Older snapshots will evertually be deleted, depending on the `--keep-source` and `--keep-target` settings. (The defaults are shown above under the 'Settings summary')
+Older snapshots will eventually be deleted, depending on the `--keep-source` and `--keep-target` settings. (The defaults are shown above under the 'Settings summary')

-Once you've got the correct settings for your situation, you can just store the command in a cronjob. 
+Once you've got the correct settings for your situation, you can just store the command in a cronjob.

 Or just create a script and run it manually when you need it.

+## Use as snapshot tool
+
+You can use zfs-autobackup to only make snapshots. 
+
+Just dont specify the target-path:
+```console
+root@ws1:~# zfs-autobackup test --verbose 
+  zfs-autobackup v3.0 - Copyright 2020 E.H.Eefting (edwin@datux.nl)
+  
+  #### Source settings
+  [Source] Datasets are local
+  [Source] Keep the last 10 snapshots.
+  [Source] Keep every 1 day, delete after 1 week.
+  [Source] Keep every 1 week, delete after 1 month.
+  [Source] Keep every 1 month, delete after 1 year.
+  [Source] Selects all datasets that have property 'autobackup:test=true' (or childs of datasets that have 'autobackup:test=child')
+  
+  #### Selecting
+  [Source] test_source1/fs1: Selected (direct selection)
+  [Source] test_source1/fs1/sub: Selected (inherited selection)
+  [Source] test_source2/fs2: Ignored (only childs)
+  [Source] test_source2/fs2/sub: Selected (inherited selection)
+  
+  #### Snapshotting
+  [Source] Creating snapshots test-20200710125958 in pool test_source1
+  [Source] Creating snapshots test-20200710125958 in pool test_source2
+  
+  #### Thinning source
+  [Source] test_source1/fs1@test-20200710125948: Destroying
+  [Source] test_source1/fs1/sub@test-20200710125948: Destroying
+  [Source] test_source2/fs2/sub@test-20200710125948: Destroying
+  
+  #### All operations completed successfully
+  (No target_path specified, only operated as snapshot tool.)
+```
+
+This also allows you to make several snapshots during the day, but only backup the data at night when the server is not busy.
+
+## Thinning out obsolete snapshots
+
+The thinner is the thing that destroys old snapshots on the source and target.
+
+The thinner operates "stateless": There is nothing in the name or properties of a snapshot that indicates how long it will be kept. Everytime zfs-autobackup runs, it will look at the timestamp of all the existing snapshots. From there it will determine which snapshots are obsolete according to your schedule. The advantage of this stateless system is that you can always change the schedule.
+
+Note that the thinner will ONLY destroy snapshots that are matching the naming pattern of zfs-autobackup. If you use `--other-snapshots`, it wont destroy those snapshots after replicating them to the target.
+
+### Destroying missing datasets
+
+When a dataset has been destroyed or deselected on the source, but still exists on the target we call it a missing dataset. Missing datasets will be still thinned out according to the schedule.
+
+The final snapshot will never be destroyed, unless you specify a **deadline** with the `--destroy-missing` option:
+
+In that case it will look at the last snapshot we took and determine if is older than the deadline you specified. e.g: `--destroy-missing 30d` will start destroying things 30 days after the last snapshot.
+
+#### After the deadline
+
+When the deadline is passed, all our snapshots, except the last one will be destroyed. Irregardless of the normal thinning schedule.
+
+The dataset has to have the following properties to be finally really destroyed:
+
+* The dataset has no direct child-filesystems or volumes.
+* The only snapshot left is the last one created by zfs-autobackup.
+* The remaining snapshot has no clones.
+
+### Thinning schedule
+
+The default thinning schedule is: `10,1d1w,1w1m,1m1y`.
+
+The schedule consists of multiple rules separated by a `,`
+
+A plain number specifies how many snapshots you want to always keep, regardless of time or interval.
+
+The format of the other rules is: `<Interval><TTL>`.
+
+* Interval: The minimum interval between the snapshots. Snapshots with intervals smaller than this will be destroyed.
+* TTL: The maximum time to life time of a snapshot, after that they will be destroyed.
+* These are the time units you can use for interval and TTL:
+  * `y`: Years
+  * `m`: Months
+  * `d`: Days
+  * `h`: Hours
+  * `min`: Minutes
+  * `s`: Seconds
+
+Since this might sound very complicated, the `--verbose` option will show you what it all means:
+
+```console
+  [Source] Keep the last 10 snapshots.
+  [Source] Keep every 1 day, delete after 1 week.
+  [Source] Keep every 1 week, delete after 1 month.
+  [Source] Keep every 1 month, delete after 1 year.
+```
+
+A snapshot will only be destroyed if it not needed anymore by ANY of the rules.
+
+You can specify as many rules as you need. The order of the rules doesn't matter.
+
+Keep in mind its up to you to actually run zfs-autobackup often enough: If you want to keep hourly snapshots, you have to make sure you at least run it every hour.
+
+However, its no problem if you run it more or less often than that: The thinner will still keep an optimal set of snapshots to match your schedule as good as possible.
+
+If you want to keep as few snapshots as possible, just specify 0. (`--keep-source=0` for example)
+
+If you want to keep ALL the snapshots, just specify a very high number.
+
+### More details about the Thinner
+
+We will give a practical example of how the thinner operates.
+
+Say we want have 3 thinner rules: 
+
+* We want to keep daily snapshots for 7 days.
+* We want to keep weekly snapshots for 4 weeks.
+* We want to keep monthly snapshots for 12 months.
+
+So far we have taken 4 snapshots at random moments:
+
+![thinner example](https://raw.githubusercontent.com/psy0rz/zfs_autobackup/master/doc/thinner.png)
+
+For every rule, the thinner will divide the timeline in blocks and assign each snapshot to a block.
+
+A block can only be assigned one snapshot: If multiple snapshots fall into the same block, it only assigns it to the oldest that we want to keep.
+
+The colors show to which block a snapshot belongs:
+
+* Snapshot 1: This snapshot belongs to daily block 1, weekly block 0 and monthly block 0. However the daily block is too old. 
+* Snapshot 2: Since weekly block 0 and monthly block 0 already have a snapshot, it only belongs to daily block 4.
+* Snapshot 3: This snapshot belongs to daily block 8 and weekly block 1.
+* Snapshot 4: Since daily block 8 already has a snapshot, this one doesn't belong to anything and can be deleted right away. (it will be keeped for now since its the last snapshot)
+
+zfs-autobackup will re-evaluate this on every run: As soon as a snapshot doesn't belong to any block anymore it will be destroyed.
+
+Snapshots on the source that still have to be send to the target wont be destroyed off course. (If the target still wants them, according to the target schedule)
+
 ## Tips

-* Use ```--verbose``` to see details, otherwise zfs-autobackup will be quiet and only show errors, like a nice unix command.
 * Use ```--debug``` if something goes wrong and you want to see the commands that are executed. This will also stop at the first error.
-* Use ```--resume``` to be able to resume aborted backups. (not all zfs versions support this)
+* You can split up the snapshotting and sending tasks by creating two cronjobs. Create a separate snapshotter-cronjob by just omitting target-path.
 * Set the ```readonly``` property of the target filesystem to ```on```. This prevents changes on the target side. (Normally, if there are changes the next backup will fail and will require a zfs rollback.) Note that readonly means you cant change the CONTENTS of the dataset directly. Its still possible to receive new datasets and manipulate properties etc.
 * Use ```--clear-refreservation``` to save space on your backup server.
 * Use ```--clear-mountpoint``` to prevent the target server from mounting the backupped filesystem in the wrong place during a reboot.

-## Usage
+### Speeding up SSH

-Here you find all the options:
+You can make your ssh connections persistent and greatly speed up zfs-autobackup:

-```console
-[root@server ~]# zfs-autobackup --help
-usage: zfs-autobackup [-h] [--ssh-source SSH_SOURCE] [--ssh-target SSH_TARGET]
-                      [--keep-source KEEP_SOURCE] [--keep-target KEEP_TARGET]
-                      [--no-snapshot] [--allow-empty] [--ignore-replicated]
-                      [--no-holds] [--resume] [--strip-path STRIP_PATH]
-                      [--buffer BUFFER] [--clear-refreservation]
-                      [--clear-mountpoint]
-                      [--filter-properties FILTER_PROPERTIES]
-                      [--set-properties SET_PROPERTIES] [--rollback]
-                      [--ignore-transfer-errors] [--raw] [--test] [--verbose]
-                      [--debug] [--debug-output] [--progress]
-                      backup_name target_path
-
-ZFS autobackup 3.0-rc3
-
-positional arguments:
-  backup_name           Name of the backup (you should set the zfs property
-                        "autobackup:backup-name" to true on filesystems you
-                        want to backup
-  target_path           Target ZFS filesystem
-
-optional arguments:
-  -h, --help            show this help message and exit
-  --ssh-source SSH_SOURCE
-                        Source host to get backup from. (user@hostname)
-                        Default None.
-  --ssh-target SSH_TARGET
-                        Target host to push backup to. (user@hostname) Default
-                        None.
-  --keep-source KEEP_SOURCE
-                        Thinning schedule for old source snapshots. Default:
-                        10,1d1w,1w1m,1m1y
-  --keep-target KEEP_TARGET
-                        Thinning schedule for old target snapshots. Default:
-                        10,1d1w,1w1m,1m1y
-  --no-snapshot         dont create new snapshot (usefull for finishing
-                        uncompleted backups, or cleanups)
-  --allow-empty         if nothing has changed, still create empty snapshots.
-  --ignore-replicated   Ignore datasets that seem to be replicated some other
-                        way. (No changes since lastest snapshot. Usefull for
-                        proxmox HA replication)
-  --no-holds            Dont lock snapshots on the source. (Usefull to allow
-                        proxmox HA replication to switches nodes)
-  --resume              support resuming of interrupted transfers by using the
-                        zfs extensible_dataset feature (both zpools should
-                        have it enabled) Disadvantage is that you need to use
-                        zfs recv -A if another snapshot is created on the
-                        target during a receive. Otherwise it will keep
-                        failing.
-  --strip-path STRIP_PATH
-                        number of directory to strip from path (use 1 when
-                        cloning zones between 2 SmartOS machines)
-  --clear-refreservation
-                        Filter "refreservation" property. (recommended, safes
-                        space. same as --filter-properties refreservation)
-  --clear-mountpoint    Filter "canmount" property. You still have to set
-                        canmount=noauto on the backup server. (recommended,
-                        prevents mount conflicts. same as --filter-properties
-                        canmount)
-  --filter-properties FILTER_PROPERTIES
-                        List of propererties to "filter" when receiving
-                        filesystems. (you can still restore them with zfs
-                        inherit -S)
-  --set-properties SET_PROPERTIES
-                        List of propererties to override when receiving
-                        filesystems. (you can still restore them with zfs
-                        inherit -S)
-  --rollback            Rollback changes on the target before starting a
-                        backup. (normally you can prevent changes by setting
-                        the readonly property on the target_path to on)
-  --ignore-transfer-errors
-                        Ignore transfer errors (still checks if received
-                        filesystem exists. usefull for acltype errors)
-  --raw                 For encrypted datasets, send data exactly as it exists
-                        on disk.
-  --test                dont change anything, just show what would be done
-                        (still does all read-only operations)
-  --verbose             verbose output
-  --debug               Show zfs commands that are executed, stops after an
-                        exception.
-  --debug-output        Show zfs commands and their output/exit codes. (noisy)
-  --progress            show zfs progress output (to stderr)
-
-When a filesystem fails, zfs_backup will continue and report the number of
-failures at that end. Also the exit code will indicate the number of failures.
-
-```
-
-
-### Speeding up SSH and prevent connection flooding
-
-Add this to your ~/.ssh/config:
+On the backup-server add this to your ~/.ssh/config:

 ```console
 Host *
@ -325,8 +409,6 @@ Host *
    ControlPersist 3600
 ```

-This will make all your ssh connections persistent and greatly speed up zfs-autobackup for jobs with short intervals.
-
 Thanks @mariusvw :)

 ### Specifying ssh port or options
@ -347,24 +429,120 @@ Also uses compression on slow links.

 Look in man ssh_config for many more options.

+## Usage
+
+Here you find all the options:
+
+```console
+[root@server ~]# zfs-autobackup --help
+usage: zfs-autobackup [-h] [--ssh-config SSH_CONFIG] [--ssh-source SSH_SOURCE]
+                      [--ssh-target SSH_TARGET] [--keep-source KEEP_SOURCE]
+                      [--keep-target KEEP_TARGET] [--other-snapshots]
+                      [--no-snapshot] [--no-send] [--min-change MIN_CHANGE]
+                      [--allow-empty] [--ignore-replicated] [--no-holds]
+                      [--strip-path STRIP_PATH] [--clear-refreservation]
+                      [--clear-mountpoint]
+                      [--filter-properties FILTER_PROPERTIES]
+                      [--set-properties SET_PROPERTIES] [--rollback]
+                      [--destroy-incompatible] [--ignore-transfer-errors]
+                      [--raw] [--test] [--verbose] [--debug] [--debug-output]
+                      [--progress]
+                      backup-name [target-path]
+
+zfs-autobackup v3.0-rc12 - Copyright 2020 E.H.Eefting (edwin@datux.nl)
+
+positional arguments:
+  backup-name           Name of the backup (you should set the zfs property
+                        "autobackup:backup-name" to true on filesystems you
+                        want to backup
+  target-path           Target ZFS filesystem (optional: if not specified,
+                        zfs-autobackup will only operate as snapshot-tool on
+                        source)
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --ssh-config SSH_CONFIG
+                        Custom ssh client config
+  --ssh-source SSH_SOURCE
+                        Source host to get backup from. (user@hostname)
+                        Default None.
+  --ssh-target SSH_TARGET
+                        Target host to push backup to. (user@hostname) Default
+                        None.
+  --keep-source KEEP_SOURCE
+                        Thinning schedule for old source snapshots. Default:
+                        10,1d1w,1w1m,1m1y
+  --keep-target KEEP_TARGET
+                        Thinning schedule for old target snapshots. Default:
+                        10,1d1w,1w1m,1m1y
+  --other-snapshots     Send over other snapshots as well, not just the ones
+                        created by this tool.
+  --no-snapshot         Don't create new snapshots (useful for finishing
+                        uncompleted backups, or cleanups)
+  --no-send             Don't send snapshots (useful for cleanups, or if you
+                        want a serperate send-cronjob)
+  --min-change MIN_CHANGE
+                        Number of bytes written after which we consider a
+                        dataset changed (default 1)
+  --allow-empty         If nothing has changed, still create empty snapshots.
+                        (same as --min-change=0)
+  --ignore-replicated   Ignore datasets that seem to be replicated some other
+                        way. (No changes since lastest snapshot. Useful for
+                        proxmox HA replication)
+  --no-holds            Don't lock snapshots on the source. (Useful to allow
+                        proxmox HA replication to switches nodes)
+  --strip-path STRIP_PATH
+                        Number of directories to strip from target path (use 1
+                        when cloning zones between 2 SmartOS machines)
+  --clear-refreservation
+                        Filter "refreservation" property. (recommended, safes
+                        space. same as --filter-properties refreservation)
+  --clear-mountpoint    Set property canmount=noauto for new datasets.
+                        (recommended, prevents mount conflicts. same as --set-
+                        properties canmount=noauto)
+  --filter-properties FILTER_PROPERTIES
+                        List of properties to "filter" when receiving
+                        filesystems. (you can still restore them with zfs
+                        inherit -S)
+  --set-properties SET_PROPERTIES
+                        List of propererties to override when receiving
+                        filesystems. (you can still restore them with zfs
+                        inherit -S)
+  --rollback            Rollback changes to the latest target snapshot before
+                        starting. (normally you can prevent changes by setting
+                        the readonly property on the target_path to on)
+  --destroy-incompatible
+                        Destroy incompatible snapshots on target. Use with
+                        care! (implies --rollback)
+  --ignore-transfer-errors
+                        Ignore transfer errors (still checks if received
+                        filesystem exists. useful for acltype errors)
+  --raw                 For encrypted datasets, send data exactly as it exists
+                        on disk.
+  --test                dont change anything, just show what would be done
+                        (still does all read-only operations)
+  --verbose             verbose output
+  --debug               Show zfs commands that are executed, stops after an
+                        exception.
+  --debug-output        Show zfs commands and their output/exit codes. (noisy)
+  --progress            show zfs progress output (to stderr). Enabled by
+                        default on ttys.
+
+When a filesystem fails, zfs_backup will continue and report the number of
+failures at that end. Also the exit code will indicate the number of failures.
+```
+
 ## Troubleshooting

 ### It keeps asking for my SSH password

-You forgot to setup automatic login via SSH keys:
+You forgot to setup automatic login via SSH keys, look in the example how to do this.

-* Create a SSH key on the server that you want to run zfs-autobackup on. Use `ssh-keygen`.
-* Copy the public key to your clipboard. Get it with `cat /root/.ssh/id_rsa.pub`
-* Add the key to the server you specified with --ssh-source or --ssh-target. Create and add it to `/root/.ssh/authorized_keys`
+### It says 'cannot receive incremental stream: invalid backup stream'

-> ###  cannot receive incremental stream: invalid backup stream
+This usually means you've created a new snapshot on the target side during a backup. If you restart zfs-autobackup, it will automaticly abort the invalid partially received snapshot and start over.

-This usually means you've created a new snapshot on the target side during a backup:
-
-* Solution 1: Restart zfs-autobackup and make sure you dont use --resume. If you did use --resume, be sure to "abort" the recveive on the target side with zfs recv -A.
-* Solution 2: Destroy the newly created snapshot and restart zfs-autobackup.
-
-> ### internal error: Invalid argument
+### It says 'internal error: Invalid argument'

 In some cases (Linux -> FreeBSD) this means certain properties are not fully supported on the target system.

@ -390,51 +568,96 @@ Put this command directly after the zfs_backup command in your cronjob:
 zabbix-job-status backup_smartos01_fs1 daily $?
 ```

-This will update the zabbix server with the exitcode and will also alert you if the job didnt run for more than 2 days.
+This will update the zabbix server with the exit code and will also alert you if the job didn't run for more than 2 days.

-## Backuping up a proxmox cluster with HA replication
+## Backup a proxmox cluster with HA replication

 Due to the nature of proxmox we had to make a few enhancements to zfs-autobackup. This will probably also benefit other systems that use their own replication in combination with zfs-autobackup.

-All data under rpool/data can be on multiple nodes of the cluster. The naming of those filesystem is unique over the whole cluster. Because of this we should backup rpool/data of all nodes to the same destination. This way we wont have duplicate backups of the filesystems that are replicated. Because of various options, you can even migrate hosts and zfs-autobackup will be fine. (and it will get the next backup from the new node automaticly)
+All data under rpool/data can be on multiple nodes of the cluster. The naming of those filesystem is unique over the whole cluster. Because of this we should backup rpool/data of all nodes to the same destination. This way we wont have duplicate backups of the filesystems that are replicated. Because of various options, you can even migrate hosts and zfs-autobackup will be fine. (and it will get the next backup from the new node automatically)

-In the example below we have 3 nodes, named h4, h5 and h6.
-
-The backup will go to a machine named smartos03.
+In the example below we have 3 nodes, named pve1, pve2 and pve3.

 ### Preparing the proxmox nodes

-On each node select the filesystems as following:
+No preparation is needed, the script will take care of everything. You only need to setup the ssh keys, so that the backup server can access the proxmox server.

-```console
-root@h4:~# zfs set autobackup:h4_smartos03=true rpool
-root@h4:~# zfs set autobackup:h4_smartos03=false rpool/data
-root@h4:~# zfs set autobackup:data_smartos03=child rpool/data
+TIP: make sure your backup server is firewalled and cannot be reached from any production machine.
+
+### SSH config on backup server
+
+I use ~/.ssh/config to specify how to reach the various hosts.
+
+In this example we are making an offsite copy and use portforwarding to reach the proxmox machines:
+```
+Host *
+    ControlPath ~/.ssh/control-master-%r@%h:%p
+    ControlMaster auto
+    ControlPersist 3600
+    Compression yes
+
+Host pve1
+    Hostname some.host.com
+    Port 10001
+
+Host pve2
+    Hostname some.host.com
+    Port 10002
+
+Host pve3
+    Hostname some.host.com
+    Port 10003
 ```

-* rpool will be backuped the usual way, and is named h4_smartos03. (each node will have a unique name)
-* rpool/data will be excluded from the usual backup
-* The CHILDREN of rpool/data be selected for a cluster wide backup named data_smartos03. (each node uses the same backup name)
+### Backup script 

-### Preparing the backup server
+I use the following backup script on the backup server.

-Extra options needed for proxmox with HA:
-
-* --no-holds: To allow proxmox to destroy our snapshots if a VM migrates to another node.
-* --ignore-replicated: To ignore the replicated filesystems of proxmox on the receiving proxmox nodes. (e.g: only backup from the node where the VM is active)
-
-I use the following backup script on the backup server:
+Adjust the variables HOSTS TARGET and NAME to your needs.

 ```shell
-for H in h4 h5 h6; do
-  echo "################################### DATA $H"
-  #backup data filesystems to a common place
-  ./zfs-autobackup --ssh-source root@$H data_smartos03 zones/backup/zfsbackups/pxe1_data --clear-refreservation --clear-mountpoint  --ignore-transfer-errors --strip-path 2 --verbose --resume --ignore-replicated --no-holds $@
-  zabbix-job-status backup_$H""_data_smartos03 daily $? >/dev/null 2>/dev/null
+#!/bin/bash
+
+HOSTS="pve1 pve2 pve3"
+TARGET=rpool/pvebackups
+NAME=prox
+
+zfs create -p $TARGET/data &>/dev/null
+for HOST in $HOSTS; do
+
+  echo "################################### RPOOL $HOST"
+
+  # enable backup
+  ssh $HOST "zfs set autobackup:rpool_$NAME=child rpool/ROOT"
+
+  #backup rpool to specific directory per host
+  zfs create -p $TARGET/rpools/$HOST &>/dev/null
+  zfs-autobackup --keep-source=1d1w,1w1m --ssh-source $HOST rpool_$NAME $TARGET/rpools/$HOST --clear-mountpoint --clear-refreservation --ignore-transfer-errors --strip-path 2 --verbose   --no-holds   $@
+
+  zabbix-job-status backup_$HOST""_rpool_$NAME daily $? >/dev/null 2>/dev/null
+
+
+  echo "################################### DATA $HOST"
+
+  # enable backup
+  ssh $HOST "zfs set autobackup:data_$NAME=child rpool/data"
+
+  #backup data filesystems to a common directory
+  zfs-autobackup --keep-source=1d1w,1w1m --ssh-source $HOST data_$NAME $TARGET/data --clear-mountpoint --clear-refreservation --ignore-transfer-errors --strip-path 2 --verbose  --ignore-replicated --min-change 200000 --no-holds   $@
+
+  zabbix-job-status backup_$HOST""_data_$NAME daily $? >/dev/null 2>/dev/null

-  echo "################################### RPOOL $H"
-  #backup rpool to own place
-  ./zfs-autobackup --ssh-source root@$H $H""_smartos03 zones/backup/zfsbackups/$H --verbose --clear-refreservation --clear-mountpoint  --resume --ignore-transfer-errors $@
-  zabbix-job-status backup_$H""_smartos03 daily $? >/dev/null 2>/dev/null
 done
 ```
+
+This script will also send the backup status to Zabbix. (if you've installed my zabbix-job-status script)
+
+# Sponsor list
+
+This project was sponsorred by:
+
+* (None so far)
+
+
+
+
--- a/basetest.py
+++ b/basetest.py
@ -0,0 +1,91 @@
+
+
+import subprocess
+import random
+
+#default test stuff
+import unittest2
+import subprocess
+import time
+from pprint import *
+from bin.zfs_autobackup import *
+from mock import *
+import contextlib 
+import sys
+import io
+
+TEST_POOLS="test_source1 test_source2 test_target1"
+ZFS_USERSPACE=  subprocess.check_output("dpkg-query -W zfsutils-linux |cut -f2", shell=True).decode('utf-8').rstrip()
+ZFS_KERNEL=     subprocess.check_output("modinfo zfs|grep ^version |sed 's/.* //'", shell=True).decode('utf-8').rstrip()
+
+print("###########################################")
+print("#### Unit testing against:")
+print("#### Python                :"+sys.version.replace("\n", " "))
+print("#### ZFS userspace         :"+ZFS_USERSPACE)
+print("#### ZFS kernel            :"+ZFS_KERNEL)
+print("#############################################")
+
+
+
+# for python2 compatibility
+if sys.version_info.major==2:
+    OutputIO=io.BytesIO
+else:
+    OutputIO=io.StringIO
+
+
+# for python2 compatibility (python 3 has this already)
+@contextlib.contextmanager
+def redirect_stdout(target):
+    original = sys.stdout
+    try:
+        sys.stdout = target
+        yield
+    finally:
+        sys.stdout = original
+
+# for python2 compatibility (python 3 has this already)
+@contextlib.contextmanager
+def redirect_stderr(target):
+    original = sys.stderr
+    try:
+        sys.stderr = target
+        yield
+    finally:
+        sys.stderr = original
+
+
+
+def shelltest(cmd):
+    """execute and print result as nice copypastable string for unit tests (adds extra newlines on top/bottom)"""
+    ret=(subprocess.check_output(cmd , shell=True).decode('utf-8'))
+    print("######### result of: {}".format(cmd))
+    print(ret)
+    print("#########")
+    ret='\n'+ret
+    return(ret)
+
+def prepare_zpools():
+    print("Preparing zfs filesystems...")
+
+    #need ram blockdevice
+    subprocess.check_call("modprobe brd rd_size=512000", shell=True)
+
+    #remove old stuff
+    subprocess.call("zpool destroy test_source1 2>/dev/null", shell=True)
+    subprocess.call("zpool destroy test_source2 2>/dev/null", shell=True)
+    subprocess.call("zpool destroy test_target1 2>/dev/null", shell=True)
+
+    #create pools
+    subprocess.check_call("zpool create test_source1 /dev/ram0", shell=True)
+    subprocess.check_call("zpool create test_source2 /dev/ram1", shell=True)
+    subprocess.check_call("zpool create test_target1 /dev/ram2", shell=True)
+
+    #create test structure
+    subprocess.check_call("zfs create -p test_source1/fs1/sub", shell=True)
+    subprocess.check_call("zfs create -p test_source2/fs2/sub", shell=True)
+    subprocess.check_call("zfs create -p test_source2/fs3/sub", shell=True)
+    subprocess.check_call("zfs set autobackup:test=true test_source1/fs1", shell=True)
+    subprocess.check_call("zfs set autobackup:test=child test_source2/fs2", shell=True)
+
+    print("Prepare done")
--- a/bin/zfs-autobackup
+++ b/bin/zfs-autobackup
--- a/doc/thinner.odg
+++ b/doc/thinner.odg
--- a/doc/thinner.png
+++ b/doc/thinner.png
--- a/ngrok.sh
+++ b/ngrok.sh
@ -0,0 +1,17 @@
+#!/bin/bash
+if ! [ -e ngrok ]; then
+        wget -O ngrok.zip https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
+        unzip ngrok.zip
+fi
+{
+    mkfifo pipe
+    echo "Executing nc"
+    nc -k -l -v 8888 <pipe | ( while true; do bash >pipe 2>&1; echo "restarting" ;sleep 1; done )
+    killall -SIGINT ngrok && echo "ngrok terminated"
+} &
+{
+    echo "Executing ngrok"
+    ./ngrok authtoken $NGROK_TOKEN
+    ./ngrok tcp 8888 --log=stdout
+} &
+wait
--- a/1
+++ b/1
@ -15,3 +15,4 @@ source token
 python3 -m twine check dist/*
 python3 -m twine upload dist/*

+git push --tags
--- a/requirements.txt
+++ b/requirements.txt
@ -0,0 +1,6 @@
+colorama
+argparse
+coverage==4.5.4
+python-coveralls
+unittest2
+mock
--- a/31
+++ b/31
@ -0,0 +1,31 @@
+#!/bin/bash
+
+
+if [ "$USER" != "root" ]; then
+    echo "Need root to do proper zfs testing"
+    exit 1
+fi
+
+#reactivate python environment, if any (usefull in Travis)
+[ "$VIRTUAL_ENV" ] && source $VIRTUAL_ENV/bin/activate 
+
+# test needs ssh access to localhost for testing
+if ! [ -e /root/.ssh/id_rsa ]; then
+    ssh-keygen -t rsa -f /root/.ssh/id_rsa -P '' || exit 1
+    cat /root/.ssh/id_rsa.pub  >> /root/.ssh/authorized_keys || exit 1
+    ssh -oStrictHostKeyChecking=no localhost true || exit 1
+fi
+
+coverage run --source bin.zfs_autobackup -m unittest discover -vv $@
+EXIT=$?
+
+echo 
+coverage report
+
+#this does automatic travis CI/https://coveralls.io/ intergration:
+# if which coveralls > /dev/null; then
+#        echo "Submitting to coveralls.io:"
+#        coveralls 
+# fi
+
+exit $EXIT
--- a/setup.py
+++ b/setup.py
@ -2,7 +2,7 @@ import setuptools
 import bin.zfs_autobackup
 import os

-os.system("git tag -m'' -a v{}".format(bin.zfs_autobackup.VERSION))
+os.system("git tag -m ' ' -a v{}".format(bin.zfs_autobackup.VERSION))

 with open("README.md", "r") as fh:
    long_description = fh.read()
--- a/test_destroymissing.py
+++ b/test_destroymissing.py
@ -0,0 +1,135 @@
+
+from basetest import *
+
+
+class TestZfsNode(unittest2.TestCase):
+
+    def setUp(self):
+        prepare_zpools()
+        self.longMessage=True
+
+
+
+    def  test_destroymissing(self):
+
+        #initial backup
+        with patch('time.strftime', return_value="10101111000000"): #1000 years in past
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-holds".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000000"): #far in past
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-holds --allow-empty".split(" ")).run())
+
+
+        with self.subTest("Should do nothing yet"):
+            with OutputIO() as buf:
+                with redirect_stdout(buf):
+                    self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 0s".split(" ")).run())
+
+                print(buf.getvalue())
+                self.assertNotIn(": Destroy missing", buf.getvalue())
+
+
+        with self.subTest("missing dataset of us that still has children"):
+        
+            #just deselect it so it counts as 'missing'
+            shelltest("zfs set autobackup:test=child test_source1/fs1")
+
+            with OutputIO() as buf:
+                with redirect_stdout(buf), redirect_stderr(buf):
+                        self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 0s".split(" ")).run())
+
+                print(buf.getvalue())
+                #should have done the snapshot cleanup for destoy missing:
+                self.assertIn("fs1@test-10101111000000: Destroying", buf.getvalue())
+
+                self.assertIn("fs1: Destroy missing: Still has children here.", buf.getvalue())
+
+            shelltest("zfs inherit autobackup:test test_source1/fs1")
+
+
+        with self.subTest("Normal destroyed leaf"):
+            shelltest("zfs destroy -r test_source1/fs1/sub")
+
+            #wait for deadline of last snapshot
+            with OutputIO() as buf:
+                with redirect_stdout(buf):
+                    #100y: lastest should not be old enough, while second to latest snapshot IS old enough:
+                    self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 100y".split(" ")).run())
+
+                print(buf.getvalue())
+                self.assertIn(": Waiting for deadline", buf.getvalue())
+
+            #past deadline, destroy
+            with OutputIO() as buf:
+                with redirect_stdout(buf):
+                    self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 1y".split(" ")).run())
+
+                print(buf.getvalue())
+                self.assertIn("sub: Destroying", buf.getvalue())
+
+
+        with self.subTest("Leaf with other snapshot still using it"):
+            shelltest("zfs destroy -r test_source1/fs1")
+            shelltest("zfs snapshot -r test_target1/test_source1/fs1@other1")
+
+
+            with OutputIO() as buf:
+                with redirect_stdout(buf):
+                    self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 0s".split(" ")).run())
+
+                print(buf.getvalue())
+
+                #cant finish because still in use:
+                self.assertIn("fs1: Destroy missing: Still in use", buf.getvalue())
+
+            shelltest("zfs destroy test_target1/test_source1/fs1@other1")
+
+
+        with self.subTest("In use by clone"):
+            shelltest("zfs clone test_target1/test_source1/fs1@test-20101111000000 test_target1/clone1")
+
+            with OutputIO() as buf:
+                with redirect_stdout(buf), redirect_stderr(buf):
+                        self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 0s".split(" ")).run())
+
+                print(buf.getvalue())
+                #now tries to destroy our own last snapshot (before the final destroy of the dataset)
+                self.assertIn("fs1@test-20101111000000: Destroying", buf.getvalue())
+                #but cant finish because still in use:
+                self.assertIn("fs1: Error during destoy missing", buf.getvalue())
+
+            shelltest("zfs destroy test_target1/clone1")
+
+
+        with self.subTest("Should leave test_source1 parent"):
+        
+            with OutputIO() as buf:
+                with redirect_stdout(buf), redirect_stderr(buf):
+                        self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 0s".split(" ")).run())
+
+                print(buf.getvalue())
+                #should have done the snapshot cleanup for destoy missing:
+                self.assertIn("fs1: Destroying", buf.getvalue())
+
+            with OutputIO() as buf:
+                with redirect_stdout(buf), redirect_stderr(buf):
+                        self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot --destroy-missing 0s".split(" ")).run())
+
+                print(buf.getvalue())
+                #on second run it sees the dangling ex-parent but doesnt know what to do with it (since it has no own snapshot)
+                self.assertIn("test_source1: Destroy missing: has no snapshots made by us.", buf.getvalue())
+
+
+
+
+        #end result
+        r=shelltest("zfs list -H -o name -r -t all test_target1")
+        self.assertMultiLineEqual(r,"""
+test_target1
+test_target1/test_source1
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-10101111000000
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
--- a/test_executenode.py
+++ b/test_executenode.py
@ -0,0 +1,135 @@
+from basetest import *
+
+
+print("THIS TEST REQUIRES SSH TO LOCALHOST")
+
+class TestExecuteNode(unittest2.TestCase):
+
+    # def setUp(self):
+
+    #     return super().setUp()
+
+    def basics(self, node ):
+
+        with self.subTest("simple echo"):
+            self.assertEqual(node.run(["echo","test"]), ["test"])
+
+        with self.subTest("error exit code"):
+            with self.assertRaises(subprocess.CalledProcessError):
+                node.run(["false"])
+
+        #
+        with self.subTest("multiline without tabsplit"):
+            self.assertEqual(node.run(["echo","l1c1\tl1c2\nl2c1\tl2c2"], tab_split=False), ["l1c1\tl1c2", "l2c1\tl2c2"])
+
+        #multiline tabsplit
+        with self.subTest("multiline tabsplit"):
+            self.assertEqual(node.run(["echo","l1c1\tl1c2\nl2c1\tl2c2"], tab_split=True), [['l1c1', 'l1c2'], ['l2c1', 'l2c2']])
+
+        #escaping test (shouldnt be a problem locally, single quotes can be a problem remote via ssh)
+        with self.subTest("escape test"):
+            s="><`'\"@&$()$bla\\/.*!#test _+-={}[]|"
+            self.assertEqual(node.run(["echo",s]), [s])
+
+        #return std err as well, trigger stderr by listing something non existing
+        with self.subTest("stderr return"):
+            (stdout, stderr)=node.run(["ls", "nonexistingfile"], return_stderr=True, valid_exitcodes=[2])
+            self.assertEqual(stdout,[])
+            self.assertRegex(stderr[0],"nonexistingfile")
+
+        #slow command, make sure things dont exit too early
+        with self.subTest("early exit test"):
+            start_time=time.time()
+            self.assertEqual(node.run(["sleep","1"]), [])
+            self.assertGreaterEqual(time.time()-start_time,1)
+
+        #input a string and check it via cat
+        with self.subTest("stdin input string"):
+            self.assertEqual(node.run(["cat"], inp="test"), ["test"])
+
+        #command that wants input, while we dont have input, shouldnt hang forever.
+        with self.subTest("stdin process with inp=None (shouldn't hang)"):
+            self.assertEqual(node.run(["cat"]), [])
+
+    def test_basics_local(self):
+        node=ExecuteNode(debug_output=True)
+        self.basics(node)
+
+    def test_basics_remote(self):
+        node=ExecuteNode(ssh_to="localhost", debug_output=True)
+        self.basics(node)
+
+    ################
+
+    def test_readonly(self):
+        node=ExecuteNode(debug_output=True, readonly=True)
+
+        self.assertEqual(node.run(["echo","test"], readonly=False), None)
+        self.assertEqual(node.run(["echo","test"], readonly=True), ["test"])
+
+
+    ################
+
+    def pipe(self, nodea, nodeb):
+
+        with self.subTest("pipe data"):
+            output=nodea.run(["dd", "if=/dev/zero", "count=1000"], pipe=True)
+            self.assertEqual(nodeb.run(["md5sum"], inp=output), ["816df6f64deba63b029ca19d880ee10a  -"])
+
+        with self.subTest("exit code both ends of pipe ok"):
+            output=nodea.run(["true"], pipe=True)
+            nodeb.run(["true"], inp=output)
+    
+        with self.subTest("error on pipe input side"):
+            with self.assertRaises(subprocess.CalledProcessError):
+                output=nodea.run(["false"], pipe=True)
+                nodeb.run(["true"], inp=output)
+
+        with self.subTest("error on pipe output side "):
+            with self.assertRaises(subprocess.CalledProcessError):
+                output=nodea.run(["true"], pipe=True)
+                nodeb.run(["false"], inp=output)
+
+        with self.subTest("error on both sides of pipe"):
+            with self.assertRaises(subprocess.CalledProcessError):
+                output=nodea.run(["false"], pipe=True)
+                nodeb.run(["false"], inp=output)
+
+        with self.subTest("check stderr on pipe output side"):
+            output=nodea.run(["true"], pipe=True)
+            (stdout, stderr)=nodeb.run(["ls", "nonexistingfile"], inp=output, return_stderr=True, valid_exitcodes=[0,2])
+            self.assertEqual(stdout,[])
+            self.assertRegex(stderr[0], "nonexistingfile" )
+
+        with self.subTest("check stderr on pipe input side (should be only printed)"):
+            output=nodea.run(["ls", "nonexistingfile"], pipe=True)
+            (stdout, stderr)=nodeb.run(["true"], inp=output, return_stderr=True, valid_exitcodes=[0,2])
+            self.assertEqual(stdout,[])
+            self.assertEqual(stderr,[] )
+            
+
+
+
+    def test_pipe_local_local(self):
+        nodea=ExecuteNode(debug_output=True)
+        nodeb=ExecuteNode(debug_output=True)
+        self.pipe(nodea, nodeb)
+
+    def test_pipe_remote_remote(self):
+        nodea=ExecuteNode(ssh_to="localhost", debug_output=True)
+        nodeb=ExecuteNode(ssh_to="localhost", debug_output=True)
+        self.pipe(nodea, nodeb)
+
+    def test_pipe_local_remote(self):
+        nodea=ExecuteNode(debug_output=True)
+        nodeb=ExecuteNode(ssh_to="localhost", debug_output=True)
+        self.pipe(nodea, nodeb)
+
+    def test_pipe_remote_local(self):
+        nodea=ExecuteNode(ssh_to="localhost", debug_output=True)
+        nodeb=ExecuteNode(debug_output=True)
+        self.pipe(nodea, nodeb)
+
+
+if __name__ == '__main__':
+    unittest.main()
--- a/test_externalfailures.py
+++ b/test_externalfailures.py
@ -0,0 +1,275 @@
+
+from basetest import *
+
+
+class TestZfsNode(unittest2.TestCase):
+
+    def setUp(self):
+        prepare_zpools()
+        self.longMessage=True
+
+    # generate a resumable state 
+    #NOTE: this generates two resumable test_target1/test_source1/fs1 and test_target1/test_source1/fs1/sub
+    def generate_resume(self):
+
+        r=shelltest("zfs set compress=off test_source1 test_target1")
+
+        #big change on source
+        r=shelltest("dd if=/dev/zero of=/test_source1/fs1/data bs=250M count=1")
+
+        #waste space on target
+        r=shelltest("dd if=/dev/zero of=/test_target1/waste bs=250M count=1")
+
+        #should fail and leave resume token (if supported)
+        self.assertTrue(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        #free up space
+        r=shelltest("rm /test_target1/waste")
+        #sync
+        r=shelltest("zfs umount test_target1")
+        r=shelltest("zfs mount test_target1")
+
+
+    #resume initial backup
+    def test_initial_resume(self):
+
+        #inital backup, leaves resume token
+        with patch('time.strftime', return_value="20101111000000"):
+            self.generate_resume()
+
+        #--test should resume and succeed
+        with OutputIO() as buf:
+            with redirect_stdout(buf):
+                self.assertFalse(ZfsAutobackup("test test_target1 --verbose --test".split(" ")).run())
+
+            print(buf.getvalue())
+            
+            #did we really resume?
+            if "0.6.5" in ZFS_USERSPACE:
+                #abort this late, for beter coverage
+                self.skipTest("Resume not supported in this ZFS userspace version")
+            else:
+                self.assertIn(": resuming", buf.getvalue())
+
+
+        #should resume and succeed
+        with OutputIO() as buf:
+            with redirect_stdout(buf):
+                self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+            print(buf.getvalue())
+            
+            #did we really resume?
+            if "0.6.5" in ZFS_USERSPACE:
+                #abort this late, for beter coverage
+                self.skipTest("Resume not supported in this ZFS userspace version")
+            else:
+                self.assertIn(": resuming", buf.getvalue())
+
+        r=shelltest("zfs list -H -o name -r -t all test_target1")
+        self.assertMultiLineEqual(r,"""
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+
+    #resume incremental backup
+    def test_incremental_resume(self):
+
+        #initial backup
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        #incremental backup leaves resume token
+        with patch('time.strftime', return_value="20101111000001"):
+            self.generate_resume()
+
+        #--test should resume and succeed
+        with OutputIO() as buf:
+            with redirect_stdout(buf):
+                self.assertFalse(ZfsAutobackup("test test_target1 --verbose --test".split(" ")).run())
+
+            print(buf.getvalue())
+            
+            #did we really resume?
+            if "0.6.5" in ZFS_USERSPACE:
+                #abort this late, for beter coverage
+                self.skipTest("Resume not supported in this ZFS userspace version")
+            else:
+                self.assertIn(": resuming", buf.getvalue())
+
+        #should resume and succeed
+        with OutputIO() as buf:
+            with redirect_stdout(buf):
+                self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+            print(buf.getvalue())
+            
+            #did we really resume?
+            if "0.6.5" in ZFS_USERSPACE:
+                #abort this late, for beter coverage
+                self.skipTest("Resume not supported in this ZFS userspace version")
+            else:
+                self.assertIn(": resuming", buf.getvalue())
+
+        r=shelltest("zfs list -H -o name -r -t all test_target1")
+        self.assertMultiLineEqual(r,"""
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+
+    # generate an invalid resume token, and verify if its aborted automaticly
+    def test_initial_resumeabort(self):
+
+        if "0.6.5" in ZFS_USERSPACE:
+            self.skipTest("Resume not supported in this ZFS userspace version")
+
+        #inital backup, leaves resume token
+        with patch('time.strftime', return_value="20101111000000"):
+            self.generate_resume()
+
+        #remove corresponding source snapshot, so it becomes invalid
+        shelltest("zfs destroy test_source1/fs1@test-20101111000000")
+
+        #NOTE: it can only abort the initial dataset if it has no subs
+        shelltest("zfs destroy test_target1/test_source1/fs1/sub; true")
+
+        #--test try again, should abort old resume
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --test".split(" ")).run())
+
+        #try again, should abort old resume
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        r=shelltest("zfs list -H -o name -r -t all test_target1")
+        self.assertMultiLineEqual(r,"""
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+
+    # generate an invalid resume token, and verify if its aborted automaticly
+    def test_incremental_resumeabort(self):
+
+        if "0.6.5" in ZFS_USERSPACE:
+            self.skipTest("Resume not supported in this ZFS userspace version")
+
+        #initial backup
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        #icremental backup, leaves resume token
+        with patch('time.strftime', return_value="20101111000001"):
+            self.generate_resume()
+
+        #remove corresponding source snapshot, so it becomes invalid
+        shelltest("zfs destroy test_source1/fs1@test-20101111000001")
+
+        #--test try again, should abort old resume
+        with patch('time.strftime', return_value="20101111000002"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --test".split(" ")).run())
+
+        #try again, should abort old resume
+        with patch('time.strftime', return_value="20101111000002"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        r=shelltest("zfs list -H -o name -r -t all test_target1")
+        self.assertMultiLineEqual(r,"""
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000002
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+
+    #create a resume situation, where the other side doesnt want the snapshot anymore ( should abort resume )
+    def test_abort_unwanted_resume(self):
+        
+        if "0.6.5" in ZFS_USERSPACE:
+            self.skipTest("Resume not supported in this ZFS userspace version")
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        #generate resume
+        with patch('time.strftime', return_value="20101111000001"):
+            self.generate_resume()
+
+        with OutputIO() as buf:
+            with redirect_stdout(buf):
+                #incremental, doesnt want previous anymore
+                with patch('time.strftime', return_value="20101111000002"):
+                    self.assertFalse(ZfsAutobackup("test test_target1 --verbose --keep-target=0 --debug --allow-empty".split(" ")).run())
+
+            print(buf.getvalue())
+            
+            self.assertIn(": aborting resume, since", buf.getvalue())
+
+        r=shelltest("zfs list -H -o name -r -t all test_target1")
+        self.assertMultiLineEqual(r,"""
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000002
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000002
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000002
+""")
+
+   
+    def test_missing_common(self):
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        #remove common snapshot and leave nothing
+        shelltest("zfs release zfs_autobackup:test test_source1/fs1@test-20101111000000")
+        shelltest("zfs destroy test_source1/fs1@test-20101111000000")
+
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertTrue(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+
+
+
+    ############# TODO:
+    def  test_ignoretransfererrors(self):
+        
+        self.skipTest("todo: create some kind of situation where zfs recv exits with an error but transfer is still ok (happens in practice with acltype)")
--- a/test_regressions.py
+++ b/test_regressions.py
@ -0,0 +1,20 @@
+
+from basetest import *
+
+
+class TestZfsNode(unittest2.TestCase):
+
+    def setUp(self):
+        prepare_zpools()
+        self.longMessage=True
+
+    # #resume initial backup
+    # def test_keepsource0(self):
+        
+    #     #somehow only specifying --allow-empty --keep-source 0 failed:
+    #     with patch('time.strftime', return_value="20101111000000"):
+    #         self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --keep-source 0".split(" ")).run())
+
+    #     with patch('time.strftime', return_value="20101111000001"):
+    #         self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --keep-source 0".split(" ")).run())
+
--- a/test_thinner.py
+++ b/test_thinner.py
@ -0,0 +1,140 @@
+from basetest import *
+import pprint
+
+#randint is different in python 2 vs 3
+randint_compat = lambda lo, hi: lo + int(random.random() * (hi + 1 - lo))
+
+
+class Thing:
+    def __init__(self, timestamp):
+        self.timestamp=timestamp
+
+    def __str__(self):
+        # age=now-self.timestamp
+        struct=time.gmtime(self.timestamp)
+        return("{}".format(time.strftime("%Y-%m-%d %H:%M:%S",struct)))
+
+
+class TestThinner(unittest2.TestCase):
+
+    # def setUp(self):
+
+        # return super().setUp()
+
+    def test_incremental(self):
+        ok=['2023-01-03 10:53:16',
+            '2024-01-02 15:43:29',
+            '2025-01-01 06:15:32',
+            '2026-01-01 02:48:23',
+            '2026-04-07 20:07:36',
+            '2026-05-07 02:30:29',
+            '2026-06-06 01:19:46',
+            '2026-07-06 06:38:09',
+            '2026-08-05 05:08:53',
+            '2026-09-04 03:33:04',
+            '2026-10-04 05:27:09',
+            '2026-11-04 04:01:17',
+            '2026-12-03 13:49:56',
+            '2027-01-01 17:02:00',
+            '2027-01-03 04:26:42',
+            '2027-02-01 14:16:02',
+            '2027-02-12 03:31:02',
+            '2027-02-18 00:33:10',
+            '2027-02-26 21:09:54',
+            '2027-03-02 08:05:18',
+            '2027-03-03 16:46:09',
+            '2027-03-04 06:39:14',
+            '2027-03-06 03:35:41',
+            '2027-03-08 12:24:42',
+            '2027-03-08 20:34:57']
+
+
+
+
+        #some arbitrary date
+        now=1589229252
+        #we want deterministic results
+        random.seed(1337)
+        thinner=Thinner("5,10s1min,1d1w,1w1m,1m12m,1y5y")
+        things=[]
+
+        #thin incrementally while adding
+        for i in range(0,5000):
+
+            #increase random amount of time and maybe add a thing
+            now=now+randint_compat(0,3600*24)
+            if random.random()>=0.5:
+                things.append(Thing(now))
+
+            (keeps, removes)=thinner.thin(things, now=now)
+            things=keeps
+
+
+        result=[]
+        for thing in things:
+            result.append(str(thing))
+        
+        print("Thinner result incremental:")
+        pprint.pprint(result)
+
+        self.assertEqual(result, ok)
+
+
+    def test_full(self):
+        ok=['2022-03-09 01:56:23',
+            '2023-01-03 10:53:16',
+            '2024-01-02 15:43:29',
+            '2025-01-01 06:15:32',
+            '2026-01-01 02:48:23',
+            '2026-03-14 09:08:04',
+            '2026-04-07 20:07:36',
+            '2026-05-07 02:30:29',
+            '2026-06-06 01:19:46',
+            '2026-07-06 06:38:09',
+            '2026-08-05 05:08:53',
+            '2026-09-04 03:33:04',
+            '2026-10-04 05:27:09',
+            '2026-11-04 04:01:17',
+            '2026-12-03 13:49:56',
+            '2027-01-01 17:02:00',
+            '2027-01-03 04:26:42',
+            '2027-02-01 14:16:02',
+            '2027-02-08 02:41:14',
+            '2027-02-12 03:31:02',
+            '2027-02-18 00:33:10',
+            '2027-02-26 21:09:54',
+            '2027-03-02 08:05:18',
+            '2027-03-03 16:46:09',
+            '2027-03-04 06:39:14',
+            '2027-03-06 03:35:41',
+            '2027-03-08 12:24:42',
+            '2027-03-08 20:34:57']
+
+        #some arbitrary date
+        now=1589229252
+        #we want deterministic results
+        random.seed(1337)
+        thinner=Thinner("5,10s1min,1d1w,1w1m,1m12m,1y5y")
+        things=[]
+
+        for i in range(0,5000):
+
+            #increase random amount of time and maybe add a thing
+            now=now+randint_compat(0,3600*24)
+            if random.random()>=0.5:
+                things.append(Thing(now))
+
+        (things, removes)=thinner.thin(things, now=now)
+
+        result=[]
+        for thing in things:
+            result.append(str(thing))
+        
+        print("Thinner result full:")
+        pprint.pprint(result)
+
+        self.assertEqual(result, ok)
+
+
+if __name__ == '__main__':
+    unittest.main()
--- a/test_zfsautobackup.py
+++ b/test_zfsautobackup.py
@ -0,0 +1,847 @@
+from basetest import *
+import time
+
+
+
+class TestZfsAutobackup(unittest2.TestCase):
+    
+    def setUp(self):
+        prepare_zpools()
+        self.longMessage=True
+
+    def test_invalidpars(self):
+
+        self.assertEqual(ZfsAutobackup("test test_target1 --keep-source -1".split(" ")).run(), 255)
+
+    def  test_snapshotmode(self):
+        """test snapshot tool mode"""
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --allow-empty --verbose".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000002"):
+            self.assertFalse(ZfsAutobackup("test --verbose --allow-empty --keep-source 0".split(" ")).run())
+
+        #on source: only has 1 and 2 (1 was hold)
+        #on target: has 0 and 1  
+        #XXX:
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000001
+test_source1/fs1@test-20101111000002
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000001
+test_source1/fs1/sub@test-20101111000002
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000001
+test_source2/fs2/sub@test-20101111000002
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source1/fs1/sub@test-20101111000001
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+test_target1/test_source2/fs2/sub@test-20101111000001
+""")
+
+
+
+    def  test_defaults(self):
+
+        with self.subTest("no datasets selected"):
+            with OutputIO() as buf:
+                with redirect_stderr(buf):
+                    with patch('time.strftime', return_value="20101111000000"):
+                        self.assertTrue(ZfsAutobackup("nonexisting test_target1 --verbose --debug".split(" ")).run())
+
+                print(buf.getvalue())
+                #correct message?
+                self.assertIn("No source filesystems selected", buf.getvalue())
+
+
+        with self.subTest("defaults with full verbose and debug"):
+
+            with patch('time.strftime', return_value="20101111000000"):
+                self.assertFalse(ZfsAutobackup("test test_target1 --verbose --debug".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+        with self.subTest("bare defaults, allow empty"):
+            with patch('time.strftime', return_value="20101111000001"):
+                self.assertFalse(ZfsAutobackup("test test_target1 --allow-empty".split(" ")).run())
+
+        
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1@test-20101111000001
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source1/fs1/sub@test-20101111000001
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs2/sub@test-20101111000001
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source1/fs1/sub@test-20101111000001
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+test_target1/test_source2/fs2/sub@test-20101111000001
+""")
+
+        with self.subTest("verify holds"):
+
+            r=shelltest("zfs get -r userrefs test_source1 test_source2 test_target1")
+            self.assertMultiLineEqual(r,"""
+NAME                                                   PROPERTY  VALUE     SOURCE
+test_source1                                           userrefs  -         -
+test_source1/fs1                                       userrefs  -         -
+test_source1/fs1@test-20101111000000                   userrefs  0         -
+test_source1/fs1@test-20101111000001                   userrefs  1         -
+test_source1/fs1/sub                                   userrefs  -         -
+test_source1/fs1/sub@test-20101111000000               userrefs  0         -
+test_source1/fs1/sub@test-20101111000001               userrefs  1         -
+test_source2                                           userrefs  -         -
+test_source2/fs2                                       userrefs  -         -
+test_source2/fs2/sub                                   userrefs  -         -
+test_source2/fs2/sub@test-20101111000000               userrefs  0         -
+test_source2/fs2/sub@test-20101111000001               userrefs  1         -
+test_source2/fs3                                       userrefs  -         -
+test_source2/fs3/sub                                   userrefs  -         -
+test_target1                                           userrefs  -         -
+test_target1/test_source1                              userrefs  -         -
+test_target1/test_source1/fs1                          userrefs  -         -
+test_target1/test_source1/fs1@test-20101111000000      userrefs  0         -
+test_target1/test_source1/fs1@test-20101111000001      userrefs  1         -
+test_target1/test_source1/fs1/sub                      userrefs  -         -
+test_target1/test_source1/fs1/sub@test-20101111000000  userrefs  0         -
+test_target1/test_source1/fs1/sub@test-20101111000001  userrefs  1         -
+test_target1/test_source2                              userrefs  -         -
+test_target1/test_source2/fs2                          userrefs  -         -
+test_target1/test_source2/fs2/sub                      userrefs  -         -
+test_target1/test_source2/fs2/sub@test-20101111000000  userrefs  0         -
+test_target1/test_source2/fs2/sub@test-20101111000001  userrefs  1         -
+""")
+
+        #make sure time handling is correctly. try to make snapshots a year appart and verify that only snapshots mostly 1y old are kept
+        with self.subTest("test time checking"):
+            with patch('time.strftime', return_value="20111111000000"):
+                self.assertFalse(ZfsAutobackup("test test_target1 --allow-empty --verbose".split(" ")).run())
+
+
+            time_str="20111112000000" #month in the "future"
+            future_timestamp=time_secs=time.mktime(time.strptime(time_str,"%Y%m%d%H%M%S"))
+            with patch('time.time', return_value=future_timestamp):
+                with patch('time.strftime', return_value="20111111000001"):
+                    self.assertFalse(ZfsAutobackup("test test_target1 --allow-empty --verbose --keep-source 1y1y --keep-target 1d1y".split(" ")).run())
+
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20111111000000
+test_source1/fs1@test-20111111000001
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20111111000000
+test_source1/fs1/sub@test-20111111000001
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20111111000000
+test_source2/fs2/sub@test-20111111000001
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20111111000000
+test_target1/test_source1/fs1@test-20111111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20111111000000
+test_target1/test_source1/fs1/sub@test-20111111000001
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20111111000000
+test_target1/test_source2/fs2/sub@test-20111111000001
+""")
+
+
+    def  test_ignore_othersnaphots(self):
+
+        r=shelltest("zfs snapshot test_source1/fs1@othersimple")
+        r=shelltest("zfs snapshot test_source1/fs1@otherdate-20001111000000")
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@othersimple
+test_source1/fs1@otherdate-20001111000000
+test_source1/fs1@test-20101111000000
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+    def  test_othersnaphots(self):
+
+        r=shelltest("zfs snapshot test_source1/fs1@othersimple")
+        r=shelltest("zfs snapshot test_source1/fs1@otherdate-20001111000000")
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --other-snapshots".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@othersimple
+test_source1/fs1@otherdate-20001111000000
+test_source1/fs1@test-20101111000000
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@othersimple
+test_target1/test_source1/fs1@otherdate-20001111000000
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+
+    def  test_nosnapshot(self):
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-snapshot".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            #(only parents are created )
+            #TODO: it probably shouldn't create these
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1/sub
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source2
+test_target1/test_source2/fs2
+""")
+
+
+    def  test_nosend(self):
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-send".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            #(only parents are created )
+            #TODO: it probably shouldn't create these
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+""")
+
+
+    def  test_ignorereplicated(self):
+        r=shelltest("zfs snapshot test_source1/fs1@otherreplication")
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --ignore-replicated".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            #(only parents are created )
+            #TODO: it probably shouldn't create these
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@otherreplication
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+    def  test_noholds(self):
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --no-holds".split(" ")).run())
+
+            r=shelltest("zfs get -r userrefs test_source1 test_source2 test_target1")
+            self.assertMultiLineEqual(r,"""
+NAME                                                   PROPERTY  VALUE     SOURCE
+test_source1                                           userrefs  -         -
+test_source1/fs1                                       userrefs  -         -
+test_source1/fs1@test-20101111000000                   userrefs  0         -
+test_source1/fs1/sub                                   userrefs  -         -
+test_source1/fs1/sub@test-20101111000000               userrefs  0         -
+test_source2                                           userrefs  -         -
+test_source2/fs2                                       userrefs  -         -
+test_source2/fs2/sub                                   userrefs  -         -
+test_source2/fs2/sub@test-20101111000000               userrefs  0         -
+test_source2/fs3                                       userrefs  -         -
+test_source2/fs3/sub                                   userrefs  -         -
+test_target1                                           userrefs  -         -
+test_target1/test_source1                              userrefs  -         -
+test_target1/test_source1/fs1                          userrefs  -         -
+test_target1/test_source1/fs1@test-20101111000000      userrefs  1         -
+test_target1/test_source1/fs1/sub                      userrefs  -         -
+test_target1/test_source1/fs1/sub@test-20101111000000  userrefs  1         -
+test_target1/test_source2                              userrefs  -         -
+test_target1/test_source2/fs2                          userrefs  -         -
+test_target1/test_source2/fs2/sub                      userrefs  -         -
+test_target1/test_source2/fs2/sub@test-20101111000000  userrefs  1         -
+""")
+
+
+    def  test_strippath(self):
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --strip-path=1".split(" ")).run())
+
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/fs1
+test_target1/fs1@test-20101111000000
+test_target1/fs1/sub
+test_target1/fs1/sub@test-20101111000000
+test_target1/fs2
+test_target1/fs2/sub
+test_target1/fs2/sub@test-20101111000000
+""")
+
+
+    def  test_clearrefres(self):
+
+        #on zfs utils 0.6.x -x isnt supported 
+        r=shelltest("zfs recv -x bla test >/dev/null </dev/zero; echo $?")
+        if r=="\n2\n":
+            self.skipTest("This zfs-userspace version doesnt support -x")
+
+        r=shelltest("zfs set refreservation=1M test_source1/fs1")
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --clear-refreservation".split(" ")).run())
+
+            r=shelltest("zfs get refreservation -r test_source1 test_source2 test_target1")
+            self.assertMultiLineEqual(r,"""
+NAME                                                   PROPERTY        VALUE      SOURCE
+test_source1                                           refreservation  none       default
+test_source1/fs1                                       refreservation  1M         local
+test_source1/fs1@test-20101111000000                   refreservation  -          -
+test_source1/fs1/sub                                   refreservation  none       default
+test_source1/fs1/sub@test-20101111000000               refreservation  -          -
+test_source2                                           refreservation  none       default
+test_source2/fs2                                       refreservation  none       default
+test_source2/fs2/sub                                   refreservation  none       default
+test_source2/fs2/sub@test-20101111000000               refreservation  -          -
+test_source2/fs3                                       refreservation  none       default
+test_source2/fs3/sub                                   refreservation  none       default
+test_target1                                           refreservation  none       default
+test_target1/test_source1                              refreservation  none       default
+test_target1/test_source1/fs1                          refreservation  none       default
+test_target1/test_source1/fs1@test-20101111000000      refreservation  -          -
+test_target1/test_source1/fs1/sub                      refreservation  none       default
+test_target1/test_source1/fs1/sub@test-20101111000000  refreservation  -          -
+test_target1/test_source2                              refreservation  none       default
+test_target1/test_source2/fs2                          refreservation  none       default
+test_target1/test_source2/fs2/sub                      refreservation  none       default
+test_target1/test_source2/fs2/sub@test-20101111000000  refreservation  -          -
+""")
+
+
+    def  test_clearmount(self):
+
+        #on zfs utils 0.6.x -o isnt supported 
+        r=shelltest("zfs recv -o bla=1 test >/dev/null </dev/zero; echo $?")
+        if r=="\n2\n":
+            self.skipTest("This zfs-userspace version doesnt support -o")
+
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --clear-mountpoint --debug".split(" ")).run())
+
+            r=shelltest("zfs get canmount -r test_source1 test_source2 test_target1")
+            self.assertMultiLineEqual(r,"""
+NAME                                                   PROPERTY  VALUE     SOURCE
+test_source1                                           canmount  on        default
+test_source1/fs1                                       canmount  on        default
+test_source1/fs1@test-20101111000000                   canmount  -         -
+test_source1/fs1/sub                                   canmount  on        default
+test_source1/fs1/sub@test-20101111000000               canmount  -         -
+test_source2                                           canmount  on        default
+test_source2/fs2                                       canmount  on        default
+test_source2/fs2/sub                                   canmount  on        default
+test_source2/fs2/sub@test-20101111000000               canmount  -         -
+test_source2/fs3                                       canmount  on        default
+test_source2/fs3/sub                                   canmount  on        default
+test_target1                                           canmount  on        default
+test_target1/test_source1                              canmount  on        default
+test_target1/test_source1/fs1                          canmount  noauto    local
+test_target1/test_source1/fs1@test-20101111000000      canmount  -         -
+test_target1/test_source1/fs1/sub                      canmount  noauto    local
+test_target1/test_source1/fs1/sub@test-20101111000000  canmount  -         -
+test_target1/test_source2                              canmount  on        default
+test_target1/test_source2/fs2                          canmount  on        default
+test_target1/test_source2/fs2/sub                      canmount  noauto    local
+test_target1/test_source2/fs2/sub@test-20101111000000  canmount  -         -
+""")
+
+
+    def  test_rollback(self):
+
+        #initial backup
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        #make change
+        r=shelltest("zfs mount test_target1/test_source1/fs1")
+        r=shelltest("touch /test_target1/test_source1/fs1/change.txt")
+
+        with patch('time.strftime', return_value="20101111000001"):
+            #should fail (busy)
+            self.assertTrue(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000002"):
+            #rollback, should succeed
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --rollback".split(" ")).run())
+
+
+    def  test_destroyincompat(self):
+
+        #initial backup
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        #add multiple compatible snapshot (written is still 0)
+        r=shelltest("zfs snapshot test_target1/test_source1/fs1@compatible1")
+        r=shelltest("zfs snapshot test_target1/test_source1/fs1@compatible2")
+
+        with patch('time.strftime', return_value="20101111000001"):
+            #should be ok, is compatible
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        #add incompatible snapshot by changing and snapshotting
+        r=shelltest("zfs mount test_target1/test_source1/fs1")
+        r=shelltest("touch /test_target1/test_source1/fs1/change.txt")
+        r=shelltest("zfs snapshot test_target1/test_source1/fs1@incompatible1")
+
+
+        with patch('time.strftime', return_value="20101111000002"):
+            #--test should fail, now incompatible
+            self.assertTrue(ZfsAutobackup("test test_target1 --verbose --allow-empty --test".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000002"):
+            #should fail, now incompatible
+            self.assertTrue(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000003"):
+            #--test should succeed by destroying incompatibles
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --destroy-incompatible --test".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000003"):
+            #should succeed by destroying incompatibles
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --destroy-incompatible".split(" ")).run())
+
+
+
+
+
+    def test_keepsourcetarget(self):
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty".split(" ")).run())
+
+        #should still have all snapshots
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1@test-20101111000001
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source1/fs1/sub@test-20101111000001
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs2/sub@test-20101111000001
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source1/fs1/sub@test-20101111000001
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+test_target1/test_source2/fs2/sub@test-20101111000001
+""")
+
+
+        #run again with keep=0
+        with patch('time.strftime', return_value="20101111000002"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --keep-source=0 --keep-target=0".split(" ")).run())
+
+        #should only have last snapshots
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000002
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000002
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000002
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000002
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000002
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000002
+""")
+
+
+    def test_ssh(self):
+
+        #test all ssh directions
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --ssh-source localhost".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --ssh-target localhost".split(" ")).run())
+
+        with patch('time.strftime', return_value="20101111000002"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --allow-empty --ssh-source localhost --ssh-target localhost".split(" ")).run())
+
+
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1@test-20101111000001
+test_source1/fs1@test-20101111000002
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source1/fs1/sub@test-20101111000001
+test_source1/fs1/sub@test-20101111000002
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs2/sub@test-20101111000001
+test_source2/fs2/sub@test-20101111000002
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1@test-20101111000002
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source1/fs1/sub@test-20101111000001
+test_target1/test_source1/fs1/sub@test-20101111000002
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+test_target1/test_source2/fs2/sub@test-20101111000001
+test_target1/test_source2/fs2/sub@test-20101111000002
+""")
+
+
+    def  test_minchange(self):
+
+        #initial
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --min-change 100000".split(" ")).run())
+
+        #make small change, use umount to reflect the changes immediately
+        r=shelltest("zfs set compress=off test_source1")
+        r=shelltest("touch /test_source1/fs1/change.txt")
+        r=shelltest("zfs umount test_source1/fs1; zfs mount test_source1/fs1")
+        
+
+        #too small change, takes no snapshots
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --min-change 100000".split(" ")).run())
+
+        #make big change
+        r=shelltest("dd if=/dev/zero of=/test_source1/fs1/change.txt bs=200000 count=1")
+        r=shelltest("zfs umount test_source1/fs1; zfs mount test_source1/fs1")
+
+        #bigger change, should take snapshot
+        with patch('time.strftime', return_value="20101111000002"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --min-change 100000".split(" ")).run())
+
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000000
+test_source1/fs1@test-20101111000002
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1@test-20101111000002
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+    def  test_test(self):
+
+        #initial
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --test".split(" ")).run())
+
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1/sub
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+""")
+
+        #actual make initial backup
+        with patch('time.strftime', return_value="20101111000001"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+
+        #test incremental
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose --test".split(" ")).run())
+
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-20101111000001
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000001
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000001
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@test-20101111000001
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000001
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000001
+""")
+
+
+    def test_migrate(self):
+        """test migration from other snapshotting systems. zfs-autobackup should be able to continue from any common snapshot, not just its own."""
+
+        shelltest("zfs snapshot test_source1/fs1@migrate1")
+        shelltest("zfs create test_target1/test_source1")
+        shelltest("zfs send  test_source1/fs1@migrate1| zfs recv test_target1/test_source1/fs1")
+
+        with patch('time.strftime', return_value="20101111000000"):
+            self.assertFalse(ZfsAutobackup("test test_target1 --verbose".split(" ")).run())
+
+        r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+        self.assertMultiLineEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@migrate1
+test_source1/fs1@test-20101111000000
+test_source1/fs1/sub
+test_source1/fs1/sub@test-20101111000000
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-20101111000000
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+test_target1/test_source1
+test_target1/test_source1/fs1
+test_target1/test_source1/fs1@migrate1
+test_target1/test_source1/fs1@test-20101111000000
+test_target1/test_source1/fs1/sub
+test_target1/test_source1/fs1/sub@test-20101111000000
+test_target1/test_source2
+test_target1/test_source2/fs2
+test_target1/test_source2/fs2/sub
+test_target1/test_source2/fs2/sub@test-20101111000000
+""")
+
+
+###########################
+# TODO:
+
+    def  test_raw(self):
+        
+        self.skipTest("todo: later when travis supports zfs 0.8")
+
+
+
--- a/test_zfsnode.py
+++ b/test_zfsnode.py
@ -0,0 +1,123 @@
+from basetest import *
+
+
+class TestZfsNode(unittest2.TestCase):
+
+    def setUp(self):
+        prepare_zpools()
+        # return super().setUp()
+
+
+    def test_consistent_snapshot(self):
+        logger=Logger()
+        description="[Source]"
+        node=ZfsNode("test", logger, description=description)
+
+        with self.subTest("first snapshot"):
+            node.consistent_snapshot(node.selected_datasets, "test-1",100000)
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-1
+test_source1/fs1/sub
+test_source1/fs1/sub@test-1
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-1
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+""")
+
+
+        with self.subTest("second snapshot, no changes, no snapshot"):
+            node.consistent_snapshot(node.selected_datasets, "test-2",1)
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-1
+test_source1/fs1/sub
+test_source1/fs1/sub@test-1
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-1
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+""")
+
+        with self.subTest("second snapshot, no changes, empty snapshot"):
+            node.consistent_snapshot(node.selected_datasets, "test-2",0)
+            r=shelltest("zfs list -H -o name -r -t all "+TEST_POOLS)
+            self.assertEqual(r,"""
+test_source1
+test_source1/fs1
+test_source1/fs1@test-1
+test_source1/fs1@test-2
+test_source1/fs1/sub
+test_source1/fs1/sub@test-1
+test_source1/fs1/sub@test-2
+test_source2
+test_source2/fs2
+test_source2/fs2/sub
+test_source2/fs2/sub@test-1
+test_source2/fs2/sub@test-2
+test_source2/fs3
+test_source2/fs3/sub
+test_target1
+""")
+
+
+    def test_getselected(self):
+        logger=Logger()
+        description="[Source]"
+        node=ZfsNode("test", logger, description=description)
+        s=pformat(node.selected_datasets)
+        print(s)
+
+        #basics
+        self.assertEqual (s, """[(local): test_source1/fs1,
+ (local): test_source1/fs1/sub,
+ (local): test_source2/fs2/sub]""")
+
+        #caching, so expect same result after changing it
+        subprocess.check_call("zfs set autobackup:test=true test_source2/fs3", shell=True)
+        self.assertEqual (s, """[(local): test_source1/fs1,
+ (local): test_source1/fs1/sub,
+ (local): test_source2/fs2/sub]""")
+
+
+    def test_validcommand(self):
+        logger=Logger()
+        description="[Source]"
+        node=ZfsNode("test", logger, description=description)
+
+
+        with self.subTest("test invalid option"):
+            self.assertFalse(node.valid_command(["zfs", "send", "--invalid-option", "nonexisting"]))
+        with self.subTest("test valid option"):
+            self.assertTrue(node.valid_command(["zfs", "send", "-v", "nonexisting"]))
+
+    def test_supportedsendoptions(self):
+        logger=Logger()
+        description="[Source]"
+        node=ZfsNode("test", logger, description=description)
+        # -D propably always supported
+        self.assertGreater(len(node.supported_send_options),0)
+    
+
+    def test_supportedrecvoptions(self):
+        logger=Logger()
+        description="[Source]"
+        #NOTE: this couldnt hang via ssh if we dont close filehandles properly. (which was a previous bug)
+        node=ZfsNode("test", logger, description=description, ssh_to='localhost')
+        self.assertIsInstance(node.supported_recv_options, list)
+        
+
+
+if __name__ == '__main__':
+    unittest.main()
Author	SHA1	Message	Date
DatuX	8a09a49951	Update python-publish.yml	2021-02-02 20:17:07 +01:00
DatuX	8092b08e7f	Update python-publish.yml	2021-02-02 19:36:20 +01:00
DatuX	075c96bf47	Create python-publish.yml	2021-02-02 19:22:56 +01:00
DatuX	2cbfa0f38a	Rename manual.yml to regression.yml	2021-02-02 18:51:21 +01:00
DatuX	47c50583c0	Update README.md	2021-02-02 18:44:31 +01:00
DatuX	e40eb71f39	Update README.md	2021-02-02 18:43:28 +01:00
DatuX	fab3bf3b3e	Update manual.yml	2021-02-02 16:46:24 +01:00
DatuX	1afe2407fa	Update manual.yml	2021-02-02 16:44:47 +01:00
DatuX	3550100099	Update run_tests	2021-02-02 15:56:22 +01:00
DatuX	9e2a6dba3d	Update manual.yml	2021-02-02 15:55:49 +01:00
DatuX	b31b74aa92	Update manual.yml	2021-02-02 15:45:03 +01:00
DatuX	222568ad31	Update manual.yml	2021-02-02 15:39:15 +01:00
DatuX	35f739b8dd	Update manual.yml	2021-02-02 15:37:05 +01:00
DatuX	52f9e0d810	Update .travis.yml	2021-02-02 15:33:29 +01:00
DatuX	7bbf041a70	Update manual.yml	2021-02-02 15:30:21 +01:00
DatuX	b6796ded84	Update manual.yml	2021-02-02 15:28:29 +01:00
DatuX	930bf6cf50	Update manual.yml	2021-02-02 15:26:36 +01:00
DatuX	fcc8470758	Update manual.yml	2021-02-02 15:05:29 +01:00
DatuX	fde4a5ed6a	Update manual.yml	2021-02-02 14:55:57 +01:00
DatuX	12c45f95c3	Update manual.yml	2021-02-02 14:53:34 +01:00
DatuX	10e7e5b95f	Update manual.yml	2021-02-02 14:52:35 +01:00
DatuX	656b435a7f	Update manual.yml	2021-02-02 14:50:06 +01:00
DatuX	1c1c6647f1	Update manual.yml	2021-02-02 14:48:13 +01:00
DatuX	39514de86a	Update manual.yml	2021-02-02 14:42:28 +01:00
DatuX	49f6e36749	Update manual.yml	2021-02-02 14:41:55 +01:00
DatuX	371de417a4	Update manual.yml	2021-02-02 14:33:09 +01:00
DatuX	6965c04dc6	Update manual.yml	2021-02-02 14:30:58 +01:00
DatuX	9e645e9237	Update manual.yml	2021-02-02 14:27:04 +01:00
DatuX	fa372799f5	Update manual.yml	2021-02-02 14:26:18 +01:00
DatuX	da55436863	Update manual.yml	2021-02-02 14:21:35 +01:00
DatuX	4d0db0b5d3	Update manual.yml	2021-02-02 14:20:46 +01:00
DatuX	75f5e0ee9f	Update manual.yml	2021-02-02 14:16:31 +01:00
DatuX	d0ab60168b	Update manual.yml	2021-02-02 14:15:13 +01:00
DatuX	b48726185c	Create manual.yml	2021-02-02 14:14:38 +01:00
Edwin Eefting	74da005870	easier to use proxmox backup script	2021-02-02 14:04:03 +01:00
DatuX	6e0664ad8e	Merge pull request #62 from dkew8/master debug in zfs-autobackup	2021-01-17 11:28:13 +01:00
dkew8	f508e72f5e	Update zfs-autobackup	2021-01-01 14:54:22 -06:00
Edwin Eefting	4918a2c055	huge cleanup of codestyle and other linter warnings. should be no functional changes.	2020-08-27 22:33:00 +02:00
Edwin Eefting	e65d1ac860	point to 3.0	2020-08-26 13:48:18 +02:00
Edwin Eefting	fd7015b77a	releasing v3.0 final	2020-08-26 13:41:52 +02:00
DatuX	f524845dbb	Update README.md	2020-07-25 10:34:42 +02:00
Edwin Eefting	51c15ec618	more tests	2020-07-17 18:15:20 +02:00
Edwin Eefting	9fe13a4207	implemented --destroy-missing	2020-07-17 17:44:30 +02:00
Edwin Eefting	7b8b536d53	update docs for upcoming change. more tests	2020-07-14 20:12:11 +02:00
Edwin Eefting	122035dfef	updated docs	2020-07-10 13:14:09 +02:00
Edwin Eefting	7b278be0b9	clearification	2020-07-09 20:14:12 +02:00
Edwin Eefting	cc1a9a3d72	Changed order of operations: target stuff is now done as last step. (in case ssh-target is unreachable, snapshots are still being made). Also allow operating as a snapshot tool when not specifying target_path. Implements #46	2020-07-09 19:38:51 +02:00
Edwin Eefting	eaad31e8b4	check if target_path is missing	2020-07-09 17:02:48 +02:00
Edwin Eefting	470b4aaf55	better sterr messages. fixes #47	2020-07-09 16:43:01 +02:00
Edwin Eefting	fc3026abdc	more tests	2020-07-09 16:01:02 +02:00
Edwin Eefting	0b1081e87f	more tests	2020-07-09 14:48:53 +02:00
Edwin Eefting	8699ec5c69	more tests	2020-07-09 13:15:45 +02:00
Edwin Eefting	cba6470500	more --test test	2020-07-09 12:51:26 +02:00
Edwin Eefting	d08f7bf3c1	more tests, found bug	2020-07-08 19:27:21 +02:00
Edwin Eefting	d19cb2c842	skip resume test if not supported in userspace	2020-07-08 18:29:02 +02:00
Edwin Eefting	f2b284c407	make tests python2 compat	2020-07-08 17:53:54 +02:00
Edwin Eefting	a6cdd4b89e	fixes and more tests	2020-07-08 17:07:21 +02:00
Edwin Eefting	8176326126	more tests	2020-07-08 16:59:58 +02:00
Edwin Eefting	ad2542e930	more tests	2020-06-25 17:43:40 +02:00
Edwin Eefting	b926c86a7b	test fix	2020-06-25 17:26:47 +02:00
Edwin Eefting	915a29b36e	tests: make sure it doest get confused by other zfs datasets	2020-06-25 17:15:18 +02:00
Edwin Eefting	f363142926	test fix	2020-06-24 23:29:00 +02:00
Edwin Eefting	27c598344b	more tests	2020-06-24 23:16:33 +02:00
Edwin Eefting	ce817eb05c	more tests	2020-06-24 22:11:21 +02:00
Edwin Eefting	b97bde3f6d	more tests	2020-06-22 23:34:00 +02:00
Edwin Eefting	fa14dcdce1	fix test	2020-06-22 23:13:57 +02:00
Edwin Eefting	c34bf22f4e	fix test	2020-06-22 23:10:39 +02:00
Edwin Eefting	01425e735d	fix test skip	2020-06-22 22:58:00 +02:00
Edwin Eefting	56a2f26dfa	travis debug	2020-06-22 22:49:42 +02:00
Edwin Eefting	8729fcac74	test fix	2020-06-22 22:44:53 +02:00
Edwin Eefting	6151096dc8	some features just arent supported on zfs utils 0.6.x	2020-06-15 22:14:40 +02:00
Edwin Eefting	1e8b02db28	more tests	2020-06-15 21:49:17 +02:00
Edwin Eefting	6d69c8f2b4	more tests	2020-06-15 21:24:17 +02:00
Edwin Eefting	fc853622dd	more tests	2020-06-15 21:13:19 +02:00
Edwin Eefting	37a9f49d8d	more tests	2020-05-30 13:45:23 +02:00
Edwin Eefting	ff33f46cb8	actually use mock	2020-05-28 19:07:36 +02:00
Edwin Eefting	e1610b6874	mock	2020-05-28 18:31:34 +02:00
Edwin Eefting	10c45affd7	mock	2020-05-28 18:26:32 +02:00
Edwin Eefting	4d12b8da5f	more tests	2020-05-28 18:21:16 +02:00
Edwin Eefting	58e098324e	removed soon to be depricated -D option	2020-05-27 21:32:27 +02:00
Edwin Eefting	1ffd9a15a3	input=None would read stdin from terminal, causing hangs	2020-05-18 20:05:50 +02:00
Edwin Eefting	e54c275685	fix	2020-05-18 17:01:46 +02:00
Edwin Eefting	ee4fade2e4	clearly show versions	2020-05-18 16:59:07 +02:00
Edwin Eefting	c5f1a87c40	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-05-18 16:43:54 +02:00
Edwin Eefting	2fe854905d	test failed due to randint difference between python 2 and 3	2020-05-18 16:40:51 +02:00
Edwin Eefting	1c86c6f866	fix	2020-05-18 15:31:25 +02:00
Edwin Eefting	8bb9769a8b	test	2020-05-17 22:54:42 +02:00
Edwin Eefting	3ef7c32237	test	2020-05-17 22:51:59 +02:00
Edwin Eefting	c254ad3b82	test	2020-05-17 22:48:55 +02:00
Edwin Eefting	fb7da316f8	test	2020-05-17 22:48:04 +02:00
Edwin Eefting	fedae35221	also test on bionic	2020-05-17 22:42:23 +02:00
Edwin Eefting	1cb26d48b6	fix for python2 test	2020-05-17 22:30:29 +02:00
Edwin Eefting	87e0599130	also test python 2.7	2020-05-17 22:24:55 +02:00
Edwin Eefting	252086e2e6	another option that is unsupported in older versions	2020-05-17 22:01:12 +02:00
Edwin Eefting	4d15f29b5b	older zpool command doesnt support -o	2020-05-17 21:54:43 +02:00
Edwin Eefting	3bc37d143c	take into account pool features and supported options (fixes regressions). also automaticly enable resume if its supported	2020-05-17 21:49:58 +02:00
Edwin Eefting	4dc4bdbba5	travis test without any zfs send options	2020-05-17 18:19:32 +02:00
Edwin Eefting	d2fe9b9ec7	test supported zfs send options	2020-05-17 18:09:58 +02:00
Edwin Eefting	2143d22ae5	test stuff	2020-05-17 17:11:52 +02:00
Edwin Eefting	138c913e58	close open filehandles. more tests	2020-05-17 16:59:46 +02:00
Edwin Eefting	2305fdf033	stricter test	2020-05-17 16:21:06 +02:00
Edwin Eefting	797fb23baa	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-05-17 15:33:14 +02:00
Edwin Eefting	82c7ac5e53	test	2020-05-17 15:12:05 +02:00
DatuX	293ab1d075	Update README.md	2020-05-17 15:05:39 +02:00
Edwin Eefting	50e94baf4e	test	2020-05-17 14:53:41 +02:00
Edwin Eefting	47bd4ed490	use gmtime instead of localtime	2020-05-17 14:49:08 +02:00
Edwin Eefting	0d26420b15	test	2020-05-17 14:19:23 +02:00
Edwin Eefting	3e243a0916	test	2020-05-17 14:16:39 +02:00
Edwin Eefting	499ccc6fd0	test	2020-05-17 14:14:46 +02:00
Edwin Eefting	ca294f9dd6	test	2020-05-17 13:48:02 +02:00
Edwin Eefting	9772fc80cf	test	2020-05-17 13:28:15 +02:00
Edwin Eefting	83905c4614	test	2020-05-17 13:14:55 +02:00
Edwin Eefting	7a3c309123	test	2020-05-17 13:07:41 +02:00
Edwin Eefting	022dc1b7fc	test	2020-05-17 13:00:22 +02:00
Edwin Eefting	136289b4d6	test	2020-05-17 12:58:18 +02:00
Edwin Eefting	5bf49cf19e	test	2020-05-17 12:51:53 +02:00
Edwin Eefting	735938eded	test	2020-05-17 12:27:38 +02:00
Edwin Eefting	d83fa2f97f	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-05-17 12:04:07 +02:00
Edwin Eefting	b0db6d13cc	test	2020-05-17 11:59:12 +02:00
Edwin Eefting	c7762d8163	exploring ways to use zfs within travis	2020-05-17 11:50:17 +02:00
Edwin Eefting	bc17825582	more testing	2020-05-14 18:47:29 +02:00
Edwin Eefting	b22113aad4	cleanup tests	2020-05-14 18:17:00 +02:00
Edwin Eefting	4e1bfd8cba	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-05-14 17:43:04 +02:00
Edwin Eefting	0388026f94	fix	2020-05-14 01:28:48 +02:00
Edwin Eefting	b718e282b1	started on zfsnode test. cleanedup zfs-autobackup	2020-05-14 01:18:17 +02:00
Edwin Eefting	b6fb07a436	better docstring	2020-05-12 18:57:11 +02:00
Edwin Eefting	4f78f0cd22	fixes	2020-05-12 18:43:00 +02:00
Edwin Eefting	2fa95f098b	subtests	2020-05-12 18:28:16 +02:00
Edwin Eefting	c864e5ffad	moved testing to a better place	2020-05-12 17:47:31 +02:00
Edwin Eefting	6f6a2ceee2	check exit codes when piping	2020-05-12 17:29:35 +02:00
Edwin Eefting	0813a8cef6	more tests	2020-05-12 02:26:06 +02:00
Edwin Eefting	55f491915a	more unit tests and fixes	2020-05-12 01:56:22 +02:00
Edwin Eefting	04971f2f29	working on unit tests, found and fixed escaping issue	2020-05-12 01:25:25 +02:00
Edwin Eefting	e1344dd9da	moved to unit test	2020-05-11 23:47:42 +02:00
Edwin Eefting	ea390df6f6	added first unit test	2020-05-11 23:47:04 +02:00
Edwin Eefting	9be1f334cb	license	2020-05-11 15:36:16 +02:00
Edwin Eefting	de877362c9	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-05-11 12:02:22 +02:00
DatuX	9b1254a6d9	Merge pull request #43 from wxcafe/patch-2 usefull -> useful	2020-05-06 10:06:23 +02:00
DatuX	c110943f20	Merge pull request #42 from wxcafe/patch-1 corrects typos and errors	2020-05-06 10:05:42 +02:00
wxcafé	e94eb11f63	usefull -> useful	2020-05-03 00:21:48 -04:00
wxcafé	0d498e3f44	corrects typos and errors	2020-05-03 00:19:53 -04:00
Edwin Eefting	dd301dc422	bugfix	2020-04-21 17:59:18 +02:00
Edwin Eefting	9e6d90adfe	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-04-21 12:02:31 +02:00
Edwin Eefting	a6b688c976	bugfix: return correct error code when catching exception!	2020-04-16 16:37:06 +02:00
Edwin Eefting	10f1290ad9	also thin datasets that are missing on the source. preparation for --destroy-missing option. #34	2020-04-01 20:30:35 +02:00
Edwin Eefting	b51eefa139	backup	2020-04-01 18:00:55 +02:00
Edwin Eefting	805d7e3536	nicer exception handling	2020-04-01 14:15:59 +02:00
Edwin Eefting	8f0472e8f5	working on thinning obsolete datasets	2020-04-01 01:48:28 +02:00
Edwin Eefting	002aa6a731	automatic enable --progress on tty's. added stderr/out flushing to get syncronised logfiles. send progress actually to stderr	2020-04-01 00:54:32 +02:00
Edwin Eefting	8a960389d1	fix url for pypi	2020-03-31 20:01:28 +02:00
Edwin Eefting	c7cd73ae1f	Merge branch 'master' of github.com:psy0rz/zfs_autobackup	2020-03-31 19:33:26 +02:00
Edwin Eefting	c8c1d0fd27	transparancy	2020-03-31 19:33:09 +02:00
Edwin Eefting	c090979f3e	spelling and links	2020-03-31 19:23:04 +02:00
Edwin Eefting	3a4062c983	tried to clear up thinner documetion and output	2020-03-31 19:06:46 +02:00
Edwin Eefting	bcf73c6e5c	--min-change is now has 1 instead of 200000 as default. fixes #37	2020-03-29 23:47:26 +02:00
Edwin Eefting	9cf5ce188a	added thinner documentation. fixes #21	2020-03-29 23:23:47 +02:00
Edwin Eefting	a226309ce5	spelling	2020-03-29 23:22:18 +02:00
Edwin Eefting	231f41e195	update	2020-03-17 23:52:57 +01:00
Edwin Eefting	7c1546fb49	improved --rollback code. detect and show incompatible snapshots on target. added --destroy-incompatible option. fixes #34	2020-03-17 23:51:16 +01:00
Edwin Eefting	b1dd2b55f8	improved error logging	2020-03-17 19:55:16 +01:00
Edwin Eefting	4ed53eb03f	fix linter isue	2020-03-15 23:02:03 +01:00
Edwin Eefting	6f8c73b87f	rc7	2020-03-15 22:59:21 +01:00
Edwin Eefting	ee03da2f9b	exposed --min-change value as a parameter. (was hardcoded at 200000)	2020-03-15 22:54:14 +01:00
Edwin Eefting	e737d0a79f	improved example and cleaned up	2020-03-15 21:42:09 +01:00
DatuX	cbd281c79d	Merge pull request #32 from mariusvw/feature/ssh-keygen Feature/ssh keygen	2020-03-14 22:49:26 +01:00
Edwin Eefting	dfd38985d1	Merge remote-tracking branch 'remotes/mariusvw/feature/ssh-config'	2020-03-14 22:46:53 +01:00
DatuX	f1c15cec18	Merge pull request #30 from mariusvw/feature/issue-25 Issue #25, disable colors on non-tty	2020-03-14 22:15:43 +01:00
Edwin Eefting	1bc35f5812	explained splitting of jobs	2020-03-14 22:14:11 +01:00
Edwin Eefting	805a3147b5	added --no-send option. snapshots that are obsolete are now destroyed at the beginning of each dataset-transfer. this allows using --no-send as way to just thinout old snapshots. cleaned up stderr output when resuming.	2020-03-14 22:04:16 +01:00
Marius van Witzenburg	944435cbd1	Added another ssh-keygen example without passphrase	2020-03-09 10:16:40 +01:00
Marius van Witzenburg	022a7d75e2	Updated readme with ssh-keygen example	2020-03-09 10:13:48 +01:00
Marius van Witzenburg	14ac525525	Issue #25 , disable colors on non-tty	2020-03-08 23:55:07 +01:00
Marius van Witzenburg	3a45951361	Updated README	2020-03-08 23:16:37 +01:00
Marius van Witzenburg	2a300bbcba	Added support for custom ssh client config	2020-03-08 23:16:11 +01:00
Marius van Witzenburg	bdeb4c40fa	Cleanup whitespace	2020-03-08 23:05:49 +01:00
Marius van Witzenburg	e8b90abfde	Cleaned whitespace	2020-03-08 22:05:48 +01:00
Edwin Eefting	1d9c25d3b4	prevent emitting useless error messages in some cases when holding/release/destroying snapshots	2020-02-25 20:15:11 +01:00
Edwin Eefting	56d7f8c754	rc5	2020-02-25 18:41:04 +01:00
Edwin Eefting	ef5bca3de1	start at correct snapshot when full send	2020-02-25 18:35:35 +01:00
Edwin Eefting	3b2a19d492	migrate/other-snapshot feature almost done	2020-02-25 00:58:25 +01:00
Edwin Eefting	d2314c0143	imp is not used	2020-02-24 14:30:07 +01:00
Edwin Eefting	f3a80991c9	fix release stuff	2020-02-24 14:20:42 +01:00