Implement DESTROY_AFTER optional argument for bin/zfs-auto-snapshot.

README.md

@@ -24,10 +24,13 @@ This will handle automatically snapshotting datasets similar to time-sliderd fro
 
 ### Usage
 
- /usr/local/bin/zfs-auto-snapshot INTERVAL KEEP
+ /usr/local/bin/zfs-auto-snapshot INTERVAL KEEP [DESTROY_AFTER]
 
 * INTERVAL - The interval for the snapshot. This is something such as `frequent`, `hourly`, `daily`, `weekly`, `monthly`, etc.
 * KEEP - How many to keep for this INTERVAL. Older ones will be destroyed.
+* DESTROY_AFTER - Create snapshot[s] with maximum lifetime of DESTROY_AFTER days starting from invocation timestamp.
+Snapshot with an expired `zfstools:destroy_after` property will be deleted upon first `zfs-auto-snapshot` invocation with no relation to KEEP argument.
+Userful for snapshots that are created upon non-recurring events (e.g. on boot or manually) so they do not stuck on the pool forever.
 
 #### Crontab
 
@@ -36,6 +39,7 @@ This will handle automatically snapshotting datasets similar to time-sliderd fro
  7 0 * * * root /usr/local/bin/zfs-auto-snapshot daily 7
  14 0 * * 7 root /usr/local/bin/zfs-auto-snapshot weekly 4
  28 0 1 * * root /usr/local/bin/zfs-auto-snapshot monthly 12
+ @reboot root /usr/local/bin/zfs-auto-snapshot boot 3 30
 
 #### Dataset setup
 
@@ -101,7 +105,9 @@ The `zfs-auto-snapshot` script will automatically flush the tables before saving
 
 ### zfs-cleanup-snapshots
 
-Cleans up zero-sized snapshots. This ignores snapshots created by `zfs-auto-snapshot` as it handles zero-sized in its own special way.
+Cleans up:
+* zero-sized snapshots created not by `zfs-auto-snapshot` as it handles zero-sized in its own special way;
+* snapshots with an expired `zfstools:destroy_after` property.
 
 #### Usage
 

bin/zfs-auto-snapshot

@@ -45,7 +45,7 @@ end
 
 def usage
  puts <<-EOF
-Usage: #{$0} [-dknpuv] <INTERVAL> <KEEP>
+Usage: #{$0} [-dknpuv] <INTERVAL> <KEEP> [DESTROY_AFTER]
  EOF
  format = " %-15s %s"
  puts format % ["-d", "Show debug output."]
@@ -58,18 +58,26 @@ Usage: #{$0} [-dknpuv] <INTERVAL> <KEEP>
  puts format % ["-v", "Show what is being done."]
  puts format % ["INTERVAL", "The interval to snapshot."]
  puts format % ["KEEP", "How many snapshots to keep."]
+ puts format % ["DESTROY_AFTER", "Unix timestamp of deadtime for snapshots. Snapshots will be deleted after that timestamp by this utility."]
  exit
 end
 
 usage if ARGV.length < 2
 
 interval=ARGV[0]
 keep=ARGV[1].to_i
+destroy_after=nil
+if ARGV.length == 3
+ destroy_after = (Time.now.to_i + 24*3600*Integer(ARGV[2])) rescue usage
+end
 
 datasets = find_eligible_datasets(interval, pool)
 
 # Generate new snapshots
-do_new_snapshots(datasets, interval) if keep > 0
+do_new_snapshots(datasets, interval, destroy_after) if keep > 0
+
+# Remove all snapshots with expired destroy_after attribute
+cleanup_attr_expired_snapshots(pool)
 
 # Delete expired
 cleanup_expired_snapshots(pool, datasets, interval, keep, should_destroy_zero_sized_snapshots)

bin/zfs-cleanup-snapshots

@@ -53,3 +53,6 @@ snapshots = Zfs::Snapshot.list(pool, {'recursive' => true}).select { |snapshot|
 datasets = Zfs::Dataset.list(pool)
 dataset_snapshots = group_snapshots_into_datasets(snapshots, datasets)
 dataset_snapshots = datasets_destroy_zero_sized_snapshots(dataset_snapshots)
+
+# Remove all snapshots with expired destroy_after attribute
+cleanup_attr_expired_snapshots(pool)

lib/zfstools.rb

@@ -28,6 +28,10 @@ def snapshot_format
  '%Y-%m-%d-%Hh%M'
 end
 
+def destroy_after_property
+ "zfstools:destroy_after"
+end
+
 ### Get the name of the snapshot to create
 def snapshot_name(interval)
  if $use_utc
@@ -147,13 +151,16 @@ def find_eligible_datasets(interval, pool)
 end
 
 ### Generate new snapshots
-def do_new_snapshots(datasets, interval)
+def do_new_snapshots(datasets, interval, destroy_after=nil)
  snapshot_name = snapshot_name(interval)
+ options = {}
+ options['destroy_after'] = destroy_after if destroy_after
 
  # Snapshot single
- Zfs::Snapshot.create_many(snapshot_name, datasets['single'])
+ Zfs::Snapshot.create_many(snapshot_name, datasets['single'], options)
  # Snapshot recursive
- Zfs::Snapshot.create_many(snapshot_name, datasets['recursive'], 'recursive'=>true)
+ options['recursive'] = true
+ Zfs::Snapshot.create_many(snapshot_name, datasets['recursive'], options)
 end
 
 def group_snapshots_into_datasets(snapshots, datasets)
@@ -226,3 +233,19 @@ def cleanup_expired_snapshots(pool, datasets, interval, keep, should_destroy_zer
  end
  threads.each { |th| th.join }
 end
+
+### Find and destroy snapshots with zfstools:destroy_after attribute expired
+### Should be invoked before cleanup_expired_snapshots as we prefer to delete
+### snapshots with zfstools:destroy_after expired rather that by count.
+def cleanup_attr_expired_snapshots(pool)
+ current_timestamp = Time.now.to_i;
+ attr_expired_snapshots = Zfs::Snapshot.list(pool, {'recursive' => true}).select { |snapshot| snapshot.destroy_after?(current_timestamp) }
+ threads = []
+ attr_expired_snapshots.each do |snapshot|
+ threads << Thread.new do
+ snapshot.destroy
+ end
+ threads.last.join unless $use_threads
+ end
+ threads.each { |th| th.join }
+end

lib/zfstools/snapshot.rb

@@ -6,9 +6,10 @@ module Zfs
  class Snapshot
  @@stale_snapshot_size = false
  attr_reader :name
- def initialize(name, used=nil)
+ def initialize(name, used=nil, destroy_after=nil)
  @name = name
  @used = used
+ @destroy_after = destroy_after
  end
 
  def used
@@ -27,19 +28,25 @@ def is_zero?
  used
  end
 
+ def destroy_after?(timestamp)
+ return false if @destroy_after.nil? || @destroy_after > timestamp
+ true
+ end
+
  ### List all snapshots
  def self.list(dataset=nil, options={})
  snapshots = []
  flags=[]
  flags << "-d 1" if dataset and !options['recursive']
  flags << "-r" if options['recursive']
- cmd = "zfs list #{flags.join(" ")} -H -t snapshot -o name,used -S name"
+ cmd = "zfs list #{flags.join(" ")} -H -t snapshot -o name,used,#{destroy_after_property} -S name"
  cmd += " " + dataset.shellescape if dataset
  puts cmd if $debug
  IO.popen cmd do |io|
  io.readlines.each do |line|
- snapshot_name,used = line.chomp.split("\t")
- snapshots << self.new(snapshot_name, used.to_i)
+ snapshot_name,used,destroy_after = line.chomp.split("\t")
+ destroy_after = Integer(destroy_after) rescue nil
+ snapshots << self.new(snapshot_name, used.to_i, destroy_after)
  end
  end
  snapshots
@@ -49,6 +56,7 @@ def self.list(dataset=nil, options={})
  def self.create(snapshot, options = {})
  flags=[]
  flags << "-r" if options['recursive']
+ flags << "-o #{destroy_after_property}=" + options['destroy_after'].to_s if options['destroy_after']
  cmd = "zfs snapshot #{flags.join(" ")} "
  if snapshot.kind_of?(Array)
  cmd += snapshot.shelljoin
@@ -129,9 +137,11 @@ def self.create_many(snapshot_name, datasets, options={})
  threads = []
  datasets.each do |dataset|
  threads << Thread.new do
- self.create("#{dataset.name}@#{snapshot_name}",
+ self.create("#{dataset.name}@#{snapshot_name}", {
  'recursive' => options['recursive'] || false,
- 'db' => dataset.db)
+ 'db' => dataset.db,
+ 'destroy_after' => options['destroy_after'] || false,
+ })
  end
  threads.last.join unless $use_threads
  end