zfs_mgmt 0.2.4

data/bin/zfssendman

@@ -0,0 +1,252 @@
+#! /bin/bash
+
+export PATH=$PATH:/sbin
+
+FILTER='.'
+USER='root'
+SEND='send'
+RECV='recv -e -F'
+FLOCK='/usr/bin/flock -w 60 -n 9'
+PORT='1337'
+MBUFFER='-s 128k -m 1G -4'
+USE_MBUFFER='no'
+LOCK_DIR='/var/run/'$(basename $0)
+test -d $LOCK_DIR || mkdir $LOCK_DIR
+TEST=0
+VERB=0
+
+test -f $HOME/.keychain/$HOSTNAME-sh && . $HOME/.keychain/$HOSTNAME-sh
+
+function zfssendrecv {
+    local OPTIND OPTARG opt
+    local zfs
+    local snap
+    local dest
+    local inc=''
+    local hold=0
+    while getopts "z:s:d:i:I:h" opt; do
+        case $opt in
+            z)
+                zfs=$OPTARG
+                ;;
+            s)
+                snap=$OPTARG
+                ;;
+            d)
+                dest=$OPTARG
+                ;;
+            i)
+                inc="-i ${OPTARG}"
+                ;;
+            I)
+                inc="-I ${OPTARG}"
+                ;;
+            h)
+                hold=1
+                ;;
+        esac
+    done
+    shift $((OPTIND-1))
+    local zfs_normal=$( echo $zfs|sed 's/[\:\|\/\\ ]/_/g' )
+    local lock="${LOCK_DIR}/${zfs_normal}.lock"
+    local zfs_recv_status
+    local zfs_send_status
+    local pipe_status
+    (
+        if ! $FLOCK; then
+            $ulog "unable to lock ${lock}"
+            return -2
+        fi
+        if [[ $TEST == 0 && $hold == 1 ]]; then
+            zfs hold -r zfsrecvman $snap 2>&1 | $ulog
+            local hold_status="${PIPESTATUS[0]}"
+            if [[ $hold_status != 0 ]]; then
+                $ulog "unable to place a hold on our snapshots: ${snap}"
+                return -3
+            fi
+        fi
+        $ulog "estimating size of sending ${snap}"
+        local size=$( zfs $SEND -v -n $inc $snap 2>&1 | tail -1 | cut -d" " -f 5 )
+        # could be 0 or 400 or 4K or 9.3g, etc.
+        local suf=$( echo $size | sed -E 's/[0-9]+\.?[0-9]*//' | tr '[:lower:]' '[:upper:]' )
+        size=$( echo $size | sed -E 's/[pPtTgGmMkKB]$//' ) # remove known suffixes
+	if [[ $suf != 'B' ]]; then
+        	size=$( echo "${size} * 1024" | bc | sed -E 's/\.[0-9]+//' ) # use bc to multiply decimals, sed to make ceil()
+	fi
+        case $suf in
+            B)
+		suf=''
+		;;
+            K)
+                suf=''
+                ;;
+            M)
+                suf='K'
+                ;;
+            G)
+                suf='M'
+                ;;
+            T)
+                suf='G'
+                ;;
+            P)
+                suf='T'
+                ;;
+        esac
+        $ulog "estimated size of sending ${snap} is ${size}${suf}"
+        local pv_more="-s ${size}${suf}"
+        if [[ $USE_MBUFFER == 'yes' ]]; then
+            ssh "${USER}@${REMOTE}" "mbuffer ${MBUFFER} -q -I ${PORT} | zfs ${RECV} ${dest}" 2>&1 | $ulog &
+            sleep 5
+            zfs $SEND $inc $snap 2> >($ulog)|
+            mbuffer $MBUFFER $MBUFFER_SEND_OPTS -O ${REMOTE}:${PORT}
+            zfs_send_status="${PIPESTATUS[0]}"
+            $ulog "zfs send exited with status: ${zfs_send_status}"
+            $ulog "about to wait on zfs send (this may take a while and appear to have hung)"
+            wait
+            zfs_recv_status="${PIPESTATUS[0]}"
+            $ulog "zfs recv exited with status: ${zfs_recv_status}"
+        else
+            zfs $SEND $inc $snap 2> >($ulog) | pv $PV_OPTS $pv_more | ssh "${USER}@${REMOTE}" "zfs ${RECV} ${dest}" 2>&1 | $ulog
+            pipe_status=("${PIPESTATUS[@]}")
+            zfs_send_status="${pipe_status[0]}"
+            zfs_recv_status="${pipe_status[2]}"
+            $ulog "zfs send exited with status: ${zfs_send_status}"
+            $ulog "zfs recv exited with status: ${zfs_recv_status}"
+        fi
+        if [[ $zfs_send_status != 0 ]]; then
+            return $zfs_send_status
+        elif [[ $zfs_recv_status != 0 ]]; then
+            return $zfs_recv_status
+        else
+            # both must be zero
+            return 0
+        fi
+    ) 9>$lock
+}
+
+function terminal_options {
+if [ -t 1 ]; then
+    ISTERM=1
+    LOGGER_EXTRA='-s' # enable logger output to stderr
+    PV_OPTS='-perb' # enable all the magic output from pv
+    MBUFFER_SEND_OPTS='' # don't do quiet mode, we have a term
+    ulog="logger ${LOGGER_EXTRA} -p user.notice -t "$(basename $0 2>/dev/null)"[${$}]"
+else
+    ISTERM=0
+    LOGGER_EXTRA='' # don't enable stderr output
+    PV_OPTS='-q' # make pv quiet
+    MBUFFER_SEND_OPTS='-q' # enable send side -q, no terminal
+    ulog="logger ${LOGGER_EXTRA} -p user.notice -t "$(basename $0 2>/dev/null)"[${$}]"
+fi
+}
+
+terminal_options
+
+while getopts "p:f:L:mnvr:u:d:" opt; do
+    case $opt in
+        p)
+            PORT=$OPTARG
+            ;;
+        f)
+            FILTER=$OPTARG
+            ;;
+        L)
+            PV_OPTS="${PV_OPTS} -L ${OPTARG}"
+            ;;
+        m)
+            USE_MBUFFER='yes'
+            ;;
+        n)
+            RECV="${RECV} -n"
+            TEST=1
+            VERB=1
+            PV_OPTS='-q' # make pv quiet
+            MBUFFER_SEND_OPTS='-q' # enable send side -q, no terminal
+            ;;
+        v)
+            VERB=1
+            ;;
+        r)
+            REMOTE=$OPTARG
+            ;;
+        u)
+            USER=$OPTARG
+            ;;
+        d)
+            DEST=$OPTARG
+            ;;
+            
+    esac
+done
+if [[ "${REMOTE}Z" == 'Z' ]]; then
+    echo 'must set remote with -r option'
+    exit 1;
+fi
+if [[ "${DEST}Z" == 'Z' ]]; then
+    echo 'must set dest with -d option'
+    exit 1;
+fi
+
+if [[ $VERB == 1 ]]; then
+    echo $RECV | grep -q -- -v || RECV="${RECV} -v"
+fi
+
+function set_options {
+    local zfs=$1
+    local target=$2
+    local compress=$( zfs get -H -o value compression $zfs )
+    local destroy=$( zfs get -H -o value zfssnapman:destroy $zfs )
+    ssh "${USER}@${REMOTE}" "zfs set readonly=on ${target} ; zfs set compression=${compress} ${target} ; zfs set zfssnapman:destroy=${destroy} ${target}"
+}
+
+# zfs is the filesystem to be sent, including source pool
+for zfs in $( zfs list -H -t filesystem,volume -o name,zfssendman:send | grep true | egrep "${FILTER}" | awk -F\\t '{if($2 == "true") {print $1;}}' | sort ); do
+    # base is the zfs filesystem to send, minus the pool
+    target="${DEST}/${zfs}"
+    target_dir=$( dirname $target )
+    # recv_last is the last snapshot on the recv side of this zfs
+    if ! ssh "${USER}@${REMOTE}" zfs get written $target >/dev/null 2>/dev/null; then
+        $ulog sending initial snapshot of $zfs to $target_dir
+        zfssendrecv -z $zfs \
+            -s $( zfs list -t snapshot -o name -s creation -d 1 -H $zfs | head -1 ) \
+            -d $target_dir
+        if [[ $TEST == 0 ]]; then
+            set_options $zfs $target
+        fi
+        sleep 5
+    fi
+    
+    recv_last=$( ssh "${USER}@${REMOTE}" zfs list -t snapshot -o name -s creation -d 1 -H $target | tail -1 ) || break;
+    if ! echo $recv_last | grep -q "${zfs}@"; then
+        $ulog "no snapshot on distant end, you must destroy the filesystem: $zfs"
+        break;
+    fi
+    # send is the snapshot on the recv side after stripping off the DEST
+    send=$( echo $recv_last|sed "s|$DEST/||" )
+    
+    zfs list -t snapshot -o name -d 1 -H $zfs | grep -q $send
+    if [[ $? == 0 ]]; then
+        # most recent snapshot on the send side
+        current=$( zfs list -t snapshot -o name -s creation -d 1 -H $zfs | tail -1 )
+        if [[ $send == $current ]]; then
+            $ulog "${zfs} is in sync on source and destination (${target})"
+        else
+            $ulog sending $send through $current to $target
+            zfssendrecv -z $zfs \
+                -I $send \
+                -s $current \
+                -d $target_dir
+            if [[ $? == 0 ]]; then
+                $ulog "$zfs is in sync on source and destination"
+                if [[ $TEST == 0 ]]; then
+                    set_options $zfs $target
+                fi
+            else
+                $ulog zfs exited with $? while sending $send through $current to $target
+            fi
+        fi
+    else
+        $ulog "the most recent snapshot ($recv_last) on the recv side does not exist on the send side ($send)"
+    fi
+done

data/bin/zfssnapman

@@ -0,0 +1,69 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings;
+
+use Getopt::Long;
+use POSIX qw( strftime mktime );
+
+my %months=(Jan => 0,
+             Feb => 1,
+             Mar => 2,
+             Apr => 3,
+             May => 4,
+             Jun => 5,
+             Jul => 6,
+             Aug => 7,
+             Sep => 8,
+             Oct => 9,
+             Nov => 10,
+             Dec => 11,
+            );
+
+my $DESTROY=0;
+my $SNAP=1;
+my $VERBOSE=0;
+
+GetOptions('snap!'    => \$SNAP,
+           'destroy!' => \$DESTROY,
+           'v|verbose'=> \$VERBOSE,
+          );
+
+my $time=strftime('%F%T',localtime(time()));
+$time =~ s/[\:\-]//g;
+
+foreach(`/sbin/zfs list -t filesystem,volume -o name,zfssnapman:snap,zfssnapman:destroy -H`) {
+  chomp;
+  my ($zfs,$snap,$days)=split(/\t/);
+  if($SNAP and ($snap eq 'true' or $snap eq 'on')) {
+    my $com="/sbin/zfs snapshot $zfs\@zfssnapman-$time";
+    $VERBOSE and print $com."\n";
+    system($com);
+    if($? != 0) {
+      warn "unable to create zfs snapshot for $zfs at $time";
+      warn "failed command: $com";
+    }
+  }
+  if($DESTROY and $days =~ /\d+/) {
+    foreach(`/sbin/zfs list -t snapshot -o name,creation -s creation -r -H $zfs`) {
+      chomp;
+      my ($snap,$creation)=split(/\t/);
+      next unless $snap =~ /^$zfs\@/;
+      unless($creation =~ /\s+(\w\w\w)\s+(\d+)\s+(\d+)\:(\d+)\s+(\d\d\d\d)/) {
+        die "unable to parse the date: $creation";
+      }
+      my $age=mktime(0,$4,$3,$2,$months{$1},($5-1900));
+      #printf("%s\t%s\t%s\t%d\t%s\n",strftime('%F %T',localtime(time())),$creation,strftime('%F %T',localtime($age)),$days,strftime('%F %T',localtime($age + ($days * 24 * 60 * 60 ))));
+      if(time() > ($age + ($days * 24 * 60 * 60 ))) {
+        my $comment=sprintf("removing: %s created at %s\n",$snap,strftime('%F %T',localtime($age)));
+        my $command="/sbin/zfs destroy $snap";
+        $VERBOSE and print $comment;
+        system($command);
+        if($? != 0) {
+          warn 'failed '.$comment;
+          warn "failed command: $command";
+        }
+      }
+    }
+  }
+}

data/lib/zfs_mgmt/version.rb

@@ -0,0 +1,3 @@
+module ZfsMgmt
+  VERSION = "0.2.4"
+end

data/lib/zfs_mgmt.rb

@@ -0,0 +1,314 @@
+# coding: utf-8
+require "zfs_mgmt/version"
+require 'pp'
+require 'date'
+require 'logger'
+require 'text-table'
+require 'open3'
+require 'filesize'
+
+$logger = Logger.new(STDERR)
+
+$date_patterns = {
+  'hourly' => '%F Hour %H',
+  'daily' => '%F',
+  'weekly' => '%Y Week %U', # week, starting on sunday
+  'monthly' => '%Y-%m',
+  'yearly' => '%Y',
+}
+
+$time_pattern_map = {}
+$date_patterns.keys.each do |tf|
+  $time_pattern_map[tf[0]] = tf
+end
+
+$time_specs = {
+  's' => 1,
+  'm' => 60,
+  'h' => 60*60,
+  'd' => 24*60*60,
+  'w' => 7*24*60*60,
+}
+
+$properties_xlate = {
+  'userrefs' => ->(x) { x.to_i },
+  'creation' => ->(x) { x.to_i },
+}
+
+module ZfsMgmt
+  def self.custom_properties()
+    return [
+      'policy',
+      'manage',
+      'strategy',
+      'minage',
+      'matchsnaps',
+      'ignoresnaps',
+      'snapshot',
+      'snap_prefix',
+      'snap_timestamp',
+    ].map do |p|
+      ['zfsmgmt',p].join(':')
+    end
+  end
+  def self.timespec_to_seconds(spec)
+    md = /^(\d+)([smhdw]?)/i.match(spec)
+    unless md.length == 3
+      raise 'SpecParseError'
+    end
+    if md[2] and md[2].length > 0
+      return md[1].to_i * $time_specs[md[2].downcase]
+    else
+      return md[1].to_i
+    end
+  end
+      
+  def self.zfsget(properties: ['name'],types: ['filesystem','volume'],zfs: '')
+    results={}
+    com = ['zfs', 'get', '-Hp', properties.join(','), '-t', types.join(','), zfs]
+    so,se,status = Open3.capture3(com.join(' '))
+    if status.signaled?
+      $logger.error("process was signalled \"#{com.join(' ')}\", termsig #{status.termsig}")
+      raise 'ZfsGetError'
+    end
+    unless status.success?
+      $logger.error("failed to execute \"#{com.join(' ')}\", exit status #{status.exitstatus}")
+      so.split("\n").each { |l| $logger.debug("stdout: #{l}") }
+      se.split("\n").each { |l| $logger.error("stderr: #{l}") }
+      raise 'ZfsGetError'
+    end
+    so.split("\n").each do |line|
+      params = line.split("\t")
+      unless results.has_key?(params[0])
+        results[params[0]] = {}
+      end
+      if params[2] != '-'
+        if $properties_xlate.has_key?(params[1])
+          results[params[0]][params[1]] = $properties_xlate[params[1]].call(params[2])
+        else
+          results[params[0]][params[1]] = params[2]
+        end
+      end
+      if params[3] != '-'
+        results[params[0]]["#{params[1]}@source"] = params[3]
+      end
+    end
+    return results
+  end
+  def self.local_epoch_to_datetime(e)
+    return Time.at(e).to_datetime
+  end
+  def self.find_saved_reason(saved,snap)
+    results = {}
+    $date_patterns.each do |d,dk|
+      if saved.has_key?(d)
+        saved[d].each do |k,s|
+          if snap == s
+            results[d]=k
+            break
+          end
+        end
+      end
+    end
+    return [results['hourly'],results['daily'],results['weekly'],results['monthly'],results['yearly']]
+  end
+  def self.snapshot_destroy_policy(zfs,props,snaps)
+    minage = 0
+    if props.has_key?('zfsmgmt:minage')
+      minage = timespec_to_seconds(props['zfsmgmt:minage'])
+    end
+    strategy = 'youngest'
+    if props.has_key?('zfsmgmt:strategy') and props['zfsmgmt:strategy'] == 'oldest'
+      strategy = 'oldest'
+    end
+    sorted = snaps.keys.sort { |a,b| snaps[b]['creation'] <=> snaps[a]['creation'] }
+    # never consider the latest snapshot for anything
+    newest_snapshot_name = sorted.shift
+    
+    counters = policy_parser(props['zfsmgmt:policy'])
+    $logger.debug(counters)
+    saved = {}
+
+    # set the counters variable to track the number of saved daily/hourly/etc. snapshots
+    $date_patterns.each do |d,p|
+      saved[d] = {}
+    end
+
+    sorted.each do |snap_name|
+      if  props.has_key?('zfsmgmt:ignoresnaps') and /#{props['zfsmgmt:ignoresnaps']}/ =~ snap_name.split('@')[1]
+        $logger.debug("skipping #{snap_name} because it matches ignoresnaps pattern: #{props['zfsmgmt:ignoresnaps']}")
+        next
+      end
+      if  props.has_key?('zfsmgmt:matchsnaps') and not /#{props['zfsmgmt:matchsnaps']}/ =~ snap_name.split('@')[1]
+        $logger.debug("skipping #{snap_name} because it does not match matchsnaps pattern: #{props['zfsmgmt:matchsnaps']}")
+        next
+      end
+      snaptime = local_epoch_to_datetime(snaps[snap_name]['creation'])
+      $date_patterns.each do |d,p|
+        pat = snaptime.strftime(p)
+        if saved[d].has_key?(pat)
+          if strategy == 'youngest'
+            # update the existing current save snapshot for this timeframe
+            $logger.debug("updating the saved snapshot for \"#{pat}\" to #{snap_name} at #{snaptime}")
+            saved[d][pat] = snap_name
+          else
+            $logger.debug("not updating the saved snapshot for \"#{pat}\" to #{snap_name} at #{snaptime}, we have an older snap")
+          end
+        elsif counters[d] > 0
+          # new pattern, and we want to save more snaps of this type
+          $logger.debug("new pattern \"#{pat}\" n#{counters[d]} #{d} snapshot, saving #{snap_name} at #{snaptime}")
+          counters[d] -= 1
+          saved[d][pat] = snap_name
+        end
+      end
+    end
+    
+    # create a list of unique saved snap shots
+    saved_snaps = []
+    saved.each do |d,saved|
+      saved_snaps += saved.values()
+    end
+    saved_snaps = saved_snaps.sort.uniq
+    
+    # delete everything not in the list of saved snapshots
+    deleteme = sorted - saved_snaps
+    deleteme = deleteme.select { |snap|
+      if props.has_key?('zfsmgmt:ignoresnaps') and /#{props['zfsmgmt:ignoresnaps']}/ =~ snap
+        $logger.debug("skipping #{snap} because it matches ignoresnaps pattern: #{props['zfsmgmt:ignoresnaps']}")
+        false
+      elsif minage > 0 and Time.at(snaps[snap]['creation'] + minage) > Time.now()
+        $logger.debug("skipping due to minage: #{snap} #{local_epoch_to_datetime(snaps[snap]['creation']).strftime('%F %T')}")
+        false
+      else
+        true
+      end
+    }
+    return saved,saved_snaps,deleteme
+  end
+  def self.zfs_managed_list(filter: '.+')
+    zfss = [] # array of arrays
+    zfsget(properties: custom_properties()).each do |zfs,props|
+      unless /#{filter}/ =~ zfs
+        next
+      end
+      unless props.has_key?('zfsmgmt:manage') and props['zfsmgmt:manage'] == 'true'
+        next
+      end
+      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
+  end
+  def self.snapshot_policy(verbopt: false, debugopt: false, filter: '.+')
+    if debugopt
+      $logger.level = Logger::DEBUG
+    else
+      $logger.level = Logger::INFO
+    end
+    zfs_managed_list(filter: filter).each do |zdata|
+      (zfs,props,snaps) = zdata
+      # call the function that decides who to save and who to delete
+      (saved,saved_snaps,deleteme) = snapshot_destroy_policy(zfs,props,snaps)
+
+      if saved_snaps.length == 0
+        $logger.info("no snapshots marked as saved by policy for #{zfs}")
+        next
+      end
+      # print a table of saved snapshots with the reasons it is being saved
+      table = Text::Table.new
+      table.head = ['snap','creation','hourly','daily','weekly','monthly','yearly']
+      table.rows = []
+      saved_snaps.sort { |a,b| snaps[b]['creation'] <=> snaps[a]['creation'] }.each do |snap|
+        table.rows << [snap,local_epoch_to_datetime(snaps[snap]['creation'])] + find_saved_reason(saved,snap)
+      end
+      print table.to_s
+    end
+  end
+  def self.snapshot_destroy(noop: false, verbopt: false, debugopt: false, filter: '.+')
+    if debugopt
+      $logger.level = Logger::DEBUG
+    else
+      $logger.level = Logger::INFO
+    end
+    zfs_managed_list(filter: filter).each do |zdata|
+      (zfs,props,snaps) = zdata
+      # call the function that decides who to save and who to delete
+      (saved,saved_snaps,deleteme) = snapshot_destroy_policy(zfs,props,snaps)
+    
+      $logger.info("deleting #{deleteme.length} snapshots for #{zfs}")
+      com_base = "zfs destroy -p"
+      if noop
+        com_base = "#{com_base}n"
+      end
+      if verbopt
+        com_base = "#{com_base}v"
+      end
+      deleteme.reverse! # oldest first for removal
+      deleteme.each do |snap_name|
+        $logger.debug("delete: #{snap_name} #{local_epoch_to_datetime(snaps[snap_name]['creation']).strftime('%F %T')}")
+      end
+      while deleteme.length > 0
+        for i in 0..(deleteme.length - 1) do
+          max = deleteme.length - 1 - i
+          $logger.debug("attempting to remove snaps 0 through #{max} out of #{deleteme.length} snapshots")
+          bigarg = "#{zfs}@#{deleteme[0..max].map { |s| s.split('@')[1] }.join(',')}"
+          com = "#{com_base} #{bigarg}"
+          $logger.debug("size of bigarg: #{bigarg.length} size of com: #{com.length}")
+          if bigarg.length >= 131072 or com.length >= (2097152-10000)
+            next
+          end
+          $logger.info(com)
+          deleteme = deleteme - deleteme[0..max]
+          system(com)
+          break
+        end
+      end
+    end
+  end
+  # parse a policy string into a hash of integers
+  def self.policy_parser(str)
+    res = {}
+    $date_patterns.keys.each do |tf|
+      res[tf]=0
+    end
+    p = str.scan(/\d+[#{$time_pattern_map.keys.join('')}]/i)
+    unless p.length > 0
+      raise "unable to parse the policy configuration #{str}"
+    end
+    p.each do |pi|
+      scn = /(\d+)([#{$time_pattern_map.keys.join('')}])/i.match(pi)
+      res[$time_pattern_map[scn[2].downcase]] = scn[1].to_i
+    end
+    res
+  end
+  def self.snapshot_create(noop: false, verbopt: false, debugopt: false, filter: '.+')
+    if debugopt
+      $logger.level = Logger::DEBUG
+    else
+      $logger.level = Logger::INFO
+    end
+    dt = DateTime.now
+    zfsget(properties: custom_properties()).each do |zfs,props|
+      # zfs must have snapshot set to true or recursive
+      if props.has_key?('zfsmgmt:snapshot') and props['zfsmgmt:snapshot'] == 'true' or ( props['zfsmgmt:snapshot'] == 'recursive' and props['zfsmgmt:snapshot@source'] == 'local' )
+        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']
+        if props['zfsmgmt:snapshot'] == 'recursive' and props['zfsmgmt:snapshot@source'] == 'local'
+          com.push('-r')
+        end
+        com.push("#{zfs}@#{[prefix,dt.strftime(ts)].join('-')}")
+        $logger.info(com)
+        system(com.join(' '))
+      end
+    end
+  end
+end

data/zfs_mgmt.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "zfs_mgmt/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "zfs_mgmt"
+  spec.version       = ZfsMgmt::VERSION
+  spec.licenses      = ['GPL-3.0-or-later']
+  spec.authors       = ["Aran Cox"]
+  spec.email         = ["arancox@gmail.com"]
+
+  spec.summary       = %q{Misc. helpers regarding snapshots and send/recv.}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = 'https://github.com/aranc23/zfs_mgmt'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage
+    spec.metadata["changelog_uri"] = spec.homepage << '/commits/'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = ['readsnaps','zfssendman','zfssnapman','zfsrecvman','zfs-list-snapshots','zfsmgr']
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "thor", "~> 1.0.1"
+  spec.add_development_dependency "text-table", "~> 1.2.4"
+  spec.add_development_dependency "filesize", "~> 0.2.0"
+  
+end