libvirt 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.2.0 (December 7, 2010)
+
+  - Domain XML is now parsed into a `Libvirt::Spec::Domain` object,
+    which can then be turned back into XML.
+
 ## 0.1.0 (November 16, 2010)
 
   - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    libvirt (0.1.0)
+    libvirt (0.2.0)
       ffi (~> 0.6.3)
       nokogiri (~> 1.4.3)
 
@@ -12,15 +12,15 @@ GEM
     ffi (0.6.3)
       rake (>= 0.8.7)
     ffi (0.6.3-java)
-    mocha (0.9.8)
+    mocha (0.9.10)
       rake
-    nokogiri (1.4.3.1)
-    nokogiri (1.4.3.1-java)
+    nokogiri (1.4.4)
+    nokogiri (1.4.4-java)
       weakling (>= 0.0.3)
-    protest (0.4.1)
+    protest (0.4.2)
     rake (0.8.7)
     weakling (0.0.4-java)
-    yard (0.6.1)
+    yard (0.6.3)
 
 PLATFORMS
   java

data/Rakefile

@@ -12,6 +12,27 @@ task :test do
   files.each { |f| load f }
 end
 
+# Testing against specific rubies or all of them. This uses RVM
+# and expects these rubies to be installed already.
+rubies = ["1.9.2", "1.8.7", "jruby", "rbx"]
+rubies.each do |ruby|
+  desc "Run the test suite against: #{ruby}"
+  task "test_#{ruby.gsub('.', '_')}" do
+    puts "Running test suite against: #{ruby}"
+    exec("rvm #{ruby} rake")
+  end
+end
+
+desc "Run the test suite against all rubies: #{rubies.join(", ")}"
+task :test_all do
+  rubies.each do |ruby|
+    puts "Running test suite against: #{ruby}"
+    pid = fork
+    exec "rvm #{ruby} rake" if !pid
+    Process.wait(pid) if pid
+  end
+end
+
 begin
   # Documentation task
   require 'yard'

data/lib/libvirt/connection.rb

@@ -40,7 +40,7 @@ module Libvirt
   # # Basic Information of a Connection
   #
   # Once you have a connection object, you can gather basic information about it
-  # by using methods such as {#name}, {#capabilities}, etc.:
+  # by using methods such as {#hypervisor}, {#capabilities}, etc.:
   #
   #     puts "Hypervisor type: #{conn.hypervisor}"
   #     puts "Hypervisor version: #{conn.hypervisor_verison}"

data/lib/libvirt/domain.rb

@@ -111,6 +111,14 @@ module Libvirt
       FFI::Libvirt.virDomainGetXMLDesc(self, 0)
     end
 
+    # Returns the {Libvirt::Spec::Domain} object representing this
+    # domain.
+    #
+    # @return [Libvirt::Spec::Domain]
+    def spec
+      Spec::Domain.new(xml)
+    end
+
     # Returns boolean of whether the domain is active (running) or not.
     #
     # @return [Boolean]

data/lib/libvirt/exception.rb

@@ -15,5 +15,14 @@ module Libvirt
         super(error.message)
       end
     end
+
+    # Represents an exception in parsing an XML spec into a Ruby
+    # {Libvirt::Spec} object.
+    class UnparseableSpec < StandardError
+      def initialize(tags)
+        tags = tags.map { |tag| tag.name }
+        super("Unsupported tags found. This is either a bug or the XML string given is invalid. Tags: #{tags}")
+      end
+    end
   end
 end

data/lib/libvirt/spec.rb

@@ -8,5 +8,6 @@ module Libvirt
   module Spec
     autoload :Device, 'libvirt/spec/device'
     autoload :Domain, 'libvirt/spec/domain'
+    autoload :Util, 'libvirt/spec/util'
   end
 end

data/lib/libvirt/spec/device.rb

@@ -3,6 +3,33 @@ module Libvirt
     module Device
       autoload :Disk, 'libvirt/spec/device/disk'
       autoload :Emulator, 'libvirt/spec/device/emulator'
+      autoload :Graphics, 'libvirt/spec/device/graphics'
+      autoload :Input, 'libvirt/spec/device/input'
+      autoload :Interface, 'libvirt/spec/device/interface'
+      autoload :Sound, 'libvirt/spec/device/sound'
+      autoload :Video, 'libvirt/spec/device/video'
+      autoload :VideoModel, 'libvirt/spec/device/video_model'
+
+      # Loads a device from an XML string. This will automatically find
+      # the proper class to load and return that.
+      #
+      # @return [Device]
+      def self.load!(xml)
+        xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+        get(xml.name).new(xml)
+      end
+
+      # Returns the class of a device based on the name. If
+      # `:disk` were given, for example, then a {Disk} class
+      # would be returned. Note that since the class is returned,
+      # and not an instance, it is up to the caller to instantiate
+      # the returned class.
+      #
+      # @param [Symbol] name
+      # @return [Class]
+      def self.get(name)
+        const_get(name.to_s.capitalize)
+      end
     end
   end
 end

data/lib/libvirt/spec/device/disk.rb

@@ -5,7 +5,10 @@ module Libvirt
       # cdrom, or paravirtualized driver is specified via the disk
       # element.
       class Disk
+        include Util
+
         attr_accessor :type
+        attr_accessor :device
         attr_accessor :source
         attr_accessor :target_dev
         attr_accessor :target_bus
@@ -15,16 +18,33 @@ module Libvirt
         attr_accessor :shareable
         attr_accessor :serial
 
-        # Initialize a new disk element with the given type. Examples
-        # of valid `type`s are "disk," "floppy," and "cdrom."
-        def initialize(type)
-          @type = type
+        # Initializes a new disk element. If an XML string is passed
+        # then that will be used to initialize the attributes of the
+        # device.
+        def initialize(xml=nil)
           @shareable = false
+
+          load!(xml) if xml
+        end
+
+        # Loads data from XML.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+          try(xml.xpath("//disk[@type]"), :preserve => true) { |result| self.type = result["type"].to_sym }
+          try(xml.xpath("//disk[@device]"), :preserve => true) { |result| self.device = result["device"].to_sym }
+          try(xml.xpath("//disk/source")) { |result| self.source = result["dev"] || result["file"] }
+
+          try(xml.xpath("//disk/target")) do |result|
+            self.target_dev = result["dev"]
+            self.target_bus = result["bus"]
+          end
+
+          raise_if_unparseables(xml.xpath("//disk/*"))
         end
 
         # Returns the XML representation of this device.
         def to_xml(xml=Nokogiri::XML::Builder.new)
-          xml.disk(:type => type) do |d|
+          xml.disk(:type => type, :device => device) do |d|
             if source
               # Source tag, the attribute depends on the type.
               attribute = type == :block ? :dev : :file

data/lib/libvirt/spec/device/graphics.rb

@@ -0,0 +1,39 @@
+module Libvirt
+  module Spec
+    module Device
+      # Represents a graphics device, which allows for graphical
+      # interaction with the guest OS.
+      class Graphics
+        include Util
+
+        attr_accessor :type
+        attr_accessor :display
+
+        # Initializes a new graphics device. If an XML string is given,
+        # it will be used to attempt to initialize the attributes.
+        def initialize(xml=nil)
+          load!(xml) if xml
+        end
+
+        # Attempts to initialize object attributes based on the XML
+        # string given.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+          try(xml.xpath("//graphics[@type]"), :preserve => true) { |result| self.type = result["type"].to_sym }
+          try(xml.xpath("//graphics[@display]"), :preserve => true) { |result| self.display = result["display"] }
+
+          raise_if_unparseables(xml.xpath("//graphics/*"))
+        end
+
+        # Returns the XML representation of this device.
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          options = { :type => type }
+          options[:display] = display if display
+
+          xml.graphics(options)
+          xml.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/spec/device/input.rb

@@ -0,0 +1,40 @@
+module Libvirt
+  module Spec
+    module Device
+      # Represents an input device, which is a device that allows
+      # interaction with the graphical framebuffer in the guest
+      # virtual machine.
+      class Input
+        include Util
+
+        attr_accessor :type
+        attr_accessor :bus
+
+        # Initializes a new input device. If an XML string is given,
+        # it will be used to attempt to initialize the attributes.
+        def initialize(xml=nil)
+          load!(xml) if xml
+        end
+
+        # Attempts to initialize object attributes based on the XML
+        # string given.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+          try(xml.xpath("//input[@type]"), :preserve => true) { |result| self.type = result["type"].to_sym }
+          try(xml.xpath("//input[@bus]"), :preserve => true) { |result| self.bus = result["bus"].to_sym }
+
+          raise_if_unparseables(xml.xpath("//input/*"))
+        end
+
+        # Returns the XML representation of this device
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          options = { :type => type }
+          options[:bus] = bus if bus
+
+          xml.input(options)
+          xml.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/spec/device/interface.rb

@@ -0,0 +1,47 @@
+module Libvirt
+  module Spec
+    module Device
+      # Represents a network interface device which is attached to
+      # a domain.
+      class Interface
+        include Util
+
+        attr_accessor :type
+        attr_accessor :mac_address
+        attr_accessor :model_type
+        attr_accessor :source_network
+
+        # Initializes a new network interface device. If an XML string
+        # is given, it will be used to attempt to initialize the attributes.
+        def initialize(xml=nil)
+          load!(xml) if xml
+        end
+
+        # Attempts to initialize object attributes based on XML attributes.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+          try(xml.xpath("//interface")) do |interface|
+            self.type = interface["type"].to_sym if interface["type"]
+            try(interface.xpath("mac")) { |result| self.mac_address = result["address"] }
+            try(interface.xpath("model")) { |result| self.model_type = result["type"] }
+            try(interface.xpath("source")) do |result|
+              self.source_network = result["network"]
+            end
+
+            raise_if_unparseables(interface.xpath("*"))
+          end
+        end
+
+        # Returns the XML representation of this device
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          xml.interface(:type => type) do |i|
+            i.mac(:address => mac_address) if mac_address
+            i.model(:type => model_type) if model_type
+          end
+
+          xml.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/spec/device/sound.rb

@@ -0,0 +1,32 @@
+module Libvirt
+  module Spec
+    module Device
+      # Represents a sound device.
+      class Sound
+        include Util
+
+        attr_accessor :model
+
+        # Initializes a new sound device. If an XML string is given,
+        # it will be used to attempt to initialize the attributes.
+        def initialize(xml=nil)
+          load!(xml) if xml
+        end
+
+        # Attempts to initialize object attributes based on the XML
+        # string given.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+          try(xml.xpath("//sound[@model]"), :preserve => true) { |result| self.model = result["model"].to_sym }
+          raise_if_unparseables(xml.xpath("//sound/*"))
+        end
+
+        # Returns the XML representation of this device.
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          xml.sound(:model => model)
+          xml.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/spec/device/video.rb

@@ -0,0 +1,47 @@
+module Libvirt
+  module Spec
+    module Device
+      # Represents a video device.
+      class Video
+        include Util
+
+        attr_accessor :models
+
+        # Initializes a new video device. If an XML string is given,
+        # it will be used to attempt to initialize the attributes.
+        def initialize(xml=nil)
+          @models = []
+
+          load!(xml) if xml
+        end
+
+        # Attempts to initialize object attributes based on the XML
+        # string given.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+
+          try(xml.xpath("//video/model"), :multi => true) do |result|
+            self.models = []
+
+            result.each do |model|
+              self.models << VideoModel.new(model)
+            end
+          end
+
+          raise_if_unparseables(xml.xpath("//video/*"))
+        end
+
+        # Returns the XML representation of this device.
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          xml.video do |v|
+            models.each do |model|
+              model.to_xml(xml)
+            end
+          end
+
+          xml.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/spec/device/video_model.rb

@@ -0,0 +1,53 @@
+module Libvirt
+  module Spec
+    module Device
+      # Represents a model in the specific video device.
+      class VideoModel
+        include Util
+
+        attr_accessor :type
+        attr_accessor :vram
+        attr_accessor :heads
+        attr_accessor :accel3d
+        attr_accessor :accel2d
+
+        # Initializes a new video model device. If an XML string is
+        # given, it will be used to attempt to initialize the attributes.
+        def initialize(xml=nil)
+          load!(xml) if xml
+        end
+
+        # Attempts to initialize object attributes based on the XML
+        # strings given.
+        def load!(xml)
+          xml = Nokogiri::XML(xml).root if !xml.is_a?(Nokogiri::XML::Element)
+          try(xml.xpath("//model[@type]"), :preserve => true) { |result| self.type = result["type"].to_sym }
+          try(xml.xpath("//model[@vram]"), :preserve => true) { |result| self.vram = result["vram"] }
+          try(xml.xpath("//model[@heads]"), :preserve => true) { |result| self.heads = result["heads"] }
+          try(xml.xpath("//model/acceleration")) do |result|
+            self.accel3d = result["accel3d"] == "yes"
+            self.accel2d = result["accel2d"] == "yes"
+          end
+
+          raise_if_unparseables(xml.xpath("//model/*"))
+        end
+
+        # Returns the XML representation of this device.
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          options = { :type => type }
+          options[:vram] = vram if vram
+          options[:heads] = heads if heads
+
+          xml.model(options) do |m|
+            a3d = accel3d ? "yes" : "no"
+            a2d = accel2d ? "yes" : "no"
+
+            m.acceleration(:accel3d => a3d, :accel2d => a2d)
+          end
+
+          xml.to_xml
+        end
+      end
+    end
+  end
+end