zfs_mgmt 0.3.5 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bce5f90411d08b54334f8694e7956f718c1e63995f2c799b95cb170b302c2c8a
-  data.tar.gz: 1d82a41657f40fe371814210be392d8c34be333816530fcff6a67ae778dc120b
+  metadata.gz: a54ed2e0ad255f69367aaeb25fd0dddcc8346cec0fd8be02561e4ea1210510f2
+  data.tar.gz: 1d31c311f63835c3f7a2b6e771b06628f1901b62130e9ec5d0255ff987fb89bc
 SHA512:
-  metadata.gz: e500b4cc3b155528c470c5aa26338a948e783a5f951a7a5e0d6c05b6739c07cccd6bfe0a1dd001a34722f47e611cc85e2f931d8e3cbca58e37b0f3b0d23606da
-  data.tar.gz: d3ca6969f760260449f85d99e05133f542700f9d0322a84f771cd157d3ec0729c2e86dc33f0326c53b1f35065cb28b879bbad85c6e422c4bae95b20cc9d21f06
+  metadata.gz: c0534143034e6edb6ce1161bacd86765cf9a151812d1849f3570c983691dfdf8d03f5d0aeefb070fa144fa0fa6838711b855e07180a7c70cd14f3f00d561d562
+  data.tar.gz: dbf53bcfe6223106f080393621d58ef538a2cf9fe9ae9e7f338b2cbe4e5d88d5bca2fcf44f3c6e8ffb76050ce2d0cfc75fa12638b8d19aae759b9b507fab3a65

data/Gemfile

@@ -6,4 +6,5 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 gem "thor"
 gem "text-table"
 gem "filesize"
+gem "json"
 gemspec

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    zfs_mgmt (0.3.5)
+    zfs_mgmt (0.3.10)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.3)
     filesize (0.2.0)
+    json (2.3.0)
     rake (13.0.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
@@ -31,6 +32,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.16)
   filesize
+  json
   rake (>= 12.3.3)
   rspec (~> 3.0)
   text-table

data/README.md

@@ -1,8 +1,11 @@
 # ZfsMgmt
 
-zfs_mgmt aims to provide some useful helpers for managing zfs snapshots, and eventually send/recv duties via the zfsmgr script in bin/.
+zfs_mgmt aims to provide some useful helpers for managing zfs
+snapshots, and eventually send/recv duties via the zfsmgr script in
+bin/.
 
-Currently only snapshot destruction is implemented by a policy specification stored in zfs properties.
+Currently only snapshot destruction is implemented by a policy
+specification stored in zfs properties.
 
 ## Installation
 
@@ -16,25 +19,36 @@ Therefore, building the gem and installing, or running ruby inside the src/ dire
 
 ## Usage
 
-The most common usage pattern would be to set zfs properties as explained below, then use **zfsmgr snapshot policy** to print a table of what would be kept and for what reason.  Then use **zfsmgr snapshot destroy --noop** to see what would be destroyed, and finally **zfsmgr snapshot destroy** without the --noop option to actually remove snapshots.
+The most common usage pattern would be to set zfs properties as
+explained below, then use **zfsmgr snapshot policy** to print a table
+of what would be kept and for what reason.  Then use **zfsmgr snapshot destroy --noop**
+to see what would be destroyed, and finally **zfsmgr snapshot destroy**
+without the --noop option to actually remove snapshots.
 
+    $ zfsmgr
     Commands:
       zfsmgr help [COMMAND]               # Describe available commands or one specific command
+      zfsmgr list SUBCOMMAND ...ARGS      # list filesystems
+      zfsmgr restic SUBCOMMAND ...ARGS    # backup zfs to restic
       zfsmgr snapshot SUBCOMMAND ...ARGS  # manage snapshots
       zfsmgr zfsget [ZFS]                 # execute zfs get for the given properties and types and parse the output into a nested hash
-    
-    
-      zfsmgr snapshot create          # execute zfs snapshot based on zfs properties
-      zfsmgr snapshot destroy         # apply the snapshot destroy policy to zfs
-      zfsmgr snapshot help [COMMAND]  # Describe subcommands or one specific subcommand
-      zfsmgr snapshot policy          # print the policy table for zfs
-    
-    Options:
-      [--noop], [--no-noop]        # pass -n option to zfs commands
-      [--verbose], [--no-verbose]  # pass -v option to zfs commands
-      [--debug], [--no-debug]      # set logging level to debug
-      [--filter=FILTER]            # only act on zfs matching this regexp
-                                   # Default: .+
+
+### list stale
+
+**zfsmgr list stale will** will list all zfs with "stale" snapshots,
+that is the newest snapshot is older than 1d or older than the --age
+parameter.
+
+### restic backup
+
+zfsmgr can pipe zfs send output into restic, to allow storing zfs
+streams in restic repositories.  zfsmgr takes an opinionated approach
+to this task, implementing a traditional full/differential/incremental
+backup scheme.  This should allow a recent snapshot to be restored
+requiring only 3 restic snapshots to recreate the filesystem. See the
+properties section for restic related zfs properties.
+
+    $ zfsmgr restic backup full
 
 
 ## Example output
@@ -100,20 +114,30 @@ The most common usage pattern would be to set zfs properties as explained below,
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install
+dependencies. Then, run `rake spec` to run the tests. You can also run
+`bin/console` for an interactive prompt that will allow you to
+experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake
+install`. To release a new version, update the version number in
+`version.rb`, and then run `bundle exec rake release`, which will
+create a git tag for the version, push git commits and tags, and push
+the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/aranc23/zfs_mgmt.
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/aranc23/zfs_mgmt.
 
 ## zfs user properties
 
-Destruction of zfs snapshots is based on the following zfs user properties:
+Destruction of zfs snapshots is based on the following zfs user
+properties:
 
 ### zfsmgmt:manage
-manage snapshots for this filesystem if this property is 'true' (string literal)
+manage snapshots for this filesystem if this property is 'true'
+(string literal)
  
 ### zfsmgmt:policy
 
@@ -127,7 +151,8 @@ Examples:
 - 1y1m1y1d1h (1 of each time frame worth of snapshots)
 - 72h (72 hourly snapshots)
 
-The order in which each timeframe is listed in does not matter, and the supported specs are as follows:
+The order in which each timeframe is listed in does not matter, and
+the supported specs are as follows:
 
 - h - hourly
 - d - daily
@@ -194,6 +219,13 @@ create snapshots called autosnap-%FT%T%z.
 strftime format string used when creating snapshot names, default
 being %FT%T%z.
 
+### zfsmgmt:restic_backup
+boolean, send this zfs to restic
+
+### zfsmgmt:restic_repository
+send the zfs to this repository, optional, rely on restic environment
+variables otherwise
+
 ## Snapshot Management / zfs destroy
 When destroying snapshots according to a given policy, all snapshots
 should be considered for deletion and all snapshots should be

data/bin/zfsmgr

@@ -1,44 +1,29 @@
 require "thor"
 require "zfs_mgmt"
-
-class Snapshot < Thor
-  class_option :noop, :type => :boolean, :default => false,
-               :desc => 'pass -n option to zfs commands'
-  class_option :verbose, :type => :boolean, :default => false,
-               :desc => 'pass -v option to zfs commands'
-  class_option :debug, :type => :boolean, :default => false,
-               :desc => 'set logging level to debug'
-  class_option :filter, :type => :string, :default => '.+',
-               :desc => 'only act on zfs matching this regexp'
-  desc "destroy", "apply the snapshot destroy policy to zfs"
-  def destroy()
-    ZfsMgmt.snapshot_destroy(noop: options[:noop], verbopt: options[:verbose], debugopt: options[:debug], filter: options[:filter])
-  end
-  desc "policy", "print the policy table for zfs"
-  def policy()
-    ZfsMgmt.snapshot_policy(verbopt: options[:verbose], debugopt: options[:debug], filter: options[:filter])
-  end
-  desc "create", "execute zfs snapshot based on zfs properties"
-  def create()
-    ZfsMgmt.snapshot_create(verbopt: options[:verbose], debugopt: options[:debug], filter: options[:filter])
-  end
-end
+require "zfs_mgmt/restic"
+require "zfs_mgmt/zfs_mgr"
+require "zfs_mgmt/zfs_mgr/restic"
 
 class ZfsMgr < Thor
+  class_option :zfs_binary, :type => :string, :default => 'zfs',
+               :desc => 'zfs binary'
+  class_option :zpool_binary, :type => :string, :default => 'zpool',
+               :desc => 'zfs binary'
   desc "zfsget [ZFS]", "execute zfs get for the given properties and types and parse the output into a nested hash"
   method_option :properties, :type => :array, :default => ['name'], :desc => "List of properties passed to zfs get"
   method_option :types,      :type => :array, :default => ['filesystem','volume'], enum: ['filesystem','volume','snapshot'], :desc => "list of types"
   def zfsget(zfs)
+    ZfsMgmt.global_options = options
     pp ZfsMgmt.zfsget(properties: options[:properties],
                       types: options[:types],
                       zfs: zfs)
   end
   desc "snapshot SUBCOMMAND ...ARGS", "manage snapshots"
-  subcommand "snapshot", Snapshot
+  subcommand "snapshot", ZfsMgmt::ZfsMgr::Snapshot
   desc "list SUBCOMMAND ...ARGS", "list filesystems"
-  subcommand "list", ZfsMgmtList
+  subcommand "list", ZfsMgmt::ZfsMgr::List
   desc "restic SUBCOMMAND ...ARGS", "backup zfs to restic"
-  subcommand "restic", ZfsMgmtRestic
+  subcommand "restic", ZfsMgmt::ZfsMgr::Restic
 end
 
 ZfsMgr.start(ARGV)

data/lib/zfs_mgmt.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 require "zfs_mgmt/version"
 require "zfs_mgmt/restic"
+require "zfs_mgmt/zfs_mgr"
 require 'pp'
 require 'date'
 require 'logger'
@@ -37,6 +38,9 @@ $properties_xlate = {
 }
 
 module ZfsMgmt
+  class << self
+    attr_accessor :global_options
+  end
   def self.custom_properties()
     return [
       'policy',
@@ -64,10 +68,49 @@ module ZfsMgmt
       return md[1].to_i
     end
   end
-      
+
+  def self.zfs_holds(snapshot)
+    com = [global_options['zfs_binary'], 'holds', '-H', snapshot]
+    $logger.debug("#{com.join(' ')}")
+    out = %x(#{com.join(' ')})
+    unless $?.success?
+      errstr = "unable to retrieves holds for snapshot: #{snapshot}"
+      $logger.error(errstr)
+      raise errstr
+    end
+    a = []
+    out.split("\n").each do |ln|
+      a.push(ln.split("\t")[1])
+    end
+    a
+  end
+
+  def self.zfs_hold(hold,snapshot)
+    com = [global_options['zfs_binary'], 'hold', hold, snapshot]
+    $logger.debug("#{com.join(' ')}")
+    system(com.join(' '))
+    unless $?.success?
+      errstr = "unable to set hold: #{hold} for snapshot: #{snapshot}"
+      $logger.error(errstr)
+      raise errstr
+    end
+  end
+
+  def self.zfs_release(hold,snapshot)
+    com = [@global_options['zfs_binary'], 'release', hold, snapshot]
+    $logger.debug("#{com.join(' ')}")
+    system(com.join(' '))
+    unless $?.success?
+      errstr = "unable to release hold: #{hold} for snapshot: #{snapshot}"
+      $logger.error(errstr)
+      raise errstr
+    end
+  end
+
   def self.zfsget(properties: ['name'],types: ['filesystem','volume'],zfs: '')
     results={}
-    com = ['zfs', 'get', '-Hp', properties.join(','), '-t', types.join(','), zfs]
+    com = [ZfsMgmt.global_options[:zfs_binary], 'get', '-Hp', properties.join(','), '-t', types.join(','), zfs]
+    $logger.debug(com.join(' '))
     so,se,status = Open3.capture3(com.join(' '))
     if status.signaled?
       $logger.error("process was signalled \"#{com.join(' ')}\", termsig #{status.termsig}")
@@ -192,24 +235,25 @@ module ZfsMgmt
     }
     return saved,saved_snaps,deleteme
   end
-  def self.zfs_managed_list(filter: '.+')
+  def self.zfs_managed_list(filter: '.+', properties: custom_properties(), property_match: { 'zfsmgmt:manage' => 'true' } )
     zfss = [] # array of arrays
-    zfsget(properties: custom_properties()).each do |zfs,props|
+    zfsget(properties: properties).each do |zfs,props|
       unless /#{filter}/ =~ zfs
         next
       end
-      unless props.has_key?('zfsmgmt:manage') and props['zfsmgmt:manage'] == 'true'
-        next
+      managed = true
+      property_match.each do |k,v|
+        unless props.has_key?(k) and props[k] == v
+          managed = false
+          break
+        end
       end
+      next unless managed
       snaps = self.zfsget(properties: ['name','creation','userrefs','used','written','referenced'],types: ['snapshot'], zfs: zfs)
       if snaps.length == 0
         $logger.warn("unable to process this zfs, no snapshots at all: #{zfs}")
         next
       end
-      unless props.has_key?('zfsmgmt:policy') and policy = policy_parser(props['zfsmgmt:policy'])
-        $logger.error("zfs_mgmt is configured to manage #{zfs}, but there is no valid policy configuration, skipping")
-        next # zfs
-      end
       zfss.push([zfs,props,snaps])
     end
     return zfss
@@ -222,6 +266,10 @@ module ZfsMgmt
     end
     zfs_managed_list(filter: filter).each do |zdata|
       (zfs,props,snaps) = zdata
+      unless props.has_key?('zfsmgmt:policy') and policy_parser(props['zfsmgmt:policy'])
+        $logger.error("zfs_mgmt is configured to manage #{zfs}, but there is no valid policy configuration, skipping")
+        next # zfs
+      end
       # call the function that decides who to save and who to delete
       (saved,saved_snaps,deleteme) = snapshot_destroy_policy(zfs,props,snaps)
 
@@ -247,6 +295,11 @@ module ZfsMgmt
     end
     zfs_managed_list(filter: filter).each do |zdata|
       (zfs,props,snaps) = zdata
+      unless props.has_key?('zfsmgmt:policy') and policy_parser(props['zfsmgmt:policy'])
+        $logger.error("zfs_mgmt is configured to manage #{zfs}, but there is no valid policy configuration, skipping")
+        next # zfs
+      end
+
       # call the function that decides who to save and who to delete
       (saved,saved_snaps,deleteme) = snapshot_destroy_policy(zfs,props,snaps)
     
@@ -322,7 +375,7 @@ module ZfsMgmt
         
         prefix = ( props.has_key?('zfsmgmt:snap_prefix') ? props['zfsmgmt:snap_prefix'] : 'zfsmgmt' )
         ts = ( props.has_key?('zfsmgmt:snap_timestamp') ? props['zfsmgmt:snap_timestamp'] : '%FT%T%z' )
-        com = ['zfs','snapshot']
+        com = [global_options['zfs_binary'],'snapshot']
         if props['zfsmgmt:snapshot'] == 'recursive' and props['zfsmgmt:snapshot@source'] == 'local'
           com.push('-r')
         end
@@ -333,26 +386,3 @@ module ZfsMgmt
     end
   end
 end
-class ZfsMgmtList < Thor
-  class_option :filter, :type => :string, :default => '.+',
-               :desc => 'only act on zfs matching this regexp'
-  desc "stale", "list all zfs with stale snapshots"
-  method_option :age, :desc => "timeframe outside of which the zfs will be considered stale", :default => '1d'
-  def stale()
-    cutoff = Time.at(Time.now.to_i -  ZfsMgmt.timespec_to_seconds(options[:age]))
-    table = Text::Table.new
-    table.head = ['zfs','snapshot','age']
-    table.rows = []
-    ZfsMgmt.zfs_managed_list(filter: options[:filter]).each do |blob|
-      zfs,props,snaps = blob
-      last = snaps.keys.sort { |a,b| snaps[a]['creation'] <=> snaps[b]['creation'] }.last
-      snap_time = Time.at(snaps[last]['creation'])
-      if snap_time < cutoff
-        table.rows << [zfs,last.split('@')[1],snap_time]
-      end
-    end
-    if table.rows.count > 0
-      print table.to_s
-    end
-  end
-end

data/lib/zfs_mgmt/restic.rb

@@ -1,33 +1,162 @@
+require "json"
 
 module ZfsMgmt::Restic
-  def self.backup(backup_type: 'incremental', force: false, filter: '.+')
-    pp backup_type, force, filter
-  end
-end
+  def self.restic_snapshots(zfs,options,props)
+    # query the restic database
+    com = [ options[:restic_binary],
+            'snapshots',
+            '--json',
+            '--tag', 'zfsmgmt',
+            '--path', "/#{zfs}",
+          ]
+    if options.has_key?('password_file')
+      com.push('-p',options['password_file'])
+    end
+    if options.has_key?('repo')
+      com.push('--repo', options['repo'])
+    elsif props.has_key?('zfsmgmt:restic_repository')
+      com.push( '--repo', props['zfsmgmt:restic_repository'] )
+    end
 
-class ZfsMgmtResticBackup < Thor
-  class_option :filter, :type => :string, :default => '.+',
-               :desc => 'only act on zfs matching this regexp'
-  class_option :force, :type => :boolean, :default => false,
-               :desc => 'force create this backup type, fail if it cannot be forced'
-  desc "incremental", "perform incremental backup"
-  def incremental()
-    ZfsMgmt::Restic.backup(backup_type: 'incremental', force: options[:force])
-  end
-  desc "differential", "perform differential backup"
-  def differential()
-    ZfsMgmt::Restic.backup(backup_type: 'differential', force: options[:force])
-  end
-  desc "full", "perform full backup"
-  def full()
-    ZfsMgmt::Restic.backup(backup_type: 'full', force: options[:force])
+    $logger.debug("#{com.join(' ')}")
+    restic_output = %x(#{com.join(' ')})
+    unless $?.success?
+      $logger.error("unable to query the restic database")
+      raise "unable to query the restic database"
+    end
+    restic_snapshots = JSON.parse(restic_output)
+    restic_snapshot_zfs_snapshot_index = {}
+    restic_snapshots.each do |snappy|
+      snappy['date_time'] = DateTime.parse(snappy['time'])
+      if snappy.has_key?('tags')
+        snappy['tags'].each do |t|
+          if m = /^(zfsmgmt:.+?)=(.+)/.match(t)
+            if ['zfsmgmt:level'].include?(m[1])
+              snappy[m[1]] = m[2].to_i
+            else
+              snappy[m[1]] = m[2]
+            end
+            if m[1] == 'zfsmgmt:snapshot'
+              restic_snapshot_zfs_snapshot_index[m[2]] = snappy
+            end
+          end
+        end
+      end
+    end
+    return([restic_snapshots,restic_snapshot_zfs_snapshot_index])
   end
-end
 
-class ZfsMgmtRestic < Thor
-  desc "restic SUBCOMMAND ...ARGS", "backup all configured zfs to restic"
-  subcommand "backup", ZfsMgmtResticBackup
+  def self.valid_chain(snap,restic_snapshots,restic_snapshot_zfs_snapshot_index,a)
+    if snap['zfsmgmt:level'] == 0
+      a.push(snap)
+      $logger.debug("found complete chain culminating in full backup of: #{snap['zfsmgmt:snapshot']}")
+      return a
+    elsif restic_snapshot_zfs_snapshot_index.has_key?(snap['zfsmgmt:parent'])
+      a.push(snap)
+      $logger.debug("found another link in the chain: #{snap['zfsmgmt:snapshot']} => #{snap['zfsmgmt:parent']}")
+      return valid_chain(restic_snapshot_zfs_snapshot_index[snap['zfsmgmt:parent']],restic_snapshots,restic_snapshot_zfs_snapshot_index,a)
+    else
+      $logger.error("broken chain: looking for the parent of #{snap['zfsmgmt:snapshot']} (#{snap['zfsmgmt:parent']}) and failed to find")
+      return []
+    end
+  end
+      
+      
+  def self.backup(backup_level: 2,
+                  options: {})
+    ZfsMgmt.zfs_managed_list(filter: options['filter'],
+                             properties: ['name',
+                                          'zfsmgmt:restic_backup',
+                                          'zfsmgmt:restic_repository',
+                                          'userrefs',
+                                         ],
+                             property_match: { 'zfsmgmt:restic_backup' => 'true' }).each do |blob|
+      zfs,props,zfs_snapshots = blob
+      last_zfs_snapshot = zfs_snapshots.keys.sort { |a,b| zfs_snapshots[a]['creation'] <=> zfs_snapshots[b]['creation'] }.last
+      zfs_snap_time = Time.at(zfs_snapshots[last_zfs_snapshot]['creation'])
 
+      level = 0
+      chain = []
+      zfs_snap_parent = ''
+      restic_snap_parent = ''
+      (restic_snapshots,restic_snapshot_zfs_snapshot_index) = restic_snapshots(zfs,options,props)
+      if restic_snapshot_zfs_snapshot_index.has_key?(last_zfs_snapshot)
+        $logger.warn("backup of this snapshot #{last_zfs_snapshot} already exists in restic, cannot continue with backup of #{zfs}")
+        next # next zfs filesystem to be backed up
+      end
+      if backup_level > 0 and restic_snapshots.count > 0
+        # reverse (oldest first) sorted restic snapshots
+        restic_snap_parent = restic_snapshots.filter { |rsnap|
+          rsnap.has_key?('zfsmgmt:zfs') and rsnap['zfsmgmt:zfs'] == zfs and
+            rsnap.has_key?('zfsmgmt:level') and rsnap['zfsmgmt:level'] < backup_level }.sort {
+          |a,b| a['date_time'] <=> b['date_time'] }.last
+        if restic_snap_parent and
+          zfs_snapshots.has_key?(restic_snap_parent['zfsmgmt:snapshot']) and
+          chain = valid_chain(restic_snap_parent,restic_snapshots,restic_snapshot_zfs_snapshot_index,[]) and
+          chain.length > 0
+          
+          level = restic_snap_parent['zfsmgmt:level'] + 1
+          zfs_snap_parent = restic_snap_parent['zfsmgmt:snapshot']
+          $logger.debug("restic_snap_parent: level: #{restic_snap_parent['zfsmgmt:level']} snapshot: #{zfs_snap_parent}")
+        else
+          $logger.error("restic_snap_parent rejected: level: #{restic_snap_parent['zfsmgmt:level']} snapshot: #{restic_snap_parent['zfsmgmt:snapshot']}")
+        end
+        $logger.debug("chain of snapshots: #{chain}")
+      end
+      tags = [ 'zfsmgmt',
+               "zfsmgmt:snapshot=#{last_zfs_snapshot}",
+               "zfsmgmt:zfs=#{zfs}",
+               "zfsmgmt:level=#{level}" ]
+      com = [ ZfsMgmt.global_options['zfs_binary'], 'send', '-L', '-w', '-h', '-p' ]
+      if level > 0
+        if options[:intermediary]
+          com.push('-I')
+        else
+          com.push('-i')
+        end
+        com.push(zfs_snap_parent)
+        tags.push("zfsmgmt:parent=#{zfs_snap_parent}")
+      end
+      com.push( last_zfs_snapshot )
+      com.push( '|', 'mbuffer', '-m', options[:buffer], '-q' )
+      com.push( '|', options[:restic_binary], 'backup', '--stdin',
+                '--stdin-filename', zfs, '--time', "\"#{zfs_snap_time.strftime('%F %T')}\"" )
+      tags.each do |tag|
+        com.push( '--tag', "\"#{tag}\"" )
+      end
+      if options.has_key?('limit_upload')
+        com.push('--limit-upload', options['limit_upload'])
+      end
+      if options.has_key?('password_file')
+        com.push('-p',options['password_file'])
+      end
+      if options.has_key?('repo')
+        com.push('--repo', options['repo'])
+      elsif props.has_key?('zfsmgmt:restic_repository')
+        com.push( '--repo', props['zfsmgmt:restic_repository'] )
+      end
+      if options[:verbose]
+        com.push('--verbose',options[:verbose])
+      elsif $stdout.isatty
+        com.push('-v')
+      end
+      unless ZfsMgmt.zfs_holds(last_zfs_snapshot).include?('zfsmgmt_restic')
+        ZfsMgmt.zfs_hold('zfsmgmt_restic',last_zfs_snapshot)
+      end
+      $logger.info("#{com.join(' ')}")
+      system(com.join(' '))
+      chain_snaps = chain.map do |rsnap|
+        rsnap['zfsmgmt:snapshot']
+      end
+      zfs_snapshots.each do |s,d|
+        d['userrefs'] == 0 and next
+        chain_snaps.include?(s) and next
+        s == last_zfs_snapshot and next
+        if ZfsMgmt.zfs_holds(s).include?('zfsmgmt_restic')
+          ZfsMgmt.zfs_release('zfsmgmt_restic',s)
+        end
+      end
+    end
+  end
 end
 
-  

data/lib/zfs_mgmt/version.rb

@@ -1,3 +1,3 @@
 module ZfsMgmt
-  VERSION = "0.3.5"
+  VERSION = "0.3.10"
 end

data/lib/zfs_mgmt/zfs_mgr.rb

@@ -0,0 +1,6 @@
+
+module ZfsMgmt::ZfsMgr
+  require "zfs_mgmt/zfs_mgr/list"
+  require "zfs_mgmt/zfs_mgr/restic"
+  require "zfs_mgmt/zfs_mgr/snapshot"
+end

data/lib/zfs_mgmt/zfs_mgr/list.rb

@@ -0,0 +1,26 @@
+# class list
+
+class ZfsMgmt::ZfsMgr::List < Thor
+  class_option :filter, :type => :string, :default => '.+',
+               :desc => 'only act on zfs matching this regexp'
+  desc "stale", "list all zfs with stale snapshots"
+  method_option :age, :desc => "timeframe outside of which the zfs will be considered stale", :default => '1d'
+  def stale()
+    ZfsMgmt.global_options = options
+    cutoff = Time.at(Time.now.to_i -  ZfsMgmt.timespec_to_seconds(options[:age]))
+    table = Text::Table.new
+    table.head = ['zfs','snapshot','age']
+    table.rows = []
+    ZfsMgmt.zfs_managed_list(filter: options[:filter]).each do |blob|
+      zfs,props,snaps = blob
+      last = snaps.keys.sort { |a,b| snaps[a]['creation'] <=> snaps[b]['creation'] }.last
+      snap_time = Time.at(snaps[last]['creation'])
+      if snap_time < cutoff
+        table.rows << [zfs,last.split('@')[1],snap_time]
+      end
+    end
+    if table.rows.count > 0
+      print table.to_s
+    end
+  end
+end

data/lib/zfs_mgmt/zfs_mgr/restic.rb

@@ -0,0 +1,41 @@
+
+class ZfsMgmt::ZfsMgr::Backup < Thor
+  include ZfsMgmt::Restic
+  class_option :filter, :type => :string, :default => '.+',
+               :desc => 'only act on zfs matching this regexp'
+  class_option :restic_binary, :type => :string, :default => 'restic',
+               :desc => 'restic binary'
+  class_option :verbose, :alias => '-v', :type => :numeric,
+               :desc => 'verbosity level for restic'
+  class_option :buffer, :type => :string, :default => '256m',
+               :desc => 'buffer size for mbuffer'
+  class_option :password_file, :alias => '-p', :type => :string,
+               :desc => 'passed to restic'
+  class_option :limit_upload, :type => :numeric,
+               :desc => 'passed to restic'
+  class_option :repo, :type => :string,
+               :desc => 'passed to restic'
+  desc "incremental", "perform incremental backup"
+  method_option :level, :desc => "backup level in integer form", :default => 2, :type => :numeric
+  method_option :intermediary, :alias => '-I', :desc => "pass -I (intermediary) option to zfs send", :default => false, :type => :boolean
+  def incremental()
+    ZfsMgmt.global_options = options
+    ZfsMgmt::Restic.backup(backup_level: options[:level], options: options)
+  end
+  desc "differential", "perform differential backup"
+  method_option :intermediary, :alias => '-I', :desc => "pass -I (intermediary) option to zfs send", :default => false, :type => :boolean
+  def differential()
+    ZfsMgmt.global_options = options
+    ZfsMgmt::Restic.backup(backup_level: 1, options: options)
+  end
+  desc "full", "perform full backup"
+  def full()
+    ZfsMgmt.global_options = options
+    ZfsMgmt::Restic.backup(backup_level: 0, options: options)
+  end
+end
+
+class ZfsMgmt::ZfsMgr::Restic < Thor
+  desc "backup SUBCOMMAND ...ARGS", "backup all configured zfs to restic"
+  subcommand "backup", ZfsMgmt::ZfsMgr::Backup
+end

data/lib/zfs_mgmt/zfs_mgr/snapshot.rb

@@ -0,0 +1,27 @@
+# implement snapshot management
+
+class ZfsMgmt::ZfsMgr::Snapshot < Thor
+  class_option :noop, :type => :boolean, :default => false,
+               :desc => 'pass -n option to zfs commands'
+  class_option :verbose, :type => :boolean, :default => false,
+               :desc => 'pass -v option to zfs commands'
+  class_option :debug, :type => :boolean, :default => false,
+               :desc => 'set logging level to debug'
+  class_option :filter, :type => :string, :default => '.+',
+               :desc => 'only act on zfs matching this regexp'
+  desc "destroy", "apply the snapshot destroy policy to zfs"
+  def destroy()
+    ZfsMgmt.global_options = options
+    ZfsMgmt.snapshot_destroy(noop: options[:noop], verbopt: options[:verbose], debugopt: options[:debug], filter: options[:filter])
+  end
+  desc "policy", "print the policy table for zfs"
+  def policy()
+    ZfsMgmt.global_options = options
+    ZfsMgmt.snapshot_policy(verbopt: options[:verbose], debugopt: options[:debug], filter: options[:filter])
+  end
+  desc "create", "execute zfs snapshot based on zfs properties"
+  def create()
+    ZfsMgmt.global_options = options
+    ZfsMgmt.snapshot_create(verbopt: options[:verbose], debugopt: options[:debug], filter: options[:filter])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zfs_mgmt
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.10
 platform: ruby
 authors:
 - Aran Cox
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-13 00:00:00.000000000 Z
+date: 2021-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,6 +127,10 @@ files:
 - lib/zfs_mgmt.rb
 - lib/zfs_mgmt/restic.rb
 - lib/zfs_mgmt/version.rb
+- lib/zfs_mgmt/zfs_mgr.rb
+- lib/zfs_mgmt/zfs_mgr/list.rb
+- lib/zfs_mgmt/zfs_mgr/restic.rb
+- lib/zfs_mgmt/zfs_mgr/snapshot.rb
 - zfs_mgmt.gemspec
 homepage: https://github.com/aranc23/zfs_mgmt
 licenses: