qemu-toolkit 0.2.18

data/LICENSE

@@ -0,0 +1,23 @@
+
+ Copyright (c) 2012 Kaspar Schiess
+
+ 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

@@ -0,0 +1,7 @@
+SYNOPSIS
+
+qemu-toolkit is a small set of scripts to control QEMU kvm virtualised
+machines on a set of illumos hosts.
+
+Have a look at 'storadm' and 'vmadm' - inline help will show you the
+possibilities.

data/bin/storadm

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+def root(*args)
+  File.expand_path(
+    File.join(File.dirname(__FILE__), '..',
+      *args))
+end
+
+$:.unshift root('lib')
+
+require 'qemu-toolkit'
+
+require 'qemu-toolkit/storadm'
+QemuToolkit::Storadm.run

data/bin/vmadm

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+def root(*args)
+  File.expand_path(
+    File.join(File.dirname(__FILE__), '..',
+      *args))
+end
+
+$:.unshift root('lib')
+
+require 'qemu-toolkit'
+
+require 'qemu-toolkit/vmadm'
+QemuToolkit::Vmadm.run

data/bin/vmconnect

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# A small helper script that allows to make a VNC connection through ssh
+# securely. Note that on the VM host, you need 'socat' installed for this to
+# work. Uses ssvnc (vncviewer). 
+
+host, machine = ARGV
+exec "ssvnc exec='/usr/bin/ssh #{host} /usr/local/bin/socat "+
+     "STDIO UNIX-CONNECT:/var/run/qemu-toolkit/#{machine}/vm.vnc'"

data/lib/qemu-toolkit/backend/illumos.rb

@@ -0,0 +1,46 @@
+module QemuToolkit
+  class Backend::Illumos
+    attr_accessor :verbose
+    
+    def zfs *args
+      run_cmd :zfs, *args
+    end
+    def itadm(*args)
+      run_cmd :itadm, *args
+    end
+    def stmfadm *args
+      run_cmd :stmfadm, *args
+    end
+    def qemu name, args
+      exec_with_arg0 '/usr/bin/qemu-system-x86_64', name, *args
+    end
+    def iscsiadm *args
+      run_cmd :iscsiadm, *args
+    end
+    def dladm *args
+      run_cmd :dladm, *args
+    end
+    
+    def disks(path)
+      output = zfs :list, '-H -o name -t volume', '-r', path
+      output.split("\n")
+    end
+    
+    def run_cmd(*args)
+      cmd = args.join(' ')
+      puts cmd if verbose
+      ret = %x(#{cmd} 2>&1)
+
+      raise "Execution error: #{cmd}." unless $?.success?
+
+      ret
+    end
+    def exec_with_arg0(command, name, *args)
+      # exec in this form only wants to be given raw arguments that contain
+      # no spaces. This is why we split and flatten args. 
+      exec [command, name], *args.map { |a| a.split }.flatten
+      
+      fail "exec failed."
+    end
+  end
+end

data/lib/qemu-toolkit/config.rb

@@ -0,0 +1,48 @@
+module QemuToolkit
+
+  # A configuration class that acts as a singleton, but really isn't. This 
+  # allows for a mixed style of coding, either using QemuToolkit::Config as 
+  # an instance or as a class. 
+  #
+  class Config
+    class << self # CLASS METHODS
+      def method_missing(sym, *args, &block)
+        return current.send(sym, *args, &block) if current.respond_to?(sym)
+        super
+      end
+      def respond_to?(sym)
+        current.respond_to?(sym) || super
+      end
+      
+      def current
+        @current ||= new
+      end
+      def reset 
+        @current = nil
+      end
+    end
+
+    attr_writer :etc
+    attr_writer :var_run
+    
+    def etc(*args)
+      expand_path(@etc, *args)
+    end
+    def var_run(*args)
+      expand_path(@var_run, *args)
+    end
+    
+    # The command runner backend for all commands. Actual execution happens
+    # through this instance. This has advantages for testing and for 
+    # customizing behaviour. 
+    #
+    def backend
+      @backend ||= Backend::Illumos.new
+    end
+  private
+    def expand_path(*args)
+      File.expand_path(
+        File.join(*args))
+    end
+  end
+end

data/lib/qemu-toolkit/dsl.rb

@@ -0,0 +1,82 @@
+
+module QemuToolkit
+  # A generic dsl class. You define a target keyword you want to associate with
+  # an object instance you also give during construction. The dsl will then 
+  # react only to a call to TARGET, allowing to use a block to configure the 
+  # object you give. 
+  #
+  # Inside the block, the following delegations are made: 
+  #
+  #   foo 'some value'
+  #   # delegated to obj.foo= 'some value' if possible
+  #   # or then to obj.add_foo 'some_value'
+  #
+  # @example
+  #   class Bar
+  #     attr_accessor :name
+  #     attr_accessor :test
+  #   end
+  #   bar = Bar.new
+  #
+  #   dsl = QemuToolkit::DSL::File.new
+  #   dsl.add_toplevel_target :foo, { |name| Bar.new(name) }
+  #   dsl.load_file(some_file)
+  #
+  #   # In this example, some_file would contain something like
+  #   foo('name') do
+  #     test 'something'
+  #   end
+  #   bar.name # => 'name'
+  #   bar.test # => 'something'
+  #
+  class DSL
+    class File
+      attr_reader :objects
+      
+      def initialize
+        @objects = []
+      end
+      def load_file(path)
+        eval(
+          ::File.read(path), 
+          binding, 
+          path)
+      end
+      def add_toplevel_target target, producer
+        define_singleton_method(target) { |*args, &block| 
+          object = producer.call(*args) 
+          Unit.new(object, &block)
+          
+          @objects << object
+        }
+      end
+    end
+    class Unit
+      def initialize(obj, &block)
+        @object = obj
+        instance_eval(&block)
+      end
+      
+      def method_missing(sym, *args, &block)
+        delegate = find_delegate_method(sym, @object)
+        return super unless delegate
+
+        if delegate.arity == args.size
+          delegate.call(*args, &block)
+        else
+          delegate.call(args, &block)
+        end
+      end
+      def respond_to?(sym)
+        find_delegate_method(sym, @object) || super
+      end
+
+    private 
+      def find_delegate_method sym, obj
+        ["#{sym}=", "add_#{sym}"].each { |dm| 
+          return obj.method(dm) if obj.respond_to? dm } 
+        nil
+      end
+    end
+  end
+end

data/lib/qemu-toolkit/iscsi_target.rb

@@ -0,0 +1,80 @@
+module QemuToolkit
+  class ISCSITarget
+    def initialize(iqn, address, backend)
+      @iqn, @address = iqn, address
+      @backend = backend
+      
+      # Keep track if disks has ever returned an array of size > 0. This would
+      # mean that the target is connected and will stay connected until we 
+      # change that. 
+      @mapped = false
+    end
+    
+    attr_reader :iqn
+    attr_reader :address
+    
+    def mapped?
+      disks.size > 0
+    end
+    
+    def ensure_exists
+      # If the target is mapped already, nothing to do. 
+      return if mapped?
+
+      # Map the target
+      begin
+        @backend.iscsiadm :add, 'static-config', "#{iqn},#{address}", '2>/dev/null'
+      rescue 
+        # Ignore already mapped targets
+      end
+      
+      print "Waiting for iSCSI disks to come online..."
+      while !mapped?
+        print '.'
+        sleep 0.5 # takes a short while until login
+      end
+      puts 'OK.'
+    end
+    
+    # A cached 'list target -vS'
+    #
+    def target_list
+      @backend.iscsiadm :list, :target, '-vS'
+    end
+    
+    def disks
+      luns = []
+      
+      state = 0
+      last_lun = nil
+            
+      target_list.each_line do |line|
+        case state
+          when 0
+            state += 1 if line.match(/^Target: #{Regexp.escape(iqn)}\n/m)
+            lun = nil
+          when 1
+            if md=line.match(/^\s+LUN: (\d+)\n/m)
+              last_lun = md[1] 
+            end
+            
+            if last_lun && md=line.match(/^\s+OS Device Name: (\/dev\/rdsk\/.*)\n/m)
+              luns << [Integer(last_lun), md[1]]
+            end
+            
+            state += 1 if line.match(/^Target: /)
+        end
+      end
+      
+      luns.sort_by { |no,_| no }.map { |_, dev| p0ify(dev) }
+    end
+
+  private
+    def p0ify(str)
+      # /dev/rdsk/c4t600144F0503CC9000000503F8B09000Ad0s2 to 
+      # /dev/rdsk/c4t600144F0503CC9000000503F8B09000Ad0p0
+      
+      str.sub(/s2$/, 'p0')
+    end
+  end
+end

data/lib/qemu-toolkit/local_disk_set.rb

@@ -0,0 +1,39 @@
+module QemuToolkit
+
+  class LocalDiskSet
+    def self.for(name, backend)
+      output = backend.zfs :list, "-oname,#{QemuToolkit::EXPORT_TAG} -H"
+      candidates = output.lines.map { |l| l.chomp.strip.split }
+      candidates.reject! { |n,_| ! n }
+      
+      # Finds all qemu-toolkit storage spaces that end in '/name':
+      # Output from this step are only the spaces that match
+      storage_spaces = candidates.
+        select { |cand_name, flag| 
+          %w(true false).include?(flag) && cand_name.end_with?('/'+name) }
+
+      # Finds all disks for each of the candidate exports: 
+      # Output from this step should be <name, disks> tuples
+      storage_spaces.
+        map { |base_name, _| new(
+          base_name, 
+          candidates.map(&:first).
+            select { |name| 
+              
+              name.match(/#{Regexp.escape(base_name)}\/disk\d+/) } ) }
+    end
+    
+    def initialize(name, disks)
+      @name = name
+      @disks = disks
+    end
+    
+    attr_reader :name
+    
+    def each_disk
+      @disks.sort.each do |path|
+        yield "/dev/zvol/dsk/#{path}"
+      end
+    end
+  end
+end

data/lib/qemu-toolkit/storadm.rb

@@ -0,0 +1,110 @@
+require 'clamp'
+
+require 'qemu-toolkit'
+
+module QemuToolkit
+  class Storadm < Clamp::Command 
+    option ['-v', '--verbose'], :flag, 'be chatty'
+    option ['-n', '--dry-run'], :flag, "don't execute commands, instead just print them"
+    
+    # Command backend to use during the processing of subcommands. 
+    #
+    def backend
+      Config.backend
+    end
+    
+    # A factory method for VM storage. 
+    #
+    def storage(name)
+      VMStorage.new(name, backend)
+    end
+    
+    # Main execute method - delegates to _execute in the subcommands. This 
+    # handles transforming Ruby errors into simple shell errors. 
+    #
+    def execute
+      backend.verbose = verbose?
+
+      _execute
+    rescue => error
+      raise if verbose? || $rspec_executing
+
+      $stderr.puts error.to_s
+      exit 1
+    end
+        
+    subcommand('clone', 
+      'Clones an existing VM storage as starting point for quickly creating new VMs.') do
+        
+        parameter 'NAME', 'name of the new VM storage, ie: new_vm'
+        parameter 'TEMPLATE', 'VM storage to use as a template, ie: pool2/template'
+        parameter 'VERSION', 'template version to clone (aka zfs snapshot), ie: v1.2'
+        
+        def _execute
+          storage(template).clone(name, version)
+        end
+      end
+    
+    subcommand('export', 
+      'Creates an iSCSI target for the VM storage, with each disk mapped to a LUN.') do
+        parameter 'NAME', 'name of the VM storage, ie: pool1/new_vm'
+        
+        def _execute
+          s = storage(name)
+          # Export the storage
+          s.export
+          # Print the IQN to be helpful. 
+          puts "Created: #{s.iqn}"
+        end
+      end
+    
+    subcommand('hide', 
+      'Removes iSCSI target for the VM storage from the system.') do
+        parameter 'NAME', 'name of the VM storage, ie: pool1/new_vm'
+
+        def _execute
+          storage(name).hide
+        end
+      end
+    
+    subcommand('create', 
+      "Creates a VM storage space from scratch. Pass the size for at least one disk volume.") do
+        
+        parameter 'NAME', 'name of the VM storage, ie: pool1/new_vm'
+        parameter 'SIZE ...', 'sizes of one or more disks, in ZFS format, ie: 10G'
+        
+        def _execute
+          fail "Must create at least one disk." if size_list.empty?
+          
+          s = storage(name)
+
+          fail "Must specify absulute storage path (pool/dataset) for creation." \
+            if s.relative_name?
+              
+          s.create(size_list)
+        end
+      end
+
+    subcommand('list', 
+      "Lists all vm stores on this machine.") do
+        
+        def _execute
+          re_splitter = /\s+/
+          store_list = backend.zfs :list, "-H -oname,#{QemuToolkit::EXPORT_TAG} -t filesystem"
+          store_list.each_line do |line|
+            clean_line = line.chomp.strip
+            last_space = clean_line.rindex(re_splitter)
+            next unless last_space
+          
+            name, _, flag = clean_line.rpartition(re_splitter)
+            if flag != '-'
+              printf "%-20s", name
+              puts (flag == 'true') ? 
+                storage(name).iqn :
+                '-'
+            end
+          end
+        end
+      end
+  end
+end

data/lib/qemu-toolkit/vm.rb

@@ -0,0 +1,331 @@
+require 'qemu-toolkit/config'
+require 'qemu-toolkit/dsl'
+require 'qemu-toolkit/iscsi_target'
+
+require 'socket'
+
+module QemuToolkit
+  # Abstracts a virtual machine on a vm host. This class provides all sorts
+  # of methods that execute administration actions. 
+  #
+  class VM
+    class << self # CLASS METHODS
+      # Load all vm descriptions and provide an iterator for them. 
+      #
+      def all(backend=nil)
+        Enumerator.new do |yielder|
+          Dir[Config.etc('*.rb')].each do |vm_file|
+            # Load all virtual machines from the given file
+            dsl = DSL::File.new
+            dsl.add_toplevel_target :virtual_machine, lambda { |name| 
+              VM.new(backend).tap { |vm| vm.name = name } }
+              
+            dsl.load_file(vm_file)
+
+            # Yield them all in turn
+            dsl.objects.each do |vm|
+              yielder << vm
+            end
+          end
+        end
+      end
+
+      # Access the definition of a single vm. 
+      #
+      def [](name, backend=nil)
+        all(backend).find { |vm| vm.name === name }
+      end
+    end
+    
+    # VM name
+    attr_accessor :name
+    # iSCSI target iqn and ip address to connect to
+    attr_accessor :iscsi_target
+    # A list of network cards that will be connected to vnics on the host. 
+    attr_reader :nics
+    # A list of network configuration statements that will be passed through
+    # to qemu. 
+    attr_reader :nets
+    # The number of cpus to configure, defaults to 2. 
+    attr_accessor :cpus
+    # Ram in megabytes
+    attr_accessor :ram
+    # VNC display port
+    attr_accessor :vnc_display
+    
+    def initialize(backend)
+      @disks = []
+      @drives = []
+      @nics = []
+      @nets = []
+      @cpus = 2
+      @ram = 1024
+      @backend = backend
+      @vnc_display = nil
+      @extra_args = []
+    end
+        
+    def add_drive(parameters)
+      @drives << parameters
+    end    
+    def add_disk(path)
+      @disks << path
+    end
+    def add_nic(name, parameters)
+      @nics << [name, parameters]
+    end
+    def add_net(type, parameters)
+      @nets << [type, parameters]
+    end
+    def add_extra_arg(argument)
+      @extra_args << argument
+    end
+    
+    # Runs the VM using qemu.
+    def start(dryrun, opts={})
+      if dryrun
+        puts command(opts) 
+      else
+        # Make sure var/run/qemu-toolkit/VMNAME exists.
+        FileUtils.mkdir_p run_path
+        
+        @backend.qemu("vm<#{name}>", command(opts))
+      end
+    end
+    
+    # Returns the command that is needed to run this virtual machine. Note 
+    # that this also modifies system configuration and is not just a routine 
+    # that returns a string.
+    #
+    # @return String command to run the machine
+    #
+    def command opts={}
+      cmd = []
+      cmd << "-name #{name}"
+      cmd << "-m #{ram}"
+      cmd << "-daemonize"
+      cmd << '-nographic'
+      cmd << "-cpu qemu64"
+      cmd << "-smp #{cpus}"
+      cmd << "-no-hpet"
+      cmd << "-enable-kvm"
+      cmd << "-vga cirrus"
+      cmd << "-k de-ch"
+      cmd << "-parallel none"
+      cmd << "-usb"
+      cmd << '-usbdevice tablet'
+
+      # Add disks
+      cmd += disk_options
+      
+      # Was an iso image given to boot from?
+      if iso_path=opts[:bootiso]
+        cmd << "-cdrom #{iso_path}"
+        cmd << "-boot order=cd,once=d"
+      else
+        cmd << '-boot order=cd'
+      end
+      
+      # Set paths for communication with vm
+      cmd << "-pidfile #{pid_path}"
+      
+      cmd << socket_chardev(:monitor, monitor_path)
+      cmd << "-monitor chardev:monitor"
+      
+      cmd << socket_chardev(:serial0, run_path('vm.console'))
+      cmd << "-serial chardev:serial0"
+      cmd << socket_chardev(:serial1, run_path('vm.ttyb'))
+      cmd << "-serial chardev:serial1"
+      
+      # vnc socket
+      cmd << "-vnc unix:#{run_path('vm.vnc')}"
+      
+      # If vnc_display is set, allow configuring a TCP based VNC port: 
+      if vnc_display
+        cmd << "-vnc #{vnc_display}"
+      end
+      
+      # networking: nic
+      vlan = 0
+      # Look up all existing vnics for this virtual machine
+      vnics = Vnic.for_prefix(name, @backend)
+      
+      nics.each do |nic_name, parameters|
+        # All vnics that travel via the given interface (:via)
+        vnics_for_interface = vnics[parameters[:via]] || []
+        
+        # Get a vnic that travels via the given interface.
+        vnic = vnics_for_interface.shift ||
+          Vnic.create(name, parameters[:via], @backend)
+        
+        cmd << "-net vnic,"+
+          parameter_list(
+            vlan: vlan, name: nic_name, 
+            ifname: vnic.vnic_name, 
+            macaddr: parameters[:macaddr])
+        cmd << "-net nic,"+
+          parameter_list(
+            vlan: vlan, name: nic_name, 
+            model: parameters[:model] || 'virtio', 
+            macaddr: parameters[:macaddr])
+
+        vlan += 1
+      end
+      
+      # networking: net
+      nets.each do |type, parameters|
+        cmd << "-net #{type},"+
+          parameter_list(parameters)
+      end
+      
+      # Extra arguments
+      cmd += @extra_args
+      
+      return cmd
+    end
+    def disk_options
+      cmd = []
+      
+      if @disks.empty? && !iscsi_target && @drives.empty?
+        raise "No disks defined, can't run." 
+      end
+      
+      disk_index = 0
+      if iscsi_target
+        target = produce_target(*iscsi_target)
+        target.ensure_exists
+        
+        target.disks.each do |device|
+          params = {
+              file: device, 
+              if: 'virtio', 
+              index: disk_index, 
+              media: 'disk'
+          }
+          params[:boot] = 'on' if disk_index == 0
+          cmd << "-drive " + parameter_list(params)
+          
+          disk_index += 1
+        end
+      end
+      
+      @disks.each do |path|
+        cmd << "-drive file=#{path},if=virtio,index=#{disk_index},"+
+          "media=disk,boot=on"
+        disk_index += 1
+      end
+      
+      @drives.each do |drive_options|
+        cmd << "-drive " + 
+          parameter_list(drive_options.merge(index: disk_index))
+        disk_index += 1
+      end
+      
+      return cmd
+    end
+    
+    # Connects the current terminal to the given socket. Available sockets
+    # include :monitor, :vnc, :console, :ttyb.
+    #
+    def connect(socket)
+      socket_path = run_path("vm.#{socket}")
+      cmd = "socat stdio unix-connect:#{socket_path}"
+      
+      exec cmd
+    end
+    
+    # Kills the vm the hard way. 
+    #
+    def kill
+      run_cmd "kill #{pid}"
+    end
+    
+    # Sends a shutdown command via the monitor socket of the virtual machine. 
+    # 
+    def shutdown
+      monitor_cmd 'system_powerdown'
+    end
+    
+    # Returns an ISCSITarget for host and port. 
+    #
+    def produce_target(host, port)
+      ISCSITarget.new(host, port, @backend)
+    end
+    
+    # Returns true if the virtual machine seems to be currently running. 
+    #
+    def running?
+      if File.exist?(pid_path) 
+        # Prod the process using kill. This will not actually kill the
+        # process!
+        begin
+          Process.kill(0, pid)
+        rescue Errno::ESRCH
+          # When this point is reached, the process doesn't exist. 
+          return false
+        end
+
+        return true
+      end
+      
+      return false
+    end
+    
+    # Attempts to read and return the pid of the running VM process.
+    #
+    def pid
+      Integer(File.read(pid_path).lines.first.chomp)
+    end
+    
+  private 
+    def monitor_cmd(cmd)
+      socket = UNIXSocket.new(monitor_path)
+      socket.puts cmd
+      socket.close
+    end
+  
+    def socket_chardev(name, path)
+      "-chardev socket,id=#{name},path=#{path},server,nowait"
+    end
+
+    # Formats a parameter list as key=value,key=value
+    #
+    def parameter_list(parameters)
+      parameters.
+        map { |k,v| "#{k}=#{v}" }.
+        join(',')
+    end
+    
+    # Returns the path below /var/run (usually) that contains runtime files
+    # for the virtual machine. 
+    #
+    def run_path(*args)
+      Config.var_run(name, *args)
+    end
+    
+    # Returns the file path of the vm pid file. 
+    #
+    def pid_path
+      run_path 'vm.pid'
+    end
+
+    # Returns the file path of the monitor socket (unix socket below /var/run)
+    # usually. )
+    #
+    def monitor_path
+      run_path 'vm.monitor'
+    end
+      
+    # Runs a command and returns its stdout. This raises an error if the 
+    # command doesn't exit with a status of 0.
+    #
+    def run_cmd(*args)
+      cmd = args.join(' ')
+      ret = %x(#{cmd})
+
+      raise "Execution error: #{cmd}." unless $?.success?
+
+      ret
+    end
+  end
+end

data/lib/qemu-toolkit/vm_storage.rb

@@ -0,0 +1,180 @@
+module QemuToolkit
+  class VMStorage
+    def initialize(name, backend)
+      @name = name
+      @backend = backend
+    end
+    
+    attr_reader :backend
+    attr_reader :name
+    
+    def create(sizes)
+      backend.zfs :create, "-o #{QemuToolkit::EXPORT_TAG}=false", name
+      sizes.each_with_index do |size, idx|
+        backend.zfs :create, "-V #{size}", name + "/disk#{idx+1}"
+      end
+    end
+    
+    # Clones this vm storage to the given target name. If target_name is 
+    # given without pool part, clone will live in the same pool as its parent
+    # vm storage. The version argument specifies which version should be 
+    # cloned and must be a recursive snapshot on the parent vm. 
+    #
+    def clone(target_name, version)
+      raise ArgumentError, "Must specify the dataset path for cloning." \
+        if relative_name?
+      
+      path, vm_name = split
+      target_path = join path, target_name
+      backend.zfs :clone, "#@name@#{version}", target_path
+      
+      backend.disks(name).each do |disk_path|
+        disk_name = subtract @name, disk_path
+        target_disk_name = join path, target_name, disk_name
+        backend.zfs :clone, "#{disk_path}@#{version}", target_disk_name
+      end
+      
+      # Mark the dataset as hidden
+      backend.zfs :set, "#{QemuToolkit::EXPORT_TAG}=false", join(path, target_name)
+    end
+    
+    # Exports all disks of a virtual machine (called 'diskN' below the main
+    # dataset) as LUNs below a single iqn for the machine. 
+    #
+    def export
+      fail "VM storage #{name} does not exist." unless exist?
+      fail "VM storage #{name} is already exported." if exported?
+      
+      path, vm_name = split
+      
+      backend.stmfadm 'create-tg', vm_name
+      
+      backend.disks(name).each do |disk_path|
+        output = backend.stmfadm 'create-lu', "/dev/zvol/rdsk/"+disk_path
+        
+        md=output.match /Logical unit created: ([0-9A-F]+)/
+        raise "Could not parse created LU. (#{output.inspect})" unless md
+        
+        backend.stmfadm 'add-view', "-t #{vm_name}", md[1]
+      end
+      
+      backend.stmfadm 'add-tg-member', "-g #{vm_name}", iqn
+      backend.itadm 'create-target', "-n #{iqn}", '-t frontend'
+      
+      # Mark the dataset as exported
+      backend.zfs :set, "#{QemuToolkit::EXPORT_TAG}=true", name
+    end
+    
+    # Returns true if the storage exists and is exported currently. Returns
+    # false if the storage exists and is not exported. In all other cases
+    # this method returns nil. 
+    #
+    def exported?
+      case (export_tag || '').chomp
+        when 'true'
+          return true
+        when 'false'
+          return false
+      end
+      
+      return nil
+    end
+    
+    # Returns true if the storage seems to exist and be a valid vm storage. 
+    # 
+    def exist?
+      ! export_tag.nil?
+    end
+
+    # Hides the vm storage from iSCSI. 
+    #
+    def hide
+      fail "VM storage #{name} does not exist." unless exist?
+      fail "VM storage #{name} is already hidden." unless exported?
+
+      path, vm_name = split
+      
+      raise "Cannot find an exported dataset named #{name}. " \
+        unless exported?
+      
+      backend.stmfadm 'offline-target', iqn
+      backend.itadm 'delete-target', iqn
+      
+      # Parse existing lus, look for vm_name/diskN
+      lus = backend.stmfadm 'list-lu', '-v'
+      last_lu = nil
+      lus.each_line do |line|
+        if md=line.match(/LU Name: ([0-9A-F]+)/)
+          last_lu = md[1]
+        end
+        if line.include?('Data File') && 
+          line.include?('/dev/zvol/rdsk') && 
+          line.match(%r(/#{Regexp.escape(vm_name)}/disk\d+))
+          
+          backend.stmfadm 'delete-lu', last_lu
+        end
+      end
+      
+      backend.stmfadm 'delete-tg', vm_name
+
+      # Mark the dataset as hidden
+      backend.zfs :set, "#{QemuToolkit::EXPORT_TAG}=false", name
+    end
+  
+    # Returns whether the name used to construct this instance is relative 
+    # or absolute. A relative name identifies a storage within its pool, 
+    # an absolute name identifies it within the whole system. 
+    #
+    #   VMStorage.new('foo').relative_name?     # => true
+    #   VMStorage.new('b1/foo').relative_name?  # => false
+    #
+    def relative_name?
+      @name.index('/') == nil
+    end
+    
+    def iqn
+      _, n = split
+      "iqn.2012-01.com.qemu-toolkit:#{n}"
+    end
+    
+  private
+  
+    # Returns the (cached) value of QemuToolkit::EXPORT_TAG of this storage.
+    # This does nothing more than execute
+    #   zfs get -Ho value #{QemuToolkit::EXPORT_TAG} NAME
+    # and handle an exception by returning nil. 
+    # 
+    def export_tag
+      @export_tag ||= begin
+        backend.zfs :get, "-Ho value #{QemuToolkit::EXPORT_TAG}", name
+      rescue 
+        nil
+      end
+    end
+
+    # Returns a pair of dataset path and dataset name for the vm storage. 
+    #
+    # @example
+    #   VMStorage.new('foo/bar/baz').split 
+    #   # => ['foo/bar', 'baz']
+    #
+    def split
+      File.split(@name)
+    end
+    
+    # Joins parts of a vm storage name. 
+    #
+    def join(*args)
+      File.join(*args)
+    end
+    
+    # Subtracts a prefix from a given string. 
+    #
+    # @example
+    #   subtract 'foo', 'foo/bar' # => '/bar'
+    def subtract(prefix, string)
+      raise ArgumentError unless string.start_with?(prefix)
+      string[prefix.size..-1]
+    end
+  end
+end

data/lib/qemu-toolkit/vmadm.rb

@@ -0,0 +1,182 @@
+require 'clamp'
+
+require 'qemu-toolkit/local_disk_set'
+
+module QemuToolkit
+  class Vmadm < Clamp::Command 
+    
+    option ['-v', '--verbose'], :flag, 'be chatty'
+    option ['-n', '--dry-run'], :flag, 
+      "don't execute commands, instead just print them"
+    
+    option '--vmpath', "VMPATH", 
+      "path to vm descriptions", default: '/etc/qemu-toolkit'
+    option '--varrun', 'VARRUN', 
+      'path to runtime files', default: '/var/run/qemu-toolkit'
+      
+    # Command backend to use during the processing of subcommands. 
+    #
+    def backend
+      Config.backend
+    end
+
+    # Main execute method - delegates to _execute in the subcommands. This 
+    # handles transforming Ruby errors into simple shell errors. 
+    #
+    def execute
+      backend.verbose = verbose?
+      
+      Config.etc = vmpath
+      Config.var_run = varrun
+
+      fail NotImplementedError, "Missing subcommand." unless respond_to?(:_execute)
+      _execute 
+    rescue => error
+      raise if verbose? || $rspec_executing
+
+      $stderr.puts error.to_s
+      exit 1
+    end
+    
+    subcommand('list', 
+      'Lists all virtual machines on this system') do
+        def _execute
+          VM.all(backend).each do |vm|
+            printf "%-20s", vm.name
+            printf " %5s", vm.running? ? vm.pid : 'off'
+            puts
+          end
+        end
+      end
+      
+    # subcommand('random-mac', 
+    #   'Generates a random MAC address') do
+    #     def _execute
+    #       puts random_mac_address
+    #     end
+    #   end          
+    
+    subcommand('create', 
+      'Creates a configuration file for the VM from a template, filling in plausible values.') do
+
+        parameter 'NAME', 'name of the virtual machine'
+        
+        def _execute
+          if VM[name]
+            puts "Machine already exists."
+            exit 1
+          end
+          
+          File.write(
+            Config.etc("#{name}.rb"), 
+            vm_template(name))
+            
+          FileUtils.mkdir(Config.var_run(name))
+        end
+        
+        def vm_template(name)
+          local_disks = StringIO.new
+
+          disk_sets = LocalDiskSet.for(name, backend)
+          disk_sets.each do |set|
+            local_disks.puts "  # Disks for storage at #{set.name}"
+            set.each_disk do |dev_path|
+              local_disks.puts "  disk '#{dev_path}'"
+            end
+            local_disks.puts
+          end
+
+          %Q(virtual_machine "#{name}" do
+  # Block device setup
+  # 
+  # Either configure a remote disk (via iSCSI):
+  # iscsi_target 'iqn.2012-01.com.qemu-toolkit:#{name}', "10.40.0.1"
+  # 
+  # Or a local disk, like a zvol for example: 
+  # disk /dev/zvol/dsk/pool/#{name}/disk1
+#{local_disks.string}
+
+  # Network configuration
+  # nic 'eth0', 
+  #   macaddr: '#{random_mac_address}', 
+  #   via: 'igbX'
+end
+)
+        end
+      end
+
+    subcommand('start', 
+      'Starts the virtual machine and daemonizes it.') do
+
+        parameter 'NAME', 'name of the virtual machine'
+        option '--bootiso', 'BOOTISO', 'boots this ISO instead of disk0'
+        
+        def _execute
+          vm(name).start(dry_run?, bootiso: bootiso)
+        end
+      end
+      
+    subcommand('monitor', 
+      'Enter QEMU monitor interactively for given VM.') do
+        parameter 'NAME', 'name of the virtual machine'
+
+        def _execute
+          vm(name).connect(:monitor)
+        end
+      end
+    subcommand('shutdown', 
+      'Shuts the VM down by issuing a system/powerdown event.') do
+        parameter 'NAME', 'name of the virtual machine'
+
+        def _execute
+          vm(name).shutdown
+        end
+      end
+
+    subcommand('kill', 
+      'Tries to kill the VM using the kill command.') do
+        parameter 'NAME', 'name of the virtual machine'
+
+        def _execute
+          vm(name).kill
+        end
+      end
+        
+    subcommand('vnc', 
+      'Connect VM VNC server to standard IO. (use ssvnc to connect)') do
+        parameter 'NAME', 'name of the virtual machine'
+        
+        def _execute
+          vm(name).connect(:vnc)
+        end
+      end
+
+    subcommand('console', 
+      'Opens serial console to VM. This only works if you configure your VM accordingly.') do
+        parameter 'NAME', 'name of the virtual machine'
+        
+        def _execute
+          vm(name).connect(:console)
+        end
+      end
+
+    def random_mac_address
+      # Please see this discussion if improving this: 
+      # http://stackoverflow.com/questions/8484877/mac-address-generator-in-python
+      mac = [ 0x00, 0x24, 0x81,
+          rand(0x7f),
+          rand(0xff),
+          rand(0xff) ]
+      mac.map { |e| e.to_s(16) }.join(':')
+    end
+    def vm(name)
+      vm = VM[name, backend]
+      unless vm
+        puts "No virtual machine by the name '#{name}' found."
+        exit 1
+      end
+    
+      vm
+    end
+  end
+end 

data/lib/qemu-toolkit/vnic.rb

@@ -0,0 +1,61 @@
+module QemuToolkit
+  class Vnic
+    class << self
+      def for_prefix(prefix, background)
+        vnics = Hash.new { |h,k| h[k] = Array.new; }
+        links = background.dladm 'show-vnic', '-po link,over,vid'
+        
+        links.each_line do |line|
+          next unless line.start_with?(prefix)
+          link, over, vid = line.chomp.split(':')
+          
+          # Assumes that vid 0 is always the 'no vlan' VLAN
+          over = "#{over}:#{vid}" if vid.to_i > 0
+          
+          if md=link.match(/^(?<vm>.*)_(?<link_no>\d+)$/)
+            vnics[over] << Vnic.new(md[:vm], Integer(md[:link_no]), over)
+          end
+        end
+        
+        vnics
+      end
+      
+      def create(prefix, over, backend)
+        # Retrieve links that exist for this prefix and this over interface
+        vnics = for_prefix(prefix, backend).values.flatten
+        next_vnic_number = (vnics.map(&:number).max || 0) + 1
+
+        new(prefix, next_vnic_number, over).tap { |o|
+          o.create(backend) }
+      end
+      
+    end
+    
+    def initialize(prefix, number, over)
+      @prefix, @number, @over = prefix, number, over
+    end
+    
+    attr_reader :prefix
+    attr_reader :number
+    attr_reader :over
+    
+    def ==(other)
+      self.prefix == other.prefix && 
+        self.number == other.number && 
+        self.over == other.over
+    end
+    
+    def create backend
+      if over.index(':')
+        iface, vlan = over.split(':')
+        backend.dladm 'create-vnic', "-l #{iface} -v #{vlan}", vnic_name
+      else
+        backend.dladm 'create-vnic', "-l #{over}", vnic_name
+      end
+    end
+    
+    def vnic_name
+      "#{prefix}_#{number}"
+    end
+  end
+end

data/lib/qemu-toolkit.rb

@@ -0,0 +1,12 @@
+
+module QemuToolkit
+  EXPORT_TAG = 'qemu_toolkit:export'
+  
+  module Backend; end
+end
+
+require 'qemu-toolkit/config'
+require 'qemu-toolkit/vm'
+require 'qemu-toolkit/vm_storage'
+require 'qemu-toolkit/backend/illumos'
+require 'qemu-toolkit/vnic'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: qemu-toolkit
+version: !ruby/object:Gem::Version
+  version: 0.2.18
+  prerelease: 
+platform: ruby
+authors:
+- Kaspar Schiess
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: kaspar.schiess@technologyastronauts.ch
+executables:
+- vmadm
+- storadm
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- LICENSE
+- README
+- lib/qemu-toolkit/backend/illumos.rb
+- lib/qemu-toolkit/config.rb
+- lib/qemu-toolkit/dsl.rb
+- lib/qemu-toolkit/iscsi_target.rb
+- lib/qemu-toolkit/local_disk_set.rb
+- lib/qemu-toolkit/storadm.rb
+- lib/qemu-toolkit/vm.rb
+- lib/qemu-toolkit/vm_storage.rb
+- lib/qemu-toolkit/vmadm.rb
+- lib/qemu-toolkit/vnic.rb
+- lib/qemu-toolkit.rb
+- bin/storadm
+- bin/vmadm
+- bin/vmconnect
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README
+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.24
+signing_key: 
+specification_version: 3
+summary: Manages QEMU kvm virtual machines on Illumos hosts.
+test_files: []