zfs 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+.vagrant
+Gemfile.lock
+test.rb

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Guardfile

@@ -0,0 +1,11 @@
+# -*- mode: ruby; tab-width: 2; indent-tabs-mode: nil -*-
+
+guard 'rspec', :version => 2, :cli => '--color' do
+  watch(/^spec\/(.*)_spec.rb/)
+  watch(/^lib\/(.*)\.rb/)         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(/^spec\/spec_helper.rb/)  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Kenneth Vestergaard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# ruby-zfs
+
+A library for interacting with ZFS, made in the spirit of Pathname.
+
+Just like Pathname, it does not represent the filesystem itself, until you try to reference
+it by calling methods on it. It can not, however, be relative - it is always an absolute reference
+to a specific pool and path.
+
+The only exception is when trying to reference a mountpoint by using a filesystem-path. In this
+case, a ZFS object is only returned if the mountpoint exists. (eg. `ZFS('/tank/foo')`)
+
+ZFS is mutable, and contains potentially very destructive methods.
+
+## Usage
+
+```ruby
+	ZFS.pools                   # => [<ZFS:tank>]
+
+	fs = ZFS('tank/foo')        # => <ZFS:tank/foo>
+	fs.create                   # creates the filesystem
+	fs.exist?                   # => true
+	fs.name                     # => 'tank/foo'
+	fs.mountpoint               # => '/tank/foo'
+
+	ZFS('/tank/foo')            # => <ZFS:tank/foo>
+
+	fs.parent                   # => <ZFS:tank>
+	fs.parent.parent            # => nil
+
+	fs.available                # returns bytes available in the filesystem
+	fs.type                     # => :filesystem
+	fs.checksum = :fletcher4
+	fs.readonly = true
+	fs.readonly?                # => true
+	# plus all other properties defined in (currently) ZFS v28
+
+	fs['org.freebsd:swap'] = 1  # sets the custom property 'org.freebsd:swap' to 1
+	fs['org.freebsd:swap']      # => 1
+
+	(fs + 'bar').create         # => <ZFS:tank/foo/bar>
+	(fs + 'bar/baz').create     # => <ZFS:tank/foo/bar/baz>
+	fs.children                 # => [<ZFS:tank/foo/bar]
+	fs.children(recursive: true)# => [<ZFS:tank/foo/bar>, <ZFS:tank/foo/bar/baz>]
+
+	s = fs.snapshot('snapname') # => <ZFS:tank/foo@snapname>
+	s.parent                    # => <ZFS:tank/foo>
+	fs.snapshots                # => [<ZFS:tank/foo@snapname>]
+	s.destroy!                  # destroys snapshot
+
+	# Take a recursive snapshot ('zfs snapshot -r')
+	fs.snapshot('snapname', children: true)
+	# => [<ZFS:tank/foo@snapname>, <ZFS:tank/foo/bar@snapname, ...]
+
+	# Destroy a snapshot recursively
+	ZFS('tank/foo@snapname').destroy!(children: true)
+
+	s = fs.snapshot('snapname') # => <ZFS:tank/foo@snapname>
+	fs2 = s.clone('tank/bar')   # => <ZFS:tank/bar>
+	fs2.promote!
+
+	fs2.rename('tank/baz')
+
+	snapshot.send_to(fs)        # ZFS send/receive rolled into one - needs long description
+
+	Still missing inherit, mount/unmount, share/unshare, and maybe send/receive
+
+	# Shell out to `ssh`, and assume `zfs` and `zpool` is in path on remote host
+	ZFS('tank/foo', hostname: 'foo.example.com')
+
+	# Can be set to either a String or an Array
+	ZFS.zfs_path                # => '/sbin/zfs'
+	ZFS.zpool_path              # => '/sbin/zpool'
+```
+
+## Development
+
+Uses a Vagrant VM with a custom Ubuntu + ZFS-on-Linux to do all the practical tests, to avoid thrashing any local ZFS-installations.
+
+
+## Bugs
+
+* Currently, ZFS-objects aren't cached, so two instances can refer to the same filesystem. If mutable actions are called, only one is updated to reflect. (eg. rename!)
+* Many commands take options, but do not warn/error if given invalid options
+
+## Todo
+
+* Support remote systems by prepending zfs/zpool-command with "ssh #{host}"
+* gem
+	* http://docs.rubygems.org/read/chapter/20
+	* http://yehudakatz.com/2010/04/02/using-gemspecs-as-intended/
+* Docs
+	* http://tomdoc.org/
+* http://www.bolthole.com/solaris/zrep/src/
+* Replace Open4 with Open3#popen3

data/Vagrantfile

@@ -0,0 +1,38 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "ubuntu-11.10+zfs-64bit"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  # config.vm.box_url = "http://domain.com/path/to/above.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  # config.vm.network :hostonly, "33.33.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+end

data/lib/zfs.rb

@@ -0,0 +1,513 @@
+# -*- mode: ruby; tab-width: 4; indent-tabs-mode: t -*-
+
+require 'pathname'
+require 'date'
+require 'open4'
+
+# Get ZFS object.
+def ZFS(path)
+	return path if path.is_a? ZFS
+
+	path = Pathname(path).cleanpath.to_s
+
+	if path.match(/^\//)
+		ZFS.mounts[path]
+	elsif path.match('@')
+		ZFS::Snapshot.new(path)
+	else
+		ZFS::Filesystem.new(path)
+	end
+end
+
+# Pathname-inspired class to handle ZFS filesystems/snapshots/volumes
+class ZFS
+	@zfs_path   = "zfs"
+	@zpool_path = "zpool"
+
+	attr_reader :name
+	attr_reader :pool
+	attr_reader :path
+
+	class NotFound < Exception; end
+	class AlreadyExists < Exception; end
+	class InvalidName < Exception; end
+
+	# Create a new ZFS object (_not_ filesystem).
+	def initialize(name)
+		@name, @pool, @path = name, *name.split('/', 2)
+	end
+
+	# Return the parent of the current filesystem, or nil if there is none.
+	def parent
+		p = Pathname(name).parent.to_s
+		if p == '.'
+			nil
+		else
+			ZFS(p)
+		end
+	end
+
+	# Returns the children of this filesystem
+	def children(opts={})
+		raise NotFound if !exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + %w(list -H -r -oname -tfilesystem)
+		cmd << '-d1' unless opts[:recursive]
+		cmd << name
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		stdout.shift # self
+		stdout.collect do |filesystem|
+			ZFS(filesystem.chomp)
+		end
+	end
+
+	# Does the filesystem exist?
+	def exist?
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + %w(list -H -oname) + [name]
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr, ignore_exit_failure: true)
+
+		if stdout == ["#{name}\n"]
+			true
+		else
+			false
+		end
+	end
+
+	# Create filesystem
+	def create(opts={})
+		return nil if exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['create']
+		cmd << '-p' if opts[:parents]
+		cmd += ['-V', opts[:volume]] if opts[:volume]
+		cmd << name
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			return self
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	# Destroy filesystem
+	def destroy!(opts={})
+		raise NotFound if !exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['destroy']
+		cmd << '-r' if opts[:children]
+		cmd << name
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			return true
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	# Stringify
+	def to_s
+		"#<ZFS:#{name}>"
+	end
+
+	# ZFS's are considered equal if they are the same class and name
+	def ==(other)
+		other.class == self.class && other.name == self.name
+	end
+
+	def [](key)
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + %w(get -ovalue -Hp) + [key.to_s, name]
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stderr.empty? and stdout.size == 1
+			return stdout.first.chomp
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	def []=(key, value)
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['set', "#{key.to_s}=#{value}", name]
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stderr.empty? and stdout.empty?
+			return value
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	class << self
+		attr_accessor :zfs_path
+		attr_accessor :zpool_path
+
+		# Get an Array of all pools
+		def pools
+			stdout, stderr = [], []
+			cmd = [ZFS.zpool_path].flatten + %w(list -Honame)
+
+			Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+			stdout.collect do |pool|
+				ZFS(pool.chomp)
+			end
+		end
+
+		# Get a Hash of all mountpoints and their filesystems
+		def mounts
+			stdout, stderr = [], []
+			cmd = [ZFS.zfs_path].flatten + %w(get -rHp -oname,value mountpoint)
+
+			Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+			mounts = stdout.collect do |line|
+				fs, path = line.chomp.split(/\t/, 2)
+				[path, ZFS(fs)]
+			end
+			Hash[mounts]
+		end
+
+		# Define an attribute
+		def property(name, opts={})
+
+			case opts[:type]
+			when :size, :integer
+				# FIXME: also takes :values. if :values is all-Integers, these are the only options. if there are non-ints, then :values is a supplement
+
+				define_method name do
+					Integer(self[name])
+				end
+				define_method "#{name}=" do |value|
+					self[name] = value.to_s
+				end if opts[:edit]
+
+			when :boolean
+				# FIXME: booleans can take extra values, so there are on/true, off/false, plus what amounts to an enum
+				# FIXME: if options[:values] is defined, also create a 'name' method, since 'name?' might not ring true
+				# FIXME: replace '_' by '-' in opts[:values]
+				define_method "#{name}?" do
+					self[name] == 'on'
+				end
+				define_method "#{name}=" do |value|
+					self[name] = value ? 'on' : 'off'
+				end if opts[:edit]
+
+			when :enum
+				define_method name do
+					sym = (self[name] || "").gsub('-', '_').to_sym
+					if opts[:values].grep(sym)
+						return sym
+					else
+						raise "#{name} has value #{sym}, which is not in enum-list"
+					end
+				end
+				define_method "#{name}=" do |value|
+					self[name] = value.to_s.gsub('_', '-')
+				end if opts[:edit]
+
+			when :snapshot
+				define_method name do
+					val = self[name]
+					if val.nil? or val == '-'
+						nil
+					else
+						ZFS(val)
+					end
+				end
+
+			when :float
+				define_method name do
+					Float(self[name])
+				end
+				define_method "#{name}=" do |value|
+					self[name] = value
+				end if opts[:edit]
+
+			when :string
+				define_method name do
+					self[name]
+				end
+				define_method "#{name}=" do |value|
+					self[name] = value
+				end if opts[:edit]
+
+			when :date
+				define_method name do
+					DateTime.strptime(self[name], '%s')
+				end
+
+			when :pathname
+				define_method name do
+					Pathname(self[name])
+				end
+				define_method "#{name}=" do |value|
+					self[name] = value.to_s
+				end if opts[:edit]
+
+			else
+				puts "Unknown type '#{opts[:type]}'"
+			end
+		end
+		private :property
+	end
+
+	property :available,            type: :size
+	property :compressratio,        type: :float
+	property :creation,             type: :date
+	property :defer_destroy,        type: :boolean
+	property :mounted,              type: :boolean
+	property :origin,               type: :snapshot
+	property :refcompressratio,     type: :float
+	property :referenced,           type: :size
+	property :type,                 type: :enum, values: [:filesystem, :snapshot, :volume]
+	property :used,                 type: :size
+	property :usedbychildren,       type: :size
+	property :usedbydataset,        type: :size
+	property :usedbyrefreservation, type: :size
+	property :usedbysnapshots,      type: :size
+	property :userrefs,             type: :integer
+
+	property :aclinherit,           type: :enum,    edit: true, inherit: true, values: [:discard, :noallow, :restricted, :passthrough, :passthrough_x]
+	property :atime,                type: :boolean, edit: true, inherit: true
+	property :canmount,             type: :boolean, edit: true,                values: [:noauto]
+	property :checksum,             type: :boolean, edit: true, inherit: true, values: [:fletcher2, :fletcher4, :sha256]
+	property :compression,          type: :boolean, edit: true, inherit: true, values: [:lzjb, :gzip, :gzip_1, :gzip_2, :gzip_3, :gzip_4, :gzip_5, :gzip_6, :gzip_7, :gzip_8, :gzip_9, :zle]
+	property :copies,               type: :integer, edit: true, inherit: true, values: [1, 2, 3]
+	property :dedup,                type: :boolean, edit: true, inherit: true, values: [:verify, :sha256, 'sha256,verify']
+	property :devices,              type: :boolean, edit: true, inherit: true
+	property :exec,                 type: :boolean, edit: true, inherit: true
+	property :logbias,              type: :enum,    edit: true, inherit: true, values: [:latency, :throughput]
+	property :mlslabel,             type: :string,  edit: true, inherit: true
+	property :mountpoint,           type: :pathname,edit: true, inherit: true
+	property :nbmand,               type: :boolean, edit: true, inherit: true
+	property :primarycache,         type: :enum,    edit: true, inherit: true, values: [:all, :none, :metadata]
+	property :quota,                type: :size,    edit: true,                values: [:none]
+	property :readonly,             type: :boolean, edit: true, inherit: true
+	property :recordsize,           type: :integer, edit: true, inherit: true, values: [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]
+	property :refquota,             type: :size,    edit: true,                values: [:none]
+	property :refreservation,       type: :size,    edit: true,                values: [:none]
+	property :reservation,          type: :size,    edit: true,                values: [:none]
+	property :secondarycache,       type: :enum,    edit: true, inherit: true, values: [:all, :none, :metadata]
+	property :setuid,               type: :boolean, edit: true, inherit: true
+	property :sharenfs,             type: :boolean, edit: true, inherit: true # FIXME: also takes 'share(1M) options'
+	property :sharesmb,             type: :boolean, edit: true, inherit: true # FIXME: also takes 'sharemgr(1M) options'
+	property :snapdir,              type: :enum,    edit: true, inherit: true, values: [:hidden, :visible]
+	property :sync,                 type: :enum,    edit: true, inherit: true, values: [:standard, :always, :disabled]
+	property :version,              type: :integer, edit: true,                values: [1, 2, 3, 4, :current]
+	property :vscan,                type: :boolean, edit: true, inherit: true
+	property :xattr,                type: :boolean, edit: true, inherit: true
+	property :zoned,                type: :boolean, edit: true, inherit: true
+	property :jailed,               type: :boolean, edit: true, inherit: true
+	property :volsize,              type: :size,    edit: true
+
+	property :casesensitivity,      type: :enum,    create_only: true, values: [:sensitive, :insensitive, :mixed]
+	property :normalization,        type: :enum,    create_only: true, values: [:none, :formC, :formD, :formKC, :formKD]
+	property :utf8only,             type: :boolean, create_only: true
+	property :volblocksize,         type: :integer, create_only: true, values: [512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072]
+end
+
+
+class ZFS::Snapshot < ZFS
+	# Return sub-filesystem
+	def +(path)
+		raise InvalidName if path.match(/@/)
+
+		parent + path + name.sub(/^.+@/, '@')
+	end
+
+	# Just remove the snapshot-name
+	def parent
+		ZFS(name.sub(/@.+/, ''))
+	end
+
+	# Rename snapshot
+	def rename!(newname, opts={})
+		raise AlreadyExists if (parent + "@#{newname}").exist?
+
+		newname = (parent + "@#{newname}").name
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['rename']
+		cmd << '-r' if opts[:children]
+		cmd << name
+		cmd << newname
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			initialize(newname)
+			return self
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	# Clone snapshot
+	def clone!(clone, opts={})
+		clone = clone.name if clone.is_a? ZFS
+
+		raise AlreadyExists if ZFS(clone).exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['clone']
+		cmd << '-p' if opts[:parents]
+		cmd << name
+		cmd << clone
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			return ZFS(clone)
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	# Send snapshot to another filesystem
+	def send_to(dest, opts={})
+		incr_snap = nil
+		dest = ZFS(dest)
+
+		if opts[:incremental] and opts[:intermediary]
+			raise ArgumentError, "can't specify both :incremental and :intermediary"
+		end
+
+		incr_snap = opts[:incremental] || opts[:intermediary]
+		if incr_snap
+			if incr_snap.is_a? String and incr_snap.match(/^@/)
+				incr_snap = self.parent + incr_snap
+			else
+				incr_snap = ZFS(incr_snap)
+				raise ArgumentError, "incremental snapshot must be in the same filesystem as #{self}" if incr_snap.parent != self.parent
+			end
+
+			snapname = incr_snap.name.sub(/^.+@/, '@')
+
+			raise NotFound, "destination must already exist when receiving incremental stream" unless dest.exist?
+			raise NotFound, "snapshot #{snapname} must exist at #{self.parent}" if self.parent.snapshots.grep(incr_snap).empty?
+			raise NotFound, "snapshot #{snapname} must exist at #{dest}" if dest.snapshots.grep(dest + snapname).empty?
+		elsif opts[:use_sent_name]
+			raise NotFound, "destination must already exist when using sent name" unless dest.exist?
+		elsif dest.exist?
+			raise AlreadyExists, "destination must not exist when receiving full stream"
+		end
+
+		dest = dest.name if dest.is_a? ZFS
+		incr_snap = incr_snap.name if incr_snap.is_a? ZFS
+
+		send_opts = ZFS.zfs_path.flatten + ['send']
+		send_opts.concat ['-i', incr_snap] if opts[:incremental]
+		send_opts.concat ['-I', incr_snap] if opts[:intermediary]
+		send_opts << '-R' if opts[:replication]
+		send_opts << name
+
+		receive_opts = ZFS.zfs_path.flatten + ['receive']
+		receive_opts << '-d' if opts[:use_sent_name]
+		receive_opts << dest
+
+		Open4::popen4(*receive_opts) do |rpid, rstdin, rstdout, rstderr|
+			Open4::popen4(*send_opts) do |spid, sstdin, sstdout, sstderr|
+				while !sstdout.eof?
+					rstdin.write(sstdout.read(16384))
+				end
+				raise "stink" unless sstderr.read == ''
+			end
+		end
+	end
+end
+
+
+class ZFS::Filesystem < ZFS
+	# Return sub-filesystem.
+	def +(path)
+		if path.match(/^@/)
+			ZFS("#{name.to_s}#{path}")
+		else
+			path = Pathname(name) + path
+			ZFS(path.cleanpath.to_s)
+		end
+	end
+
+	# Rename filesystem.
+	def rename!(newname, opts={})
+		raise AlreadyExists if ZFS(newname).exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['rename']
+		cmd << '-p' if opts[:parents]
+		cmd << name
+		cmd << newname
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			initialize(newname)
+			return self
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	# Create a snapshot.
+	def snapshot(snapname, opts={})
+		raise NotFound, "no such filesystem" if !exist?
+		raise AlreadyExists, "#{snapname} exists" if ZFS("#{name}@#{snapname}").exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['snapshot']
+		cmd << '-r' if opts[:children]
+		cmd << "#{name}@#{snapname}"
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			return ZFS("#{name}@#{snapname}")
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+
+	# Get an Array of all snapshots on this filesystem.
+	def snapshots
+		raise NotFound, "no such filesystem" if !exist?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + %w(list -H -d1 -r -oname -tsnapshot) + [name]
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		stdout.collect do |snap|
+			ZFS(snap.chomp)
+		end
+	end
+
+	# Promote this filesystem.
+	def promote!
+		raise NotFound, "filesystem is not a clone" if self.origin.nil?
+
+		stdout, stderr = [], []
+		cmd = [ZFS.zfs_path].flatten + ['promote', name]
+
+		Open4::spawn(cmd, stdout: stdout, stderr: stderr)
+
+		if stdout.empty? and stderr.empty?
+			return self
+		else
+			raise Exception, "something went wrong"
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# -*- mode: ruby; tab-width: 4; indent-tabs-mode: t -*-
+$LOAD_PATH.push(File.expand_path('../lib/zfs'))
+
+require 'zfs'
+require 'open4'
+
+shared_context "vagrant" do
+	before(:all) do
+		ZFS.zfs_path   = %w(ssh vagrant-zfs sudo zfs)
+		ZFS.zpool_path = %w(ssh vagrant-zfs sudo zpool)
+	end
+
+	after(:all) do
+		Open4::spawn([*ZFS.zfs_path]+['destroy -r tank/foo'], ignore_exit_failure: true)
+		Open4::spawn([*ZFS.zfs_path]+['destroy -r tank/bar'], ignore_exit_failure: true)
+
+		ZFS.zfs_path   = 'zfs'
+		ZFS.zpool_path = 'zpool'
+	end
+end

data/spec/zfs_spec.rb

@@ -0,0 +1,518 @@
+# -*- mode: ruby; tab-width: 4; indent-tabs-mode: t -*-
+require 'spec_helper'
+
+# NOTE! The ordering of the tests may be important, or at least significant.
+# Example: we test create+snapshot, then destroy - in between, there is state left behind
+# since we don't want to assume something works before it's been tested, to avoid very
+# confusing errors in stuff other than what is being tested.
+#
+# We also test clones after snapshots, and promote! after clones and properties.
+
+
+# Helper-method to return ZFS-instances
+describe "ZFS()" do
+	it "returns the correct instance" do
+		ZFS('tank').should be_an_instance_of ZFS::Filesystem
+		ZFS('tank@foo').should be_an_instance_of ZFS::Snapshot
+	end
+
+	it "supports Pathname's" do
+		ZFS('tank').should eq ZFS(Pathname('tank'))
+	end
+
+	it "passes a ZFS as argument through untouched" do
+		fs = ZFS('tank')
+		ZFS(fs).should eq fs
+	end
+end
+
+
+# Methods that don't require a live filesystem
+describe ZFS do
+	describe "#parent" do
+		it "returns the correct parent" do
+			ZFS('tank/foo/bar').parent.should eq ZFS('tank/foo')
+			ZFS('tank/foo/bar@snap').parent.should eq ZFS('tank/foo/bar')
+			ZFS('tank/foo/bar@snap').parent.parent.should eq ZFS('tank/foo')
+		end
+	end
+
+	describe "#+" do
+		it "returns an appended path" do
+			(ZFS('tank/foo') + 'bar').should eq ZFS('tank/foo/bar')
+			(ZFS('tank/foo') + '@bar').should eq ZFS('tank/foo@bar')
+			(ZFS('tank/foo@baz') + 'bar').should eq ZFS('tank/foo/bar@baz')
+			expect { (ZFS('tank/foo@baz') + '@bar') }.to raise_exception ZFS::InvalidName
+		end
+	end
+end
+
+
+# Methods that require a live filesystem.
+describe ZFS do
+	include_context "vagrant"
+
+	describe "#create" do
+		it "creates a filesystem, and returns the filesystem or nil if it already exists" do
+			ZFS('tank/foo').should_not exist
+			ZFS('tank/foo').create.should eq ZFS('tank/foo')
+			ZFS('tank/foo').create.should be_nil
+			ZFS('tank/foo').should exist
+		end
+
+		it "creates parents" do
+			ZFS('tank/foo/bar/baz').create(parents: true).should exist
+		end
+
+		it "raises an error if parent does not exist"
+
+		it "creates volumes" do
+			ZFS('tank/foo/volume').create(volume: '10G').should_not be_nil
+		end
+	end
+
+	describe "#snapshot" do
+		it "creates a snapshot" do
+			snapshot = ZFS('tank/foo').snapshot('qux')
+
+			snapshot.should be_an_instance_of ZFS::Snapshot
+		end
+
+		it "creates a snapshot recursively" do
+			ZFS('tank/foo').snapshot('quux', children: true)
+			ZFS('tank/foo@quux').should exist
+			ZFS('tank/foo/bar@quux').should exist
+			ZFS('tank/foo/bar/baz@quux').should exist
+		end
+
+		it "should raise an exception if filesystem does not exist" do
+			expect { ZFS('tank/none').snapshot('foo') }.to raise_error(ZFS::NotFound)
+		end
+
+		it "should raise an exception if snapshot already exists" do
+			expect { ZFS('tank/foo').snapshot('quux') }.to raise_error(ZFS::AlreadyExists)
+		end
+	end
+
+	describe "#destroy" do
+		it "destroys snapshots" do
+			ZFS('tank/foo/bar/baz@quux').should exist
+			ZFS('tank/foo/bar/baz@quux').destroy!
+			ZFS('tank/foo/bar/baz@quux').should_not exist
+		end
+
+		it "destroys filesystems" do
+			ZFS('tank/foo/bar/baz').should exist
+			ZFS('tank/foo/bar/baz').destroy!
+			ZFS('tank/foo/bar/baz').should_not exist
+		end
+
+		it "destroys snapshots recursively" do
+			ZFS('tank/foo@quux').should exist
+			ZFS('tank/foo/bar@quux').should exist
+
+			ZFS('tank/foo@quux').destroy!(children: true)
+
+			ZFS('tank/foo@quux').should_not exist
+			ZFS('tank/foo/bar@quux').should_not exist
+
+			ZFS('tank/foo').should exist
+			ZFS('tank/foo/bar').should exist
+		end
+
+		it "destroys filesystems recursively" do
+			ZFS('tank/foo').destroy!(children: true)
+			ZFS('tank/foo').should_not exist
+		end
+
+		it "should raise an exception if filesystem does not exist" do
+			expect { ZFS('tank/none').destroy! }.to raise_error(ZFS::NotFound)
+		end
+	end
+
+	describe "#snapshots" do
+		it "returns a list of snapshots on a filesystem" do
+			snapshot = ZFS('tank/foo').create.snapshot('bar')
+			snapshot.should exist
+
+			ZFS('tank/foo').snapshots.should eq [snapshot]
+
+			snapshot2 = ZFS('tank/foo').snapshot('baz')
+
+			ZFS('tank/foo').snapshots.should eq [snapshot, snapshot2]
+
+			# Should only include direct descendants
+			ZFS('tank/foo/bar').create.snapshot('baz')
+			ZFS('tank/foo').snapshots.should eq [snapshot, snapshot2]
+
+			snapshot.destroy!
+			ZFS('tank/foo').snapshots.should eq [snapshot2]
+
+			ZFS('tank/foo').destroy!(children: true)
+
+			ZFS('tank/foo').should_not exist
+		end
+
+		it "should raise an exception if filesystem does not exist" do
+			expect { ZFS('tank/none').snapshots }.to raise_error(ZFS::NotFound)
+		end
+	end
+
+	describe "#children" do
+		before(:all) do
+			%w(tank/l1/ll1/lll1 tank/l1/ll2 tank/l2/ll2/lll2 tank/l3).each { |f| ZFS(f).create(parents: true) }
+		end
+
+		after(:all) do
+			%w(tank/l1 tank/l2 tank/l3).each { |f| ZFS(f).destroy!(children: true) }
+		end
+
+		it "should raise an exception if filesystem does not exist" do
+			expect { ZFS('tank/none').children }.to raise_error(ZFS::NotFound)
+		end
+
+		it "returns a list of immediate children" do
+			ZFS('tank/l1').children.should eq [ZFS('tank/l1/ll1'), ZFS('tank/l1/ll2')]
+			ZFS('tank').children.should eq [ZFS('tank/l1'), ZFS('tank/l2'), ZFS('tank/l3')]
+		end
+
+		it "returns a list of all children" do
+			ZFS('tank/l1').children(recursive: true).should eq [ZFS('tank/l1/ll1'), ZFS('tank/l1/ll1/lll1'), ZFS('tank/l1/ll2')]
+		end
+
+		it "does not include snapshots" do
+			ZFS('tank/l1').snapshot('test')
+			ZFS('tank/l1').children.should eq [ZFS('tank/l1/ll1'), ZFS('tank/l1/ll2')]
+		end
+	end
+
+	describe "#rename" do
+		it "renames filesystems" do
+			fs = ZFS('tank/foo').create
+			fs.rename!('tank/bar')
+
+			ZFS('tank/foo').should_not exist
+			ZFS('tank/bar').should exist
+			fs.should exist
+
+			fs.name.should eq "tank/bar"
+
+			fs.destroy!
+		end
+
+		it "renames filesystems and creates parents for new name" do
+			fs = ZFS('tank/foo').create
+			fs.rename!('tank/bar/baz/qux', parents: true)
+
+			ZFS('tank/foo').should_not exist
+			ZFS('tank/bar/baz/qux').should exist
+			fs.should exist
+
+			ZFS('tank/bar').destroy!(children: true)
+		end
+
+		it "renames snapshots" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+			snapshot.rename!('baz')
+			ZFS('tank/foo').snapshots.should eq [ZFS('tank/foo@baz')]
+			snapshot.name.should eq "tank/foo@baz"
+
+			ZFS('tank/foo').destroy!(children: true)
+		end
+
+		it "renames snapshots recursively" do
+			ZFS('tank/foo/bar/baz').create(parents: true)
+			ZFS('tank/foo').snapshot('bar', children: true)
+
+			ZFS('tank/foo/bar/baz@bar').should exist
+
+			ZFS('tank/foo@bar').rename!('foo', children: true)
+
+			ZFS('tank/foo/bar/baz@foo').should exist
+
+			ZFS('tank/foo').destroy!(children: true)
+		end
+
+		it "throws an exception when new name is already used" do
+			ZFS('tank/foo').create
+
+			# Rename filesystem
+			expect { ZFS('tank/bar').create.rename!('tank/foo') }.to raise_error ZFS::AlreadyExists
+
+			# Rename snapshot
+			snapshot = ZFS('tank/foo').snapshot('foo')
+			ZFS('tank/foo').snapshot('bar')
+			expect { snapshot.rename!('bar') }.to raise_error ZFS::AlreadyExists
+
+			ZFS('tank/foo').destroy!(children: true)
+			ZFS('tank/bar').destroy!
+		end
+	end
+
+	describe ".pools" do
+		it "returns an Array of all pools" do
+			ZFS.pools.should eq [ZFS('tank')]
+
+			# and only pools
+			ZFS('tank/foo').create
+			ZFS.pools.should eq [ZFS('tank')]
+			ZFS('tank/foo').destroy!
+		end
+	end
+
+	describe ".mounts" do
+		it "returns a Hash of all mountpoints" do
+			ZFS.mounts.should eq "/tank" => ZFS('tank')
+		end
+	end
+
+	describe "#[]" do
+		it "gets raw properties" do
+			ZFS('tank')['type'].should eq 'filesystem'
+		end
+	end
+
+	describe "#[]=" do
+		it "sets raw properties" do
+			ZFS('tank/foo').create
+			ZFS('tank/foo')['exec'].should eq 'on'
+			ZFS('tank/foo')['exec'] = 'off'
+			ZFS('tank/foo')['exec'].should eq 'off'
+			ZFS('tank/foo').destroy!
+		end
+	end
+
+	describe "properties" do
+		it "has helper functions" do
+			ZFS('tank').type.should eq :filesystem
+		end
+
+		it "gets correct types" do
+			ZFS('tank/foo').create
+			ZFS('tank/foo').exec?.should be_true
+			ZFS('tank/foo').origin.should be_nil
+			ZFS('tank/foo').creation.should be_an_instance_of DateTime
+			ZFS('tank/foo').referenced.should be_an_instance_of Fixnum
+			ZFS('tank/foo').mountpoint.should eq Pathname('/tank/foo')
+
+			ZFS('tank/foo').destroy!
+		end
+
+		it "sets correct types" do
+			ZFS('tank/foo').create
+			ZFS('tank/foo').exec?.should be_true
+			ZFS('tank/foo').exec = false
+			ZFS('tank/foo').exec?.should be_false
+
+		end
+	end
+end
+
+# Now that we've tested properties, we should be able to test fetching by mountpoint
+describe "ZFS()" do
+	include_context "vagrant"
+
+	it "takes a mountpoint as argument" do
+		ZFS('/tank').should eq ZFS('tank')
+		ZFS('/tank').name.should eq 'tank'
+		ZFS('tank/foo').create
+		ZFS('/tank/foo').should eq ZFS('tank/foo')
+		ZFS('tank/foo').destroy!
+	end
+end
+
+describe ZFS::Snapshot do
+	include_context "vagrant"
+
+	describe "#clone" do
+		it "raises an error when target already exists" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+			ZFS('tank/bar').create
+
+			expect { snapshot.clone!('tank/bar') }.to raise_error ZFS::AlreadyExists
+
+			ZFS('tank/foo').destroy!(children: true)
+			ZFS('tank/bar').destroy!
+		end
+
+		it "clones a snapshot to a filesystem" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+
+			fs = snapshot.clone!('tank/bar')
+			fs.should be_an_instance_of ZFS::Filesystem
+			fs.should exist
+			fs.should eq ZFS('tank/bar')
+
+			fs.destroy!
+			snapshot.destroy!
+			ZFS('tank/foo').destroy!
+		end
+
+		it "creates parent-filesystems when requested" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+
+			fs = snapshot.clone!('tank/bar/baz', parents: true)
+			fs.should be_an_instance_of ZFS::Filesystem
+			fs.should exist
+			fs.should eq ZFS('tank/bar/baz')
+
+			fs.destroy!
+			snapshot.destroy!
+			ZFS('tank/foo').destroy!
+			ZFS('tank/bar').destroy!(children: true)
+		end
+
+		it "returns a filesystem with a valid 'origin' property" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+
+			fs = snapshot.clone!('tank/bar')
+			fs.should be_an_instance_of ZFS::Filesystem
+			fs.origin.should eq snapshot
+
+			fs.destroy!
+			snapshot.destroy!
+			ZFS('tank/foo').destroy!
+		end
+
+		it "accepts a ZFS as a valid destination" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+
+			fs = snapshot.clone!(ZFS('tank/bar'))
+			fs.should be_an_instance_of ZFS::Filesystem
+			fs.origin.should eq snapshot
+
+			fs.destroy!
+			snapshot.destroy!
+			ZFS('tank/foo').destroy!
+		end
+	end
+
+	describe "#send_to" do
+		before(:all) do
+			@source = ZFS('tank/foo').create
+			@dest1  = ZFS('tank/bar').create
+			@dest2  = ZFS('tank/baz')
+			@sourcesnap = @source.snapshot('snapshot')
+		end
+
+		after(:all) do
+			@source.destroy!(children: true)
+			@dest1.destroy!(children: true)
+			@dest2.destroy!(children: true) if @dest2.exist?
+		end
+
+		it "sends the snapshot to another filesystem" do
+			@sourcesnap.send_to(@dest2)
+			(@dest2 + '@snapshot').should exist
+			@dest2.snapshots.should eq [(@dest2 + '@snapshot')]
+
+			@dest2.destroy!(children: true)
+		end
+
+		it "raises an error if the destination filesystem exists when sending a full stream" do
+			expect { @sourcesnap.send_to(@dest1) }.to raise_error ZFS::AlreadyExists
+		end
+
+		it "supports incremental/intermediary snapshots" do
+			@sourcesnap.send_to(@dest2)
+
+			snap2 = @source.snapshot('snapshot2')
+			snap2.send_to(@dest2, incremental: @sourcesnap)
+			snap2.should exist
+			(@dest2 + '@snapshot2').should exist
+
+			snap3 = @source.snapshot('snapshot3')
+			snap3.send_to(@dest2, intermediary: @sourcesnap)
+			snap3.should exist
+			(@dest2 + '@snapshot3').should exist
+
+			snap3.destroy!
+			snap2.destroy!
+			@dest2.destroy!(children: true)
+		end
+
+		it "raises an error when specifying invalid combinations of options" do
+			expect { @sourcesnap.send_to(@dest1, incremental: @sourcesnap, intermediary: @sourcesnap) }.to raise_error ArgumentError
+		end
+
+		it "supports relative paths (Strings beginning with @) as incremental sources" do
+			@sourcesnap.send_to(@dest2)
+
+			snap2 = @source.snapshot('snapshot2')
+			snap2.send_to(@dest2, incremental: '@snapshot')
+			snap2.should exist
+			(@dest2 + '@snapshot2').should exist
+
+			snap3 = @source.snapshot('snapshot3')
+			snap3.send_to(@dest2, intermediary: '@snapshot')
+			snap3.should exist
+			(@dest2 + '@snapshot3').should exist
+
+			snap3.destroy!
+			snap2.destroy!
+			@dest2.destroy!(children: true)
+		end
+
+		it "raises an error if incremental snapshot isn't in the same filesystem as source" do
+			s = @dest1.snapshot('foo')
+			expect { @sourcesnap.send_to(@dest1, incremental: s) }.to raise_error ArgumentError
+			s.destroy!
+		end
+
+		it "raises an error when filesystems/snapshots don't exist" do
+			expect { @sourcesnap.send_to(@dest1, incremental: ZFS('tank/foo@none')) }.to raise_error ZFS::NotFound
+			expect { @sourcesnap.send_to(@dest1, intermediary: ZFS('tank/foo@none')) }.to raise_error ZFS::NotFound
+			expect { @sourcesnap.send_to(@dest2, intermediary: @sourcesnap) }.to raise_error ZFS::NotFound
+		end
+
+		it "supports replication streams" do
+			source2 = (@source + 'sub').create
+			source2.snapshot('snapshot')
+
+			@sourcesnap.send_to(@dest2, replication: true)
+
+			@dest2.should exist
+			(@dest2 + 'sub@snapshot').should exist
+
+			@dest2.destroy!(children: true)
+		end
+
+		it "supports 'receive -d'" do
+			@sourcesnap.send_to(@dest1, use_sent_name: true)
+			(@dest1 + 'foo').should exist
+			(@dest1 + 'foo@snapshot').should exist
+			(@dest1 + 'foo').destroy!(children: true)
+		end
+
+		it "raises an error when using 'receive -d' and destination is missing" do
+			expect { @sourcesnap.send_to(@dest2, use_sent_name: true) }.to raise_error ZFS::NotFound
+		end
+	end
+end
+
+describe ZFS::Filesystem do
+	include_context "vagrant"
+
+	describe "#promote!" do
+		it "promotes a clone" do
+			snapshot = ZFS('tank/foo').create.snapshot('foo')
+
+			fs = snapshot.clone!('tank/bar')
+			fs.origin.should eq snapshot
+
+			fs.promote!
+
+			fs.origin.should be_nil
+			snapshot.parent.origin.should eq fs + '@foo'
+
+			snapshot.parent.destroy!
+			fs.snapshots.first.destroy!
+			fs.destroy!
+		end
+
+		it "raises an error if filesystem is not a clone" do
+			expect { ZFS('tank/foo').create.promote! }.to raise_error ZFS::NotFound
+			ZFS('tank/foo').destroy!
+		end
+	end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: zfs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- kvs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70251194879920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70251194879920
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70251194879320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70251194879320
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: &70251194878680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70251194878680
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70251194878160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70251194878160
+- !ruby/object:Gem::Dependency
+  name: open4
+  requirement: &70251199214680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70251199214680
+description: Makes it possible to query and manipulate ZFS filesystems, snapshots,
+  etc.
+email:
+- kvs@binarysolutions.dk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Vagrantfile
+- lib/zfs.rb
+- spec/spec_helper.rb
+- spec/zfs_spec.rb
+homepage: https://github.com/kvs/ruby-zfs
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: An library for interacting with ZFS
+test_files:
+- spec/spec_helper.rb
+- spec/zfs_spec.rb