vbox-ng 0.1.3 → 1.0.0

data/lib/vbox/cmdlineapi.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 require 'awesome_print'
+require 'open3'
 
 module VBOX
 
@@ -12,28 +13,72 @@ module VBOX
 
     def initialize options={}
       @options = options
-      @options[:verbose] ||= 2 if @options[:dry_run]
-      @options[:verbose] ||= 0
+      @options[:verbose] = VBOX.verbosity
+      @options[:verbose] ||= 2 if @options[:dry_run] && @options[:verbose] < 2
     end
 
-    # run as in backtick operator, and return result
-    def ` cmd
-      puts "[.] #{cmd}".gray if @options[:verbose] >= 2
-      exit if @options[:dry_run]
-      r = super
-      #exit 1 unless $?.success?
+    private
+
+    def quiet &block
+      prev_verbose = @options[:verbose]
+      @options[:verbose] = -100
+      r = yield
+    ensure
+      @options[:verbose] = prev_verbose
       r
     end
 
-    # run as in system() call
-    def system *args
-      puts "[.] #{args.inspect}".gray if @options[:verbose] >= 2
+    def vboxmanage *args
+      args = args.map do |arg|
+        case arg
+        when Hash
+          arg.map{ |k,v| ["--#{k}", v == '' ? nil : v.to_s] }
+        else
+          arg.to_s
+        end
+      end.flatten.compact
+
+      puts "[.] VBoxManage #{args.join(' ')}".gray if @options[:verbose] >= 2
       exit if @options[:dry_run]
-      r = super
-      #exit 1 unless $?.success?
-      r
+
+      stdout = stderr = nil
+      Open3.popen3("VBoxManage", *args.map(&:to_s)) do |i,o,e,x|
+        i.close
+        stdout = o.read.to_s.strip
+        stderr = e.read.to_s.strip
+        @success = (x ? x.value : $?).success?
+      end
+
+      if @options[:verbose] >= 0
+        STDERR.puts( success? ? stderr : stderr.red ) unless stderr.empty?
+        puts(stdout) if @options[:verbose] >= 3 && !stdout.empty?
+      end
+
+      stdout
+    end
+
+    # internal method that indicates result of recent vboxmanage() cmd
+    def success?
+      @success
     end
 
+#    # run as in backtick operator, and return result
+#    def ` cmd
+#      puts "[.] #{cmd}".gray if @options[:verbose] >= 2
+#      exit if @options[:dry_run]
+#      r = super
+#      #exit 1 unless success?#      r
+#    end
+#
+#    # run as in system() call
+#    def system *args
+#      puts "[.] #{args.inspect}".gray if @options[:verbose] >= 2
+#      exit if @options[:dry_run]
+#      r = super
+#      #exit 1 unless success?#      r
+#    end
+
+    public
     def get_vm_details vm_or_name_or_uuid
       name_or_uuid = case vm_or_name_or_uuid
         when String
@@ -41,32 +86,25 @@ module VBOX
           vm_or_name_or_uuid
         when VM
           vm = vm_or_name_or_uuid
-          vm.uuid
+          vm.uuid || vm.name
         end
 
-      data = `VBoxManage showvminfo "#{name_or_uuid}" --machinereadable`
+      h = {}
+      data = quiet{ vboxmanage :showvminfo, name_or_uuid, "--machinereadable" }
       data.each_line do |line|
-        k,v = line.strip.split('=',2)
+        k,v = line.split('=',2)
         next unless v
-        vm.all_vars[k] = v # not stripping quotes here to save some CPU time
-        case k
-        when 'name'
-          vm.name = v.strip.sub(/^"/,'').sub(/"$/,'')
-        when 'UUID'
-          vm.uuid = v.strip.sub(/^"/,'').sub(/"$/,'')
-        when 'memory'
-          vm.memory_size = v.to_i
-        when 'VMState'
-          vm.state = v.tr('"','').to_sym
-#        when 'CfgFile'
-#          dir = File.dirname(v.tr('"',''))
-#          s = `du -s -BM "#{dir}"`
-#          vm.dir_size = s.split("\t").first.tr("M","")
-        end
+        h[qstrip(k)] = qstrip(v)
       end
-      (vm.name && vm.uuid) ? vm : nil
+      h.empty? ? nil : h
     end
 
+    def createvm vm
+      options = { :name => vm.name, :register => '' }
+      options[:uuid] = vm.uuid if vm.uuid
+      a = vboxmanage :createvm, options
+      success?    end
+
     # for natural string sort order
     # http://stackoverflow.com/questions/4078906/is-there-a-natural-sort-by-method-for-ruby
     def _naturalize s
@@ -74,56 +112,60 @@ module VBOX
     end
 
     def list_vms params = {}
-      if params[:running]
-        data = `VBoxManage list runningvms`
-      else
-        data = `VBoxManage list vms`
-      end
-      r = []
-      data.strip.each_line do |line|
+      vms = []
+      vboxmanage(:list, :vms).each_line do |line|
         if line[UUID_RE]
           vm = VM.new
           vm.uuid = $&
-          vm.name = line.gsub($&, '').strip.sub(/^"/,'').sub(/"$/,'')
-          r << vm
+          vm.name = qstrip(line.gsub($&, ''))
+          vms << vm
         end
       end
-      r.sort_by{ |vm| _naturalize(vm.name) }
+      if params[:include_state]
+        # second pass
+        h = Hash[*vms.map{ |vm| [vm.uuid, vm] }.flatten]
+        uuid = nil # declare variable for inner loop
+        vboxmanage(:list, :runningvms).each_line do |line|
+          h[uuid].state = :running if (uuid=line[UUID_RE]) && h[uuid]
+        end
+      end
+      vms.sort_by{ |vm| _naturalize(vm.name) }
+    end
+
+    private
+    # strip quotes
+    def qstrip s
+      s.strip.sub /\A"(.*)"\Z/, '\1'
     end
 
+    public
     def get_vm_info name
-      data = `VBoxManage showvminfo "#{name}" --machinereadable`
       h = {}
-      data.each_line do |line|
-        line.strip!
+      vboxmanage(:showvminfo, name, "--machinereadable").each_line do |line|
         k,v = line.split('=',2)
-        h[k] = v
+        h[qstrip(k)] = qstrip(v)
       end
       h
     end
 
-    def show name
-      get_vm_info(name).each do |k,v|
-        next if ['"none"', '"off"', '""'].include?(v)
-        puts "#{k}=#{v}"
-      end
-    end
-
     COMMANDS.each do |cmd|
-      class_eval <<-EOF unless method_defined?(cmd.to_sym)
-        def #{cmd} name
-          system "VBoxManage", "controlvm", name, "#{cmd}"
+      unless method_defined?(cmd.to_sym)
+        define_method(cmd) do |name|
+          vboxmanage :controlvm, name, cmd
         end
-      EOF
+      end
     end
 
-    def start name
-      if ENV['DISPLAY'] && !@options[:headless]
-        system "VBoxManage", "startvm", name
+    def start name, options = {}
+      headless = @options[:headless]
+      headless =  options[:headless] if options.key?(:headless)
+
+      if ENV['DISPLAY'] && !headless
+        vboxmanage :startvm, name
       else
-        puts "[.] $DISPLAY is not set, assuming --headless".gray unless @options[:headless]
+        puts "[.] $DISPLAY is not set, assuming --headless".gray unless headless
         @options[:headless] = true
-        system "VBoxManage", "startvm", name, "--type", "headless"
+        vboxmanage :startvm, name, :type => :headless
       end
     end
 
@@ -131,10 +173,10 @@ module VBOX
     def get_snapshots _name
       r = []
       name = uuid = nil
-      `VBoxManage snapshot "#{_name}" list --machinereadable`.strip.each_line do |line|
+      vboxmanage(:snapshot, _name, 'list', '--machinereadable').each_line do |line|
         k,v = line.strip.split('=',2)
         next unless v
-        v = v.strip.sub(/^"/,'').sub(/"$/,'')
+        v = qstrip(v)
         case k
         when /SnapshotName/
           name = v
@@ -152,12 +194,13 @@ module VBOX
     # d0   -> d1, d2, d3
     # d1   -> d1.1, d1.2, d1.3
     # d1.1 -> d1.1.1, d1.1.2, d1.1.3
+    # xx   -> xx.1, xx.2, xx.3
     def _gen_vm_name parent_name
       # try to guess new name
+      names = list_vms.map(&:name)
       numbers = parent_name.scan /\d+/
       if numbers.any?
         lastnum = numbers.last
-        names = list_vms.map(&:name)
         if lastnum.to_i == 0
           # d0 -> d1, d2, d3
           newnum = lastnum.to_i + 1
@@ -177,13 +220,21 @@ module VBOX
             newnum += 1
           end
         end
+      else
+        # xx -> xx.1, xx.2, xx.3
+        newnum = 1
+        while true
+          newname = "#{parent_name}.#{newnum}"
+          return newname unless names.include?(newname)
+          newnum += 1
+        end
       end
       nil
     end
 
     def take_snapshot vm_name, params = {}
-      system "VBoxManage", "snapshot", vm_name, "take", params[:name] || "noname"
-      exit 1 unless $?.success?
+      vboxmanage "snapshot", vm_name, "take", params[:name] || "noname"
+      exit 1 unless success?
       get_snapshots(vm_name).last
     end
 
@@ -208,9 +259,9 @@ module VBOX
     end
 
     def _clone old_vm_name, params
-      args = []
-      if new_vm_name = params['name'] || _gen_vm_name(old_vm_name)
-        args += ["--name", new_vm_name]
+      args = {}
+      if new_vm_name = params[:name] || _gen_vm_name(old_vm_name)
+        args[:name] = new_vm_name
       end
 
       snapshot = @clone_use_snapshot ||= case params[:snapshot].to_s
@@ -219,47 +270,42 @@ module VBOX
         when 'last'
           get_snapshots(old_vm_name).last
         else
-          puts "[!] please gimme --snapshot=LAST OR --snapshot=NEW option"
-          exit 1
+          raise "no :snapshot param"
         end
       unless snapshot
-        puts "[!] failed to get snapshot, cannot continue".red
-        exit 1
+        raise "failed to get snapshot"
       end
 
-      args += ["--options","link"]
-      args += ["--register"]
-      args += ["--snapshot", snapshot.uuid]
-
-      system "VBoxManage", "clonevm", old_vm_name, *args
-      return false unless $?.success?
+      args[:options]  = :link
+      args[:register] = ''
+      args[:snapshot] = snapshot.uuid
 
+      vboxmanage :clonevm, old_vm_name, args
+      return false unless success?
       get_vm_info(old_vm_name).each do |k,v|
         if k =~ /^macaddress/
-          old_mac = v.tr('"','').downcase
+          old_mac = v.downcase
           puts "[.] old #{k}=#{old_mac}"
           old_automac = _name2macpart(old_vm_name)
           if old_automac && old_mac[-old_automac.size..-1] == old_automac
             new_automac = _name2macpart(new_vm_name)
             new_mac = old_mac[0,old_mac.size-new_automac.size] + new_automac
             puts "[.] new #{k}=#{new_mac}"
-            modify new_vm_name, k, new_mac, :quiet => true
+            modify new_vm_name, k => new_mac
           end
         end
       end
       new_vm_name
     end
 
-    def modify name, k, v, params = {}
-      system "VBoxManage", "modifyvm", name, "--#{k}", v
-      if $?.success? && !params[:quiet]
-        h = get_vm_info(k == 'name' ? v : name)
-        puts "#{k}=#{h[k]}"
-      end
+    def modify vm, vars
+      id = vm.is_a?(VM) ? (vm.uuid || vm.name) : vm.to_s
+      vboxmanage :modifyvm, id, vars
+      success?
     end
 
     def delete name
-      system "VBoxManage", "unregistervm", name, "--delete"
+      vboxmanage :unregistervm, name, "--delete"
     end
     alias :destroy :delete
   end

data/lib/vbox/vm.rb

@@ -1,15 +1,86 @@
 module VBOX
   class VM
-    attr_accessor :name, :uuid, :memory_size, :dir_size, :state, :all_vars
+    attr_accessor :name, :uuid, :state
 
-    def initialize
-      @all_vars = {}
+    def initialize params = {}
+      @metadata = params[:metadata]
+      _parse_metadata
+      @name = params[:name] if params[:name]
+      @uuid = params[:uuid] if params[:uuid]
     end
 
+    private
+
+    def _parse_metadata
+      return unless @metadata && @metadata.any?
+      @name  = @metadata['name']
+      @uuid  = @metadata['UUID']
+      @state = @metadata['VMState'].to_sym
+    end
+
+    def deep_copy x
+      Marshal.load(Marshal.dump(x))
+    end
+
+    public
+
+    def metadata
+      if !@metadata || @metadata.empty?
+        reload_metadata
+      end
+      @metadata
+    end
+    alias :fetch_metadata :metadata
+
     %w'start pause resume reset poweroff savestate acpipowerbutton acpisleepbutton destroy'.each do |action|
-      define_method "#{action}!" do
-        VBOX.api.send( action, uuid || name )
+      define_method "#{action}!" do |*args|
+        VBOX.api.send( action, uuid || name, *args )
+      end
+    end
+
+    def create!
+      raise "cannot create VM w/o name" if self.name.to_s == ""
+      VBOX.api.createvm(self) || raise("failed to create VM")
+      reload_metadata
+      self
+    end
+
+    # set some variable: change VM name, memory size, pae, etc
+    def set_var k, v = nil
+      reload_metadata unless @metadata
+      @metadata_orig ||= deep_copy(@metadata)
+
+      if k.is_a?(Hash) && v.nil?
+        k.each do |kk,vv|
+          @metadata[kk.to_s] = vv.to_s
+        end
+      elsif !k.is_a?(Hash) && !v.is_a?(Hash)
+        @metadata[k.to_s] = v.to_s
+      else
+        raise "invalid params combination"
+      end
+    end
+    alias :set_vars :set_var
+
+    # save modified metadata, if any
+    def save
+      return nil if @metadata == @metadata_orig
+      vars = {}
+      @metadata.each do |k,v|
+        vars[k] = v if @metadata[k].to_s != @metadata_orig[k].to_s
       end
+      VBOX.api.modify self, vars
+    end
+
+    # reload all VM metadata info from VirtualBox
+    def reload_metadata
+      raise "cannot reload metadata if name & uuid are NULL" unless name || uuid
+      @metadata = VBOX.api.get_vm_details(self)
+
+      # make a 'deep copy' of @metadata to detect changed vars
+      # dup() or clone() does not fit here b/c they leave hash values linked to each other
+      @metadata_orig = deep_copy(@metadata)
+      _parse_metadata
     end
 
     def clone! params
@@ -35,16 +106,23 @@ module VBOX
     def dir_size
       @dir_size ||=
         begin
-          VBOX.api.get_vm_details(self) unless @all_vars['CfgFile']
-          return nil unless v=@all_vars['CfgFile']
-          dir = File.dirname(v.tr('"',''))
+          return nil unless v=metadata['CfgFile']
+          dir = File.dirname(v)
           `du -sm "#{dir}"`.split("\t").first.tr("M","").to_i
         end
     end
 
+    def memory_size
+      metadata['memory'].to_i
+    end
+
+    def snapshots
+      VBOX.api.get_snapshots(uuid||name)
+    end
+
     class << self
       def all
-        VBOX.api.list_vms
+        VBOX.api.list_vms :include_state => true
       end
 
       def first
@@ -52,10 +130,32 @@ module VBOX
       end
 
       def find name_or_uuid
-        VBOX.api.get_vm_details name_or_uuid
+        r = VBOX.api.get_vm_details name_or_uuid
+        r ? VM.new(:metadata => r) : nil
       end
-
       alias :[] :find
+
+      def find_all glob
+        all.keep_if do |vm|
+          expand_glob(glob){ |glob1| File.fnmatch(glob1, vm.name) }
+        end
+      end
+
+      # expand globs like "d{1-30}" to d1,d2,d3,d4,...,d29,d30
+      def expand_glob glob, &block
+        if glob[/\{(\d+)-(\d+)\}/]
+          $1.to_i.upto($2.to_i) do |i|
+            expand_glob glob.sub($&,i.to_s), &block
+          end
+        else
+          yield glob
+        end
+      end
+
+      def create! *args
+        new(*args).create!
+      end
+
     end
   end
 end