zfstools 0.1.0 → 0.2.0

data/README.md

@@ -6,6 +6,12 @@ Various scripts for administrating ZFS. Modeled after [time-sliderd](http://mail
 
 Install the gem.
 
+## Production version
+
+    gem install zfstools
+
+### Development version
+
     rake install
 
 Setup crontab entries for scripts wanted. See below.
@@ -37,6 +43,12 @@ Only datasets with the `com.sun:auto-snapshot` property set to `true` will be sn
 
     zfs set com.sun:auto-snapshot=true DATASET
 
+##### MySQL Support
+
+Setting a MySQL dataset's property to `mysql` will hook it into the `zfs-snapshot-mysql` script. See its section for setup instructions.
+
+    zfs set com.sun:auto-snapshot=mysql DATASET
+
 ##### Overrides
 
 You can override a child dataset to use, or not use auto snapshotting by settings its flag with the given interval.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/bin/zfs-auto-snapshot

@@ -7,29 +7,46 @@ require 'getoptlong'
 require 'zfstools'
 
 opts = GetoptLong.new(
-  [ "--utc",       "-u",           GetoptLong::NO_ARGUMENT ],
-  [ "--dry-run",   "-n",           GetoptLong::NO_ARGUMENT ]
+  [ "--utc",                             "-u",           GetoptLong::NO_ARGUMENT ],
+  [ "--keep-zero-sized-snapshots",       "-k",           GetoptLong::NO_ARGUMENT ],
+  [ "--parallel-snapshots",              "-p",           GetoptLong::NO_ARGUMENT ],
+  [ "--dry-run",                         "-n",           GetoptLong::NO_ARGUMENT ],
+  [ "--verbose",                         "-v",           GetoptLong::NO_ARGUMENT ],
+  [ "--debug",                           "-d",           GetoptLong::NO_ARGUMENT ]
 )
 
 $use_utc = false
 $dry_run = false
+should_destroy_zero_sized_snapshots = true
 opts.each do |opt, arg|
   case opt
   when '--utc'
     $use_utc = true
+  when '--keep-zero-sized-snapshots'
+    should_destroy_zero_sized_snapshots = false
+  when '--parallel-snapshots'
+    $use_threads = true
   when '--dry-run'
     $dry_run = true
+  when '--verbose'
+    $verbose = true
+  when '--debug'
+    $debug = true
   end
 end
 
 
 def usage
   puts <<-EOF
-Usage: $0 [-un] <INTERVAL> <KEEP>
+Usage: $0 [-dknpuv] <INTERVAL> <KEEP>
   EOF
   format = "    %-15s %s"
-  puts format % ["-u", "Use UTC for snapshots."]
+  puts format % ["-d", "Show debug output."]
+  puts format % ["-k", "Keep zero-sized snapshots."]
   puts format % ["-n", "Do a dry-run. Nothing is committed. Only show what would be done."]
+  puts format % ["-p", "Create snapshots in parallel."]
+  puts format % ["-u", "Use UTC for snapshots."]
+  puts format % ["-v", "Show what is being done."]
   puts format % ["INTERVAL", "The interval to snapshot."]
   puts format % ["KEEP", "How many snapshots to keep."]
   exit
@@ -40,8 +57,10 @@ usage if ARGV.length < 2
 interval=ARGV[0]
 keep=ARGV[1].to_i
 
+datasets = find_eligible_datasets(interval)
+
 # Generate new snapshots
-do_new_snapshots(interval) if keep > 0
+do_new_snapshots(datasets, interval) if keep > 0
 
 # Delete expired
-cleanup_expired_snapshots(interval, keep)
+cleanup_expired_snapshots(datasets, interval, keep, should_destroy_zero_sized_snapshots)

data/bin/zfs-cleanup-snapshots

@@ -7,32 +7,43 @@ require 'getoptlong'
 require 'zfstools'
 
 opts = GetoptLong.new(
-  [ "--dry-run",   "-n",           GetoptLong::NO_ARGUMENT ]
+  [ "--parallel-snapshots",              "-p",           GetoptLong::NO_ARGUMENT ],
+  [ "--dry-run",                         "-n",           GetoptLong::NO_ARGUMENT ],
+  [ "--verbose",                         "-v",           GetoptLong::NO_ARGUMENT ],
+  [ "--debug",                           "-d",           GetoptLong::NO_ARGUMENT ]
 )
 
 $dry_run = false
+$use_threads = false
 opts.each do |opt, arg|
   case opt
   when '--dry-run'
     $dry_run = true
+  when '--parallel-snapshots'
+    $use_threads = true
+  when '--verbose'
+    $verbose = true
+  when '--debug'
+    $debug = true
   end
 end
 
 
 def usage
   puts <<-EOF
-Usage: $0 [-n]
+Usage: $0 [-dnv]
   EOF
   format = "    %-15s %s"
+  puts format % ["-d", "Show debug output."]
   puts format % ["-n", "Do a dry-run. Nothing is committed. Only show what would be done."]
+  puts format % ["-v", "Show what is being done."]
   exit
 end
 
 usage if ARGV.length > 0
 
-snapshots = Zfs::Snapshot.find.select { |snapshot| snapshot.used == 0 and !snapshot.name.include?(snapshot_prefix) }
-dataset_snapshots = group_snapshots_into_datasets(snapshots)
+snapshots = Zfs::Snapshot.list.select { |snapshot| snapshot.used == 0 and !snapshot.name.include?(snapshot_prefix) }
 ## Group into datasets
-dataset_snapshots.each do |dataset, snapshots|
-  destroy_zero_sized_snapshots(snapshots)
-end
+datasets = Zfs::Dataset.list
+dataset_snapshots = group_snapshots_into_datasets(snapshots, datasets)
+dataset_snapshots = datasets_destroy_zero_sized_snapshots(dataset_snapshots)

data/bin/zfs-snapshot-mysql

@@ -7,7 +7,9 @@ require 'getoptlong'
 require 'zfstools'
 
 opts = GetoptLong.new(
-  [ "--dry-run",   "-n",           GetoptLong::NO_ARGUMENT ]
+  [ "--dry-run",   "-n",           GetoptLong::NO_ARGUMENT ],
+  [ "--verbose",   "-v",           GetoptLong::NO_ARGUMENT ],
+  [ "--debug",     "-d",           GetoptLong::NO_ARGUMENT ]
 )
 
 $dry_run = false
@@ -15,16 +17,22 @@ opts.each do |opt, arg|
   case opt
   when '--dry-run'
     $dry_run = true
+  when '--verbose'
+    $verbose = true
+  when '--debug'
+    $debug = true
   end
 end
 
 
 def usage
   puts <<-EOF
-Usage: $0 [-n] DATASET
+Usage: $0 [-dnv] DATASET
   EOF
   format = "    %-15s %s"
+  puts format % ["-d", "Show debug output."]
   puts format % ["-n", "Do a dry-run. Nothing is committed. Only show what would be done."]
+  puts format % ["-v", "Show what is being done."]
   exit
 end
 
@@ -34,15 +42,5 @@ dataset=ARGV[0]
 
 snapshot_format = "%Y-%m-%dT%H:%M:%S"
 snapshot_name = Time.now.strftime(snapshot_format)
-snapshot_name = "#{dataset}@#{snapshot_name}"
-
-sql_query=%Q[
-  FLUSH LOGS;
-  FLUSH TABLES WITH READ LOCK;
-  SYSTEM zfs snapshot -r #{snapshot_name};
-  UNLOCK TABLES;
-]
-
-cmd = %Q!mysql -e "#{sql_query}"!
-puts cmd
-system cmd unless $dry_run
+snapshot = "#{dataset}@#{snapshot_name}"
+Zfs::Snapshot.create(snapshot, 'db' => 'mysql', 'recursive' => true)

data/lib/zfs/dataset.rb

@@ -0,0 +1,44 @@
+module Zfs
+  class Dataset
+    attr_reader :name
+    attr_reader :properties
+    attr_reader :db
+    def initialize(name, properties={}, options={})
+      @name = name
+      @properties = properties
+      if properties[snapshot_property] == "mysql"
+        self.contains_db!(properties[snapshot_property])
+      end
+    end
+
+    def ==(dataset)
+      dataset.equal?(self) || (dataset && dataset.name == @name)
+    end
+
+    def contains_db!(kind)
+      @db = kind
+      self
+    end
+
+    def self.list(properties=[])
+      datasets = []
+      cmd_properties = ["name"] + properties
+      cmd="zfs list -H -t filesystem,volume -o #{cmd_properties.join(",")} -s name"
+      puts cmd if $debug
+      IO.popen cmd do |io|
+        io.readlines.each do |line|
+          values = line.split
+          name = values.shift
+          dataset_properties = {}
+          properties.each_with_index do |property_name, i|
+            value = values[i]
+            next if value == '-'
+            dataset_properties[property_name] = value
+          end
+          datasets << self.new(name, dataset_properties)
+        end
+      end
+      datasets
+    end
+  end
+end

data/lib/zfs/snapshot.rb

@@ -10,23 +10,33 @@ module Zfs
     def used
       if @used.nil? or @@stale_snapshot_size
         cmd = "zfs get -Hp -o value used #{@name}"
+        puts cmd if $debug
         @used = %x[#{cmd}].to_i
       end
       @used
     end
 
-    ### Find all snapshots in the given interval
-    ### @param String match_on The string to match on snapshots
-    def self.find(match_on=nil)
+    def is_zero?
+      if @used != 0
+        return false
+      end
+      used
+    end
+
+    ### List all snapshots
+    def self.list(dataset=nil, options={})
       snapshots = []
-      cmd = "zfs list -H -t snapshot -o name,used -S name"
+      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 += " #{dataset}" if dataset
+      puts cmd if $debug
       IO.popen cmd do |io|
         io.readlines.each do |line|
           line.chomp!
-          if match_on.nil? or line.include?(match_on)
-            snapshot_name,used = line.split(' ')
-            snapshots << self.new(snapshot_name, used.to_i)
-          end
+          snapshot_name,used = line.split(' ')
+          snapshots << self.new(snapshot_name, used.to_i)
         end
       end
       snapshots
@@ -37,7 +47,22 @@ module Zfs
       flags=[]
       flags << "-r" if options['recursive']
       cmd = "zfs snapshot #{flags.join(" ")} #{snapshot}"
-      puts cmd
+
+      if options['db']
+        case options['db']
+        when 'mysql'
+          sql_query=<<-EOF.gsub(/^ {10}/, '')
+
+            FLUSH LOGS;
+            FLUSH TABLES WITH READ LOCK;
+            SYSTEM #{cmd};
+            UNLOCK TABLES;
+          EOF
+          cmd = %Q[mysql -e "#{sql_query}"]
+        end
+      end
+
+      puts cmd if $debug || $verbose
       system(cmd) unless $dry_run
     end
 
@@ -50,7 +75,7 @@ module Zfs
       flags=["-d"]
       flags << "-r" if options['recursive']
       cmd = "zfs destroy #{flags.join(" ")} #{@name}"
-      puts cmd
+      puts cmd if $debug
       system(cmd) unless $dry_run
     end
 

data/lib/zfstools.rb

@@ -1,6 +1,11 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'zfs/snapshot'
+require 'zfs/dataset'
+
+def snapshot_property
+  "com.sun:auto-snapshot"
+end
 
 def snapshot_prefix(interval=nil)
   prefix = "zfs-auto-snap"
@@ -24,27 +29,6 @@ def snapshot_name(interval)
   snapshot_prefix(interval) + date
 end
 
-### Find eligible datasets
-def find_datasets(datasets, property)
-  cmd="zfs list -H -t filesystem,volume -o name,#{property} -s name"
-  all_datasets = datasets['included'] + datasets['excluded']
-
-  IO.popen cmd do |io|
-    io.readlines.each do |line|
-      dataset,value = line.split(" ")
-      # Skip datasets with no value set
-      next if value == "-"
-      # If the dataset is already included/excluded, skip it (for override checking)
-      next if all_datasets.include? dataset
-      if value == "true"
-        datasets['included'] << dataset
-      elsif value == "false"
-        datasets['excluded'] << dataset
-      end
-    end
-  end
-end
-
 ### Find which datasets can be recursively snapshotted
 ### single snapshot restrictions apply to datasets that have a child in the excluded list
 def find_recursive_datasets(datasets)
@@ -57,7 +41,7 @@ def find_recursive_datasets(datasets)
   datasets['included'].each do |dataset|
     excluded_child = false
     # Find all children_datasets
-    children_datasets = all_datasets.select { |child_dataset| child_dataset.start_with? dataset }
+    children_datasets = all_datasets.select { |child_dataset| child_dataset.name.start_with? dataset.name }
     children_datasets.each do |child_dataset|
       if datasets['excluded'].include?(child_dataset)
         excluded_child = true
@@ -72,9 +56,9 @@ def find_recursive_datasets(datasets)
 
   ## Cleanup recursive
   recursive.each do |dataset|
-    if dataset.include?('/')
-      parts = dataset.rpartition('/')
-      parent = parts[0]
+    if dataset.name.include?('/')
+      parts = dataset.name.rpartition('/')
+      parent = all_datasets.find { |dataset| dataset.name == parts[0] }
     else
       parent = dataset
     end
@@ -89,43 +73,96 @@ def find_recursive_datasets(datasets)
     cleaned_recursive << dataset unless recursive.include?(parent)
   end
 
+  # If any children have a DB, need to set it in the recursive parent
+  cleaned_recursive.each do |parent|
+    all_datasets.each do |dataset|
+      # Is this dataset a child of the parent?
+      next if !dataset.name.include?(parent.name)
+      # If this dataset has a DB, set the parent to contain it as well.
+      if dataset.db
+        parent.contains_db!(dataset.db)
+      end
+    end
+  end
+
 
-  { 'single' => single, 'recursive' => cleaned_recursive }
+  {
+    'single' => single,
+    'recursive' => cleaned_recursive,
+    'included' => datasets['included'],
+    'excluded' => datasets['excluded'],
+  }
 end
 
-### Generate new snapshots
-def do_new_snapshots(interval)
-  datasets = {
+
+### Find eligible datasets
+def filter_datasets(datasets, included_excluded_datasets, property)
+  all_datasets = included_excluded_datasets['included'] + included_excluded_datasets['excluded']
+
+  datasets.each do |dataset|
+    # If the dataset is already included/excluded, skip it (for override checking)
+    next if all_datasets.include? dataset
+    value = dataset.properties[property]
+    if value == "true" || value == "mysql"
+      included_excluded_datasets['included'] << dataset
+    elsif value
+      included_excluded_datasets['excluded'] << dataset
+    end
+  end
+end
+
+def find_eligible_datasets(interval)
+  properties = [
+    "#{snapshot_property}:#{interval}",
+    snapshot_property,
+  ]
+  datasets = Zfs::Dataset.list(properties)
+
+  ### Group datasets into included/excluded for snapshotting
+  included_excluded_datasets = {
     'included' => [],
     'excluded' => [],
   }
 
-  snapshot_name = snapshot_name(interval)
-
   # Gather the datasets given the override property
-  find_datasets datasets, "com.sun:auto-snapshot:#{interval}"
+  filter_datasets datasets, included_excluded_datasets, "#{snapshot_property}:#{interval}"
   # Gather all of the datasets without an override
-  find_datasets datasets, "com.sun:auto-snapshot"
+  filter_datasets datasets, included_excluded_datasets, snapshot_property
 
   ### Determine which datasets can be snapshotted recursively and which not
-  datasets = find_recursive_datasets datasets
+  datasets = find_recursive_datasets included_excluded_datasets
+end
+
+### Generate new snapshots
+def do_new_snapshots(datasets, interval)
+  snapshot_name = snapshot_name(interval)
 
+  threads = []
   # Snapshot single
   datasets['single'].each do |dataset|
-    Zfs::Snapshot.create("#{dataset}@#{snapshot_name}")
+    threads << Thread.new do
+      Zfs::Snapshot.create("#{dataset.name}@#{snapshot_name}", 'db' => dataset.db)
+    end
+    threads.last.join unless $use_threads
   end
 
   # Snapshot recursive
   datasets['recursive'].each do |dataset|
-    Zfs::Snapshot.create("#{dataset}@#{snapshot_name}", 'recursive' => true)
+    threads << Thread.new do
+      Zfs::Snapshot.create("#{dataset.name}@#{snapshot_name}", 'recursive' => true, 'db' => dataset.db)
+    end
+    threads.last.join unless $use_threads
   end
+
+  threads.each { |th| th.join }
 end
 
-def group_snapshots_into_datasets(snapshots)
+def group_snapshots_into_datasets(snapshots, datasets)
   dataset_snapshots = Hash.new {|h,k| h[k] = [] }
   ### Sort into datasets
   snapshots.each do |snapshot|
-    dataset = snapshot.name.split('@')[0]
+    snapshot_name = snapshot.name.split('@')[0]
+    dataset = datasets.find { |dataset| dataset.name == snapshot_name }
     dataset_snapshots[dataset] << snapshot
   end
   dataset_snapshots
@@ -137,8 +174,8 @@ def destroy_zero_sized_snapshots(snapshots)
   saved_snapshot = snapshots.shift(1)
   remaining_snapshots = [saved_snapshot]
   snapshots.each do |snapshot|
-    if snapshot.used == 0
-      puts "Destroying zero-sized snapshot: #{snapshot.name}"
+    if snapshot.is_zero?
+      puts "Destroying zero-sized snapshot: #{snapshot.name}" if $verbose
       snapshot.destroy
     else
       remaining_snapshots << snapshot
@@ -147,17 +184,32 @@ def destroy_zero_sized_snapshots(snapshots)
   remaining_snapshots
 end
 
-### Find and destroy expired snapshots
-def cleanup_expired_snapshots(interval, keep)
-  ### Find all snapshots matching this interval
-  snapshots = Zfs::Snapshot.find snapshot_prefix(interval)
-  dataset_snapshots = group_snapshots_into_datasets(snapshots)
-
+def datasets_destroy_zero_sized_snapshots(dataset_snapshots)
   ### Cleanup zero-sized snapshots before purging old snapshots
   ### Keep the most recent one of the zeros and restore it for the later expired purging
+  threads = []
   dataset_snapshots.each do |dataset, snapshots|
-    ## Delete all of the remaining zero-sized snapshots
-    dataset_snapshots[dataset] = destroy_zero_sized_snapshots(snapshots)
+    ## Safe to run this in a thread as each dataset's snapshots shift on themselves, but not outside.
+    threads << Thread.new do
+      ## Delete all of the remaining zero-sized snapshots
+      dataset_snapshots[dataset] = destroy_zero_sized_snapshots(snapshots)
+    end
+    threads.last.join unless $use_threads
+  end
+  threads.each { |th| th.join }
+  dataset_snapshots
+end
+
+### Find and destroy expired snapshots
+def cleanup_expired_snapshots(datasets, interval, keep, should_destroy_zero_sized_snapshots)
+  ### Find all snapshots matching this interval
+  snapshots = Zfs::Snapshot.list.select { |snapshot| snapshot.name.include?(snapshot_prefix(interval)) }
+  dataset_snapshots = group_snapshots_into_datasets(snapshots, datasets['included'] + datasets['excluded'])
+  ### Filter out datasets not included
+  dataset_snapshots.select! { |dataset, snapshots| datasets['included'].include?(dataset) }
+
+  if should_destroy_zero_sized_snapshots
+    dataset_snapshots = datasets_destroy_zero_sized_snapshots(dataset_snapshots)
   end
 
   ### Now that zero-sized are removed, remove expired snapshots
@@ -166,7 +218,12 @@ def cleanup_expired_snapshots(interval, keep)
     dataset_snapshots[dataset].shift(keep)
     # ... Now the list only contains snapshots eligible to be destroyed.
   end
+  threads = []
   dataset_snapshots.values.flatten.each do |snapshot|
-    snapshot.destroy
+    threads << Thread.new do
+      snapshot.destroy
+    end
+    threads.last.join unless $use_threads
   end
+  threads.each { |th| th.join }
 end

data/spec/zfstools_spec.rb

@@ -1,7 +1,251 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Zfstools" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+describe "Zfstools", "#group_snapshots_into_datasets" do
+  it "Groups snapshots into their datasets" do
+    snapshots = {
+      'tank' => [
+        Zfs::Snapshot.new('tank@1'),
+        Zfs::Snapshot.new('tank@2'),
+      ],
+      'tank/a' => [
+        Zfs::Snapshot.new('tank/a@1'),
+        Zfs::Snapshot.new('tank/a@2'),
+      ],
+      'tank/a/1' => [
+        Zfs::Snapshot.new('tank/a/1@1'),
+      ],
+      'tank/a/2' => [
+        Zfs::Snapshot.new('tank/a/2@1'),
+      ],
+      'tank/b' => [
+        Zfs::Snapshot.new('tank/b@1'),
+      ],
+      'tank/c' => [
+        Zfs::Snapshot.new('tank/c@1'),
+      ],
+      'tank/d' => [
+        Zfs::Snapshot.new('tank/d@1'),
+      ],
+      'tank/d/1' => [
+        Zfs::Snapshot.new('tank/d/1@2'),
+      ]
+    }
+    datasets = {
+      'tank' => Zfs::Dataset.new('tank'),
+      'tank/a' => Zfs::Dataset.new('tank/a'),
+      'tank/a/1' => Zfs::Dataset.new('tank/a/1'),
+      'tank/a/2' => Zfs::Dataset.new('tank/a/2'),
+      'tank/b' => Zfs::Dataset.new('tank/b'),
+      'tank/c' => Zfs::Dataset.new('tank/c'),
+      'tank/d' => Zfs::Dataset.new('tank/d'),
+      'tank/d/1' => Zfs::Dataset.new('tank/d/1'),
+    }
+    dataset_snapshots = group_snapshots_into_datasets(snapshots.values.flatten, datasets.values)
+    dataset_snapshots.should eq({
+      datasets['tank'] => snapshots['tank'],
+      datasets['tank/a'] => snapshots['tank/a'],
+      datasets['tank/a/1'] => snapshots['tank/a/1'],
+      datasets['tank/a/2'] => snapshots['tank/a/2'],
+      datasets['tank/b'] => snapshots['tank/b'],
+      datasets['tank/c'] => snapshots['tank/c'],
+      datasets['tank/d'] => snapshots['tank/d'],
+      datasets['tank/d/1'] => snapshots['tank/d/1'],
+    })
+  end
+
+end
+
+describe "Zfstools", "#find_recursive_datasets" do
+  it "considers all included as recursive" do
+    tank = Zfs::Dataset.new("tank")
+    datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+        Zfs::Dataset.new("tank/b"),
+      ],
+      'excluded' => [],
+    }
+    recursive_datasets = find_recursive_datasets(datasets)
+    recursive_datasets['recursive'].should eq([Zfs::Dataset.new("tank")])
+    recursive_datasets['single'].should eq([])
+  end
+
+  it "considers all multiple parent datasets as recursive" do
+    tank = Zfs::Dataset.new("tank")
+    datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+        Zfs::Dataset.new("tank/b"),
+        Zfs::Dataset.new("rpool"),
+        Zfs::Dataset.new("rpool/a"),
+        Zfs::Dataset.new("rpool/b"),
+        Zfs::Dataset.new("zpool"),
+        Zfs::Dataset.new("zpool/a"),
+        Zfs::Dataset.new("zpool/b"),
+      ],
+      'excluded' => [],
+    }
+    recursive_datasets = find_recursive_datasets(datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank"),
+      Zfs::Dataset.new("rpool"),
+      Zfs::Dataset.new("zpool"),
+    ])
+    recursive_datasets['single'].should eq([])
+  end
+
+  it "considers all excluded as empty" do
+    tank = Zfs::Dataset.new("tank")
+    datasets = [
+      Zfs::Dataset.new("tank"),
+      Zfs::Dataset.new("tank/a"),
+      Zfs::Dataset.new("tank/a/1"),
+      Zfs::Dataset.new("tank/b"),
+    ]
+    included_excluded_datasets = {
+      'included' => [],
+      'excluded' => datasets,
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([])
+    recursive_datasets['single'].should eq([])
+  end
+
+  it "considers first level excluded" do
+    included_excluded_datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+      ],
+      'excluded' => [
+        Zfs::Dataset.new("rpool"),
+        Zfs::Dataset.new("rpool/a"),
+      ]
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank"),
+    ])
+    recursive_datasets['single'].should eq([])
+  end
+
+  it "considers second level excluded" do
+    included_excluded_datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+      ],
+      'excluded' => [
+        Zfs::Dataset.new("tank/b"),
+      ]
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank/a"),
+    ])
+    recursive_datasets['single'].should eq([
+      Zfs::Dataset.new("tank"),
+    ])
+  end
+
+  it "considers third level excluded" do
+    included_excluded_datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+        Zfs::Dataset.new("tank/a/2"),
+        Zfs::Dataset.new("tank/b"),
+        Zfs::Dataset.new("tank/b/1"),
+        Zfs::Dataset.new("tank/b/2"),
+      ],
+      'excluded' => [
+        Zfs::Dataset.new("tank/c"),
+      ]
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank/a"),
+      Zfs::Dataset.new("tank/b"),
+    ])
+    recursive_datasets['single'].should eq([
+      Zfs::Dataset.new("tank"),
+    ])
+  end
+
+  it "considers child with mysql db in parent recursive" do
+    included_excluded_datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+        Zfs::Dataset.new("tank/a/2"),
+        Zfs::Dataset.new("tank/b"),
+        Zfs::Dataset.new("tank/b/1").contains_db!("mysql"),
+        Zfs::Dataset.new("tank/b/2"),
+      ],
+      'excluded' => []
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank").contains_db!("mysql"),
+    ])
+    recursive_datasets['single'].should eq([])
+  end
+
+  it "considers child with mysql db in recursive with singles and exclusions" do
+    included_excluded_datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+        Zfs::Dataset.new("tank/a/2").contains_db!("mysql"),
+        Zfs::Dataset.new("tank/b"),
+        Zfs::Dataset.new("tank/b/1"),
+      ],
+      'excluded' => [
+        Zfs::Dataset.new("tank/b/2"),
+      ]
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank/a").contains_db!("mysql"),
+      Zfs::Dataset.new("tank/b/1"),
+    ])
+    recursive_datasets['single'].should eq([
+      Zfs::Dataset.new("tank"),
+      Zfs::Dataset.new("tank/b"),
+    ])
+  end
+
+  it "considers child with mysql db in single with recursives and exclusions" do
+    included_excluded_datasets = {
+      'included' => [
+        Zfs::Dataset.new("tank"),
+        Zfs::Dataset.new("tank/a"),
+        Zfs::Dataset.new("tank/a/1"),
+        Zfs::Dataset.new("tank/a/2"),
+        Zfs::Dataset.new("tank/b"),
+        Zfs::Dataset.new("tank/b/1").contains_db!("mysql"),
+      ],
+      'excluded' => [
+        Zfs::Dataset.new("tank/b/2"),
+      ]
+    }
+    recursive_datasets = find_recursive_datasets(included_excluded_datasets)
+    recursive_datasets['recursive'].should eq([
+      Zfs::Dataset.new("tank/a"),
+      Zfs::Dataset.new("tank/b/1").contains_db!("mysql"),
+    ])
+    recursive_datasets['single'].should eq([
+      Zfs::Dataset.new("tank"),
+      Zfs::Dataset.new("tank/b"),
+    ])
   end
 end

data/zfstools.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "zfstools"
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Bryan Drewery"]
+  s.date = "2012-04-28"
+  s.description = "ZFS admin scripts, such as automatic snapshots, mysql snapshotting, scrubbing, etc."
+  s.email = "bryan@shatow.net"
+  s.executables = ["zfs-auto-snapshot", "zfs-cleanup-snapshots", "zfs-snapshot-mysql"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/zfs-auto-snapshot",
+    "bin/zfs-cleanup-snapshots",
+    "bin/zfs-snapshot-mysql",
+    "features/step_definitions/zfstools_steps.rb",
+    "features/support/env.rb",
+    "features/zfstools.feature",
+    "lib/zfs/dataset.rb",
+    "lib/zfs/snapshot.rb",
+    "lib/zfstools.rb",
+    "spec/spec_helper.rb",
+    "spec/zfstools_spec.rb",
+    "zfstools.gemspec"
+  ]
+  s.homepage = "http://github.com/bdrewery/zfstools"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.16"
+  s.summary = "ZFSTools"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.7"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<cucumber>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<yard>, ["~> 0.7"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<cucumber>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<yard>, ["~> 0.7"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<cucumber>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+  end
+end
+

metadata

@@ -1,120 +1,93 @@
 --- !ruby/object:Gem::Specification
 name: zfstools
 version: !ruby/object:Gem::Version
-  version: 0.1.0
-  segments:
-  - 0
-  - 1
-  - 0
-  prerelease: false
+  version: 0.2.0
+  prerelease: 
 platform: ruby
 authors:
 - Bryan Drewery
-autorequire: !!null 
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-15 00:00:00.000000000 -06:00
-default_executable: !!null 
+date: 2012-04-28 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &14899340 !ruby/object:Gem::Requirement
+  requirement: &15950360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.8.0
-        segments:
-        - 2
-        - 8
-        - 0
   type: :development
   prerelease: false
-  version_requirements: *14899340
+  version_requirements: *15950360
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &14896780 !ruby/object:Gem::Requirement
+  requirement: &15949660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.7'
-        segments:
-        - 0
-        - 7
   type: :development
   prerelease: false
-  version_requirements: *14896780
+  version_requirements: *15949660
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &14895400 !ruby/object:Gem::Requirement
+  requirement: &15948980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.12'
-        segments:
-        - 3
-        - 12
   type: :development
   prerelease: false
-  version_requirements: *14895400
+  version_requirements: *15948980
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &14894220 !ruby/object:Gem::Requirement
+  requirement: &15948340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-        segments:
-        - 0
   type: :development
   prerelease: false
-  version_requirements: *14894220
+  version_requirements: *15948340
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &14893080 !ruby/object:Gem::Requirement
+  requirement: &15947700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.0
-        segments:
-        - 1
-        - 0
-        - 0
   type: :development
   prerelease: false
-  version_requirements: *14893080
+  version_requirements: *15947700
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &14891840 !ruby/object:Gem::Requirement
+  requirement: &15946900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.8.3
-        segments:
-        - 1
-        - 8
-        - 3
   type: :development
   prerelease: false
-  version_requirements: *14891840
+  version_requirements: *15946900
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &14865880 !ruby/object:Gem::Requirement
+  requirement: &15946240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-        segments:
-        - 0
   type: :development
   prerelease: false
-  version_requirements: *14865880
+  version_requirements: *15946240
 description: ZFS admin scripts, such as automatic snapshots, mysql snapshotting, scrubbing,
   etc.
 email: bryan@shatow.net
@@ -143,15 +116,16 @@ files:
 - features/step_definitions/zfstools_steps.rb
 - features/support/env.rb
 - features/zfstools.feature
+- lib/zfs/dataset.rb
 - lib/zfs/snapshot.rb
 - lib/zfstools.rb
 - spec/spec_helper.rb
 - spec/zfstools_spec.rb
-has_rdoc: true
+- zfstools.gemspec
 homepage: http://github.com/bdrewery/zfstools
 licenses:
 - MIT
-post_install_message: !!null 
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -163,19 +137,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1580374833721105612
+      hash: 1469645042708547290
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
 requirements: []
-rubyforge_project: !!null 
-rubygems_version: 1.3.7
-signing_key: !!null 
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
 specification_version: 3
 summary: ZFSTools
 test_files: []