xen 0.1.1 → 0.1.2

data/README

@@ -2,6 +2,12 @@
 
 Xen strives to be the Ruby interface talking to the Xen API. It grew from our own need to talk to Xen Servers with Ruby.
 
+=== Install:
+xen is a registered rubygem, so you can just do
+  sudo gem install xen
+
+And you're good to go.
+
 === Usage:
 
   # Connect to xenhost
@@ -13,4 +19,23 @@ Xen strives to be the Ruby interface talking to the Xen API. It grew from our ow
   end
   
   # Restart a certain VM
-  xenhost.find_vm('example_vm').clean_reboot!
+  xenhost.find_vm('example_vm').clean_reboot!
+
+
+=== Creating a new VM:
+
+  h = Xen::Host.new('10.1.10.200')
+
+  network =Xen::Network.find_by_name 'xenbr101', h
+
+  vm = h.create_vm 'slice', 128*1024*1024
+
+  vdi_hda1 = h.create_vdi 'vdi1', 'phy:/dev/xendomains/slice-root'
+  vdi_hda2 = h.create_vdi 'vdi2', 'phy:/dev/xendomains/slice-swap'
+
+  vbd1 = h.create_vbd 'hda1', vm, vdi_hda1
+  vbd2 = h.create_vbd 'hda2', vm, vdi_hda2
+
+  vif = h.create_vif vm, network, '00:30:48:88:81:03'
+
+  vm.start!

data/lib/xen.rb

@@ -1,4 +1,10 @@
+require 'xen/base.rb'
 require 'xen/connection.rb'
 require 'xen/host.rb'
 require 'xen/vm.rb'
-require 'xen/network.rb'
+require 'xen/network.rb'
+require 'xen/sr.rb'
+require 'xen/vdi.rb'
+require 'xen/vbd.rb'
+require 'xen/console.rb'
+require 'xen/vif.rb'

data/lib/xen/base.rb

@@ -0,0 +1,19 @@
+module Xen
+  class Base
+    def initialize(uid, host)
+      @uid, @host = uid, host
+    end
+    
+    def uuid
+      self.to_s
+    end
+    
+    def to_s
+      @uid.to_s
+    end 
+
+    def record
+      @host.get_value("#{self.class.to_s.gsub(/^.*::/, '')}.get_record", @uid)
+    end
+  end
+end

data/lib/xen/console.rb

@@ -0,0 +1,16 @@
+module Xen
+  class Console < Base
+
+    # The initial config for a new VDI device
+    @initial_config = {
+        :protocol => 'rfb'
+    }
+  
+    # Create method, takes a name, a device (p.ex. 'phy:/dev/storage/slice') and a host
+    def self.create(vm, host)
+      config = @initial_config.merge({:VM => vm.uuid})
+      uuid = host.get_value("console.create", config)
+      self.new(uuid, host)
+    end
+  end
+end

data/lib/xen/host.rb

@@ -18,7 +18,7 @@ module Xen
     # Gives an array of active VM's on that Host.
     def vms
       get_value("host.get_resident_VMs", uid).collect do |vm_uid|
-        Vm.new(vm_uid, self) # Isn't this expensive?
+        VM.new(vm_uid, self) # Isn't this expensive?
       end
     end
     
@@ -47,6 +47,31 @@ module Xen
       get_value("host.get_record")
     end
 
+    # gives the local storage resource
+    def get_local_sr
+      SR.get_local(self)
+    end
+
+    def create_vdi(name, dev)
+      VDI.create(name, dev, self)
+    end
+
+    def create_vbd(device, vm, vdi)
+      VBD.create(device, vm, vdi, self)
+    end
+
+    def create_vif(vm, network, mac)
+      VIF.create(vm, network, mac, self)
+    end
+
+    def create_vm(name, memory)
+      VM.create(name, memory, self)
+    end
+
+    def create_console(vm)
+      Console.create(vm, self)
+    end
+
     def to_s
       uid.to_s
     end

data/lib/xen/network.rb

@@ -1,21 +1,13 @@
 module Xen
-  class Network
+  class Network < Base
 
-    def initialize(uid, host)
-      @uid = uid
-      @host = host
-    end
-    
-    def record
-      @host.call("network.get_record", @uid)['Value']
-    end
-    
-    def uuid
-      self.to_s
-    end
-    
-    def to_s
-      @uid.to_s
+    # Searches the networks for a certain name
+    def self.find_by_name(name, host)
+      host.get_value("network.get_all").collect do |networkuid|
+        return self.new(networkuid, host) if host.get_value("network.get_name_label", networkuid) == name
+      end
+      nil
     end
+
   end
 end

data/lib/xen/sr.rb

@@ -0,0 +1,12 @@
+module Xen
+  class SR < Base
+    
+    # Searches the host for the first storage resource with the type set to 'local'
+    def self.get_local(host)
+      host.get_value("SR.get_all").each do |sruid|
+        return self.new(sruid, host) if host.get_value("SR.get_type", sruid) == 'local'
+      end
+      nil
+    end
+  end
+end

data/lib/xen/vbd.rb

@@ -0,0 +1,39 @@
+module Xen
+  class VBD < Base
+
+    @initial_config = {
+#      :device=>"hda1", 
+      :bootable=>"0", 
+      :mode=>"RW", 
+      :type=>"disk", 
+      :driver=>"paravirtualised",
+#      :VM => "73a2c34f-d5f1-2c96-e6f6-ca98de793d2d", 
+#      :VDI => "20b1af7c-fe3a-bdf4-eeb8-c8635d0daadc"
+    }
+
+    # Creates a new VBD. Required paramters are the device ('hda1'), the vm object, the vdi object and the host
+    def self.create(dev, vm, vdi, host)
+      o = @initial_config.merge({:device => dev, 
+                                      :VM => vm.uuid,
+                                      :VDI => vdi.uuid})
+      uuid = host.get_value("VBD.create", o)
+      self.new(uuid, host)
+    end
+    
+    # Gets the connected VDI
+    def vdi
+      Xen::VDI.new(@host.get_value('VBD.get_VDI', self.uuid), @host)
+    end
+    
+    # Destroys the VBD
+    def destroy!
+      @host.call('VBD.destroy', self.uuid)
+    end
+    
+    # Gives a nice description
+    def humanize
+      r = self.record
+      "VBD #{self.uuid} is disk '#{r['device']}' in the VM, connected to VDI #{self.vdi}\n" + self.vdi.humanize('\--')
+    end
+  end
+end

data/lib/xen/vdi.rb

@@ -0,0 +1,51 @@
+module Xen
+  class VDI < Base
+
+    # The initial config for a new VDI device
+    @initial_config = {
+        :type => 'system', 
+        :sharable => false, 
+    }
+  
+    # Create method, takes a name, a device (p.ex. 'phy:/dev/storage/slice') and a host
+    def self.create(name, dev, host)
+      sr = host.get_local_sr
+      config = @initial_config.merge({:name_label => name, 
+                                          :other_config => {:location => dev}, 
+                                          :SR => sr.uuid })
+      uuid = host.get_value("VDI.create", config)
+      self.new(uuid, host)
+    end
+    
+    # Finds a device when given a devicename
+    def self.find_by_device(dev, host)
+      host.get_value('VDI.get_all').each do |vdi|
+        vdirecord = host.get_value('VDI.get_record', vdi) 
+        return self.new(vdi, host) if vdirecord['other_config']['location'] == dev
+      end
+      nil
+    end
+    
+    # Destroys the current VDI
+    def destroy!
+      @host.call 'VDI.destroy', self.uuid
+    end
+    
+    # Gets all the VDBs connected
+    def vbds
+      @host.get_value('VDI.get_VBDs', self.uuid).collect do |vbd|
+        Xen::VBD.new(vbd, @host)
+      end
+    end
+
+    # Gives some human string
+    def humanize(prepend)
+      r = self.record
+      if !r 
+        prepend + "Unknown vdi #{self.uuid}"
+      else
+        prepend + "VDI #{self.uuid} is device #{r['other_config']['location']}"
+      end
+    end
+  end
+end

data/lib/xen/vif.rb

@@ -0,0 +1,19 @@
+module Xen
+  class VIF < Base
+
+    @initial_config = {
+      :device => "eth0",
+      :MTU => "1500"
+    }
+
+    # Creates a new VIF in a vm. The mac address is spelled out, with colons in between
+    def self.create(vm, network, mac, host)
+      o = @initial_config.merge({:VM => vm.uuid,
+                                 :network => network.uuid,
+                                 :MAC => mac
+                                })
+      uuid = host.get_value("VIF.create", o)
+      self.new(uuid, host)
+    end
+  end
+end

data/lib/xen/vm.rb

@@ -1,13 +1,58 @@
 module Xen
 
-  class Vm
+  class VM < Base
 
-    attr_reader :uid
+    @initial_config = {
+      #    :name_label =>  '',
+      :name_description =>  'Openminds APIs zijn vetgeil',
+      :user_version =>  1,
+      :is_a_template =>  false,
+#      :memory_static_max =>  32,
+#      :memory_dynamic_max =>  32,
+#      :memory_dynamic_min =>  32,
+#      :memory_static_min =>  32,
+      :VCPUs_policy =>  '',
+      :VCPUs_params =>  '',
+      :VCPUS_features_required =>  '',
+      :VCPUs_features_can_use =>  '',
+      :VCPUs_features_force_on =>  '',
+      :VCPUs_features_force_off =>  '',
+      :actions_after_shutdown =>  'restart',
+      :actions_after_reboot =>  'restart',
+      :actions_after_suspend =>  'destroy',
+      :actions_after_crash =>  'restart',
+      :bios_boot =>  '',
+      :platform_std_VGA =>  false,
+      :platform_serial =>  '',
+      :platform_localtime =>  false,
+      :platform_clock_offset =>  false,
+      :platform_enable_audio =>  false,
+      :builder =>  'linux',
+      :boot_method =>  '',
+      :PV_kernel =>  '/boot/xenu-linux-2.6.18-domu',
+      :PV_initrd =>  '',
+      :PV_args =>  'root=/dev/hda1 ro 4',
+      :grub_cmdline =>  '',
+      :PCI_bus =>  '',
+      :other_config =>  '' ,
+    }
+
+    # Creates a new VM with a certain name set and a amount of memory (in bytes) on a host
+    def self.create(name, memory, host)
+      o = @initial_config.merge({
+        :name_label => name,
+        :memory_static_max =>  memory,
+        :memory_dynamic_max => memory,
+        :memory_dynamic_min =>  memory,
+        :memory_static_min =>  memory
+      })
+      uid = host.get_value("VM.create", o)
+      self.new(uid, host)
 
     # Creates a new VM, Given the VM's UID and the host it is running on.
     def initialize(uid, host)
       @uid, @host = uid, host
-      # self.get_state       # Too expensive!
+      preload_record!
     end
 
     # Gets the state of the VM. The first time it is called it query's the server, other times it is cached. There is an optional parameter 'refresh' which, when true, will re-query the server.
@@ -24,19 +69,14 @@ module Xen
 
     # Returns the VM's name
     def name
-      @host.get_value("VM.get_name_label",@uid)
+      @name ||= @host.get_value("VM.get_name_label",@uid)
     end
 
     # Returns true if the current vm happens to be dom0.
     def is_dom0?
-      name.to_s == "Domain-0" 
+      @control_domain
     end
     
-    # Returns the VM's uuid
-    def uuid
-      @host.get_value("VM.get_uuid",@uid)
-    end
-
     # Starts a VM, and returns the current state
     def start!(paused = false)
       @host.call("VM.start",@uid, paused)    
@@ -75,17 +115,32 @@ module Xen
 
     # Hard reboots the VM, and returns the current state
     def hard_reboot!
-      @host.call("VM.hard_reboot",@uid)    
+      # Update 30/08/2007
+      # This function just returns an ENOTIMPLEMENTED in the Xen API, so we'll have to implement it ourselves
+      # @host.call("VM.hard_reboot",@uid)    
+      
+      # Should do:
+        # hard_shutdown!
+        # start!
       state(true)
     end
-
-    # Record..
-    def record
-        @host.get_value("VM.get_record", @uid)
+    
+    def vdbs
+      @host.get_value('VM.get_VBDs', self.uuid).collect do |vbd|
+        Xen::VBD.new(vbd, @host)
+      end
     end
-
-    def to_s
-      @uid.to_s
+    
+    private
+    def preload_record
+      data = record
+      @dom_id = data["domid"]
+      @kernel = data["PV_kernel"]
+      @kernel_args = data["PV_args"]
+      @name = data["name_label"]
+      # vifs
+      @control_domain = data["is_control_domain"]
     end
+    
   end
 end

metadata

@@ -3,13 +3,13 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: xen
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-08-29 00:00:00 +02:00
+  version: 0.1.2
+date: 2007-08-31 00:00:00 +02:00
 summary: A package that is a link between Ruby and Xen API.
 require_paths: 
 - lib
 email: xen-ruby@openminds.be
-homepage: 
+homepage: ruby-xen.rubyforge.com
 rubyforge_project: 
 description: 
 autorequire: xen
@@ -31,9 +31,15 @@ authors:
   - Jan De Poorter
 files: 
 - lib/xen
+- lib/xen/base.rb
 - lib/xen/connection.rb
+- lib/xen/console.rb
 - lib/xen/host.rb
 - lib/xen/network.rb
+- lib/xen/sr.rb
+- lib/xen/vbd.rb
+- lib/xen/vdi.rb
+- lib/xen/vif.rb
 - lib/xen/vm.rb
 - lib/xen.rb
 - README