ovirt 0.1.0

data/lib/ovirt/inventory.rb

@@ -0,0 +1,177 @@
+module Ovirt
+  class Inventory
+    attr_accessor :service
+
+    def initialize(options={})
+      @service = Service.new(options)
+    end
+
+    def api
+      standard_collection('api').first
+    end
+
+    def capabilities
+      standard_collection("capabilities")
+    end
+
+    def clusters
+      standard_collection("clusters")
+    end
+
+    def datacenters
+      standard_collection("datacenters", "data_center")
+    end
+
+    def domains
+      standard_collection("domains")
+    end
+
+    def events(since = nil)
+      if since.nil?
+        standard_collection("events")
+      else
+        standard_collection("events?from=#{since}", "event")
+      end
+    end
+
+    def groups
+      standard_collection("groups")
+    end
+
+    def hosts
+      standard_collection("hosts", nil, true)
+    end
+
+    def networks
+      standard_collection("networks")
+    end
+
+    def roles
+      standard_collection("roles")
+    end
+
+    def storagedomains
+      standard_collection("storagedomains", "storage_domain", true)
+    end
+
+    def tags
+      standard_collection("tags")
+    end
+
+    def templates
+      standard_collection("templates")
+    end
+
+    def users
+      standard_collection("users")
+    end
+
+    def vms
+      standard_collection("vms", nil, true)
+    end
+
+    def vmpools
+      standard_collection("vmpools")
+    end
+
+    def get_vm(path)
+      vm_guid = File.basename(path, '.*')
+      vm = get_resource_by_ems_ref("/api/vms/#{vm_guid}") rescue nil
+      vm = get_resource_by_ems_ref("/api/templates/#{vm_guid}") if vm.blank?
+      return vm
+    end
+
+    def get_resource_by_ems_ref(uri_suffix, element_name = nil)
+      @service.get_resource_by_ems_ref(uri_suffix, element_name)
+    end
+
+    def refresh
+      # TODO: Change to not return native objects to the caller.  The caller
+      #       should just expect raw data.
+      primary_items = collect_primary_items
+      collect_secondary_items(primary_items)
+    end
+
+    private
+
+    def standard_collection(uri_suffix, element_name = nil, paginate=false, sort_by=:name)
+      @service.standard_collection(uri_suffix, element_name, paginate, sort_by)
+    end
+
+    # TODO: Remove this key/method translation and just use the method name as
+    #       the key directly.
+    PRIMARY_ITEMS = {
+      # Key          RHEVM API method
+      :cluster    => :clusters,
+      :vmpool     => :vmpools,
+      :network    => :networks,
+      :storage    => :storagedomains,
+      :datacenter => :datacenters,
+      :host       => :hosts,
+      :vm         => :vms,
+      :template   => :templates
+    }
+
+    SECONDARY_ITEMS = {
+      # Key          RHEVM API methods
+      :datacenter => [:storagedomains],
+      :host       => [:statistics, :host_nics], # :cdroms, tags
+      :vm         => [:disks, :snapshots, :nics],
+      :template   => [:disks]
+    }
+
+    def primary_item_jobs
+      PRIMARY_ITEMS.to_a
+    end
+
+    # Returns all combinations of primary resources and the methods to run on those resources.
+    #
+    # > secondary_item_jobs({:vm, => [v1, v2]})
+    #  => [[v1, :disks], [v1, :snapshots], [v1, :nics], [v2, :disks], [v2, :snapshots], [v2, :nics]]
+    def secondary_item_jobs(primary_items)
+      SECONDARY_ITEMS.collect do |key, methods|
+        primary_items[key].product(methods)
+      end.flatten(1)
+    end
+
+    def collect_primary_items
+      jobs = primary_item_jobs
+
+      results = collect_in_parallel(jobs) do |_, method|
+        self.send(method)
+      end
+
+      jobs.zip(results).each_with_object({}) do |((key, _), result), hash|
+        hash[key] = result
+      end
+    end
+
+    def collect_secondary_items(primary_items)
+      jobs = secondary_item_jobs(primary_items)
+
+      results = collect_in_parallel(jobs) do |resource, method|
+        resource.send(method) rescue nil
+      end
+
+      jobs.zip(results).each do |(resource, method), result|
+        resource.attributes[method] = result
+      end
+
+      primary_items
+    end
+
+    def collect_in_parallel(jobs, &block)
+      require 'parallel'
+      Parallel.map(jobs, :in_threads => num_threads, &block)
+    end
+
+    def num_threads
+      use_threads? ? 8 : 0
+    end
+
+    # HACK: VCR is not threadsafe, and so tests running under VCR fail
+    def use_threads?
+      !defined?(VCR)
+    end
+  end
+end

data/lib/ovirt/network.rb

@@ -0,0 +1,16 @@
+module Ovirt
+  class Network < Object
+
+    self.top_level_strings  = [:name, :description]
+    self.top_level_booleans = [:stp, :display]
+    self.top_level_objects  = [:data_center, :cluster, :vlan]
+
+    def self.parse_xml(xml)
+      node, hash    = xml_to_hash(xml)
+
+      parse_first_node(node, :status, hash, :node => [:state])
+
+      hash
+    end
+  end
+end

data/lib/ovirt/nic.rb

@@ -0,0 +1,31 @@
+module Ovirt
+  class Nic < Object
+
+    self.top_level_strings  = [:name, :interface]
+    self.top_level_objects  = [:vm, :network]
+
+    def self.parse_xml(xml)
+      node, hash     = xml_to_hash(xml)
+
+      parse_first_node(node, :network, hash, :node      => [:name])
+      parse_first_node(node, :mac,     hash, :attribute => [:address])
+
+      hash
+    end
+
+    def attributes_for_new_nic
+      attrs = attributes.dup
+      attrs[:network_id] = self[:network][:id]
+      attrs
+    end
+
+    def apply_options!(options)
+      update! do |xml|
+        xml.name options[:name]                     if options[:name]
+        xml.interface options[:interface]           if options[:interface]
+        xml.network(:id => options[:network_id])    if options[:network_id]
+        xml.mac(:address => options[:mac_address])  if options[:mac_address]
+      end
+    end
+  end
+end

data/lib/ovirt/object.rb

@@ -0,0 +1,315 @@
+module Ovirt
+  class Object
+    def self.create_from_xml(service, xml)
+      self.new(service, parse_xml(xml))
+    end
+
+    def self.xml_to_relationships(xml)
+      node = xml_to_nokogiri(xml)
+      relationships = {}
+      node.xpath('link').each do |link|
+        relationships[link['rel'].to_sym] = link['href']
+      end
+
+      relationships
+    end
+
+    def self.xml_to_actions(xml)
+      node = xml_to_nokogiri(xml)
+      actions = {}
+      node.xpath('actions/link').each do |link|
+        actions[link['rel'].to_sym] = link['href']
+      end
+
+      actions
+    end
+
+    def self.hash_from_id_and_href(node)
+      hash = {}
+      [:id, :href].each { |key| hash[key] = node[key.to_s] unless node.nil? || node[key.to_s].nil? }
+      hash
+    end
+
+    def self.parse_boolean(what)
+      return true  if what == 'true'
+      return false if what == 'false'
+      raise "Cannot parse boolean for value: <#{what.inspect}>"
+    end
+
+    def self.parse_first_text(node, hash, key, modifier=nil)
+      text_node = node.xpath(key.to_s).first
+      value = text_node.text unless text_node.nil?
+      self.set_value(value, hash, key, modifier)
+    end
+
+    def self.parse_attribute(node, hash, key, modifier=nil)
+      value = node[key.to_s]
+      self.set_value(value, hash, key, modifier)
+    end
+
+    def self.set_value(value, hash, key, modifier)
+      return if value.nil?
+      hash[key] = case modifier
+      when :to_i    then value.to_i
+      when :to_f    then value.to_f
+      when :to_bool then self.parse_boolean(value)
+      else value
+      end
+    end
+
+    def self.parse_first_node(node, path, hash, options)
+      self.parse_first_node_with_hash(node, path, nh = {}, options)
+      unless nh.empty?
+        hash[path.to_sym] = hash[path.to_sym].nil? ? nh : hash[path.to_sym].merge(nh)
+      end
+      nh
+    end
+
+    def self.parse_first_node_with_hash(node, path, hash, options)
+      xnode = node.xpath(path.to_s).first
+      unless xnode.blank?
+        options[:attribute].to_a.each      {|key| self.parse_attribute( xnode, hash, key)}
+        options[:attribute_to_i].to_a.each {|key| self.parse_attribute( xnode, hash, key, :to_i)}
+        options[:attribute_to_f].to_a.each {|key| self.parse_attribute( xnode, hash, key, :to_f)}
+        options[:node].to_a.each           {|key| self.parse_first_text(xnode, hash, key)}
+        options[:node_to_i].to_a.each      {|key| self.parse_first_text(xnode, hash, key, :to_i)}
+        options[:node_to_bool].to_a.each   {|key| self.parse_first_text(xnode, hash, key, :to_bool)}
+      end
+    end
+
+    def self.top_level_objects=(keys)
+      @top_level_objects = keys
+    end
+
+    def self.top_level_objects
+      @top_level_objects ||= []
+    end
+
+    def self.top_level_strings=(keys)
+      @top_level_strings = keys
+    end
+
+    def self.top_level_strings
+      @top_level_strings ||= []
+    end
+
+    def self.top_level_integers=(keys)
+      @top_level_integers = keys
+    end
+
+    def self.top_level_integers
+      @top_level_integers ||= []
+    end
+
+    def self.top_level_booleans=(keys)
+      @top_level_booleans = keys
+    end
+
+    def self.top_level_booleans
+      @top_level_booleans ||= []
+    end
+
+    def self.top_level_timestamps=(keys)
+      @top_level_timestamps = keys
+    end
+
+    def self.top_level_timestamps
+      @top_level_timestamps ||= []
+    end
+
+
+    def self.xml_to_hash(xml)
+      node                          = xml_to_nokogiri(xml)
+      hash                          = hash_from_id_and_href(node)
+      hash[:relationships]          = xml_to_relationships(node)
+      hash[:actions]                = xml_to_actions(node)
+
+      top_level_objects.each do |key|
+        object_node = node.xpath(key.to_s).first
+        hash[key]   = hash_from_id_and_href(object_node) unless object_node.nil?
+      end
+
+      top_level_strings.each do |key|
+        object_node = node.xpath(key.to_s).first
+        hash[key]   = object_node.text unless object_node.nil?
+      end
+
+      top_level_integers.each do |key|
+        object_node = node.xpath(key.to_s).first
+        hash[key]   = object_node.text.to_i  unless object_node.nil?
+      end
+
+      top_level_booleans.each do |key|
+        object_node = node.xpath(key.to_s).first
+        hash[key]   = parse_boolean(object_node.text)  unless object_node.nil?
+      end
+
+      top_level_timestamps.each do |key|
+        object_node = node.xpath(key.to_s).first
+        hash[key]   = Time.parse(object_node.text)  unless object_node.nil?
+      end
+
+      return node, hash
+    end
+
+    def self.xml_to_nokogiri(xml)
+      if xml.kind_of?(Nokogiri::XML::Element)
+        nokogiri = xml
+      else
+        nokogiri = Nokogiri::XML(xml).root
+      end
+      nokogiri
+    end
+
+    def self.href_from_creation_status_link(link)
+      # "/api/vms/5024ab49-19b5-4176-9568-c004d1c9f256/creation_status/d0e45003-d490-4551-9911-05b3bec682dc"
+      # => "/api/vms/5024ab49-19b5-4176-9568-c004d1c9f256"
+      link.split("/")[0,4].join("/")
+    end
+
+    def self.href_to_guid(href)
+      href.split("/").last
+    end
+
+    def self.object_to_id(object)
+      case object
+      when Ovirt::Object
+        object = object[:id]
+      when String
+        raise ArgumentError, "object must be a valid guid" unless object.guid?
+        object = href_to_guid(object)
+      else
+        raise ArgumentError, "object must be a valid guid or an Ovirt Object"
+      end
+      object
+    end
+
+    def self.api_endpoint
+      namespace.last.pluralize.downcase
+    end
+
+    def self.element_names
+      element_name.pluralize
+    end
+
+    def self.element_name
+      api_endpoint.singularize
+    end
+
+    def self.all_xml_objects(service)
+      response = service.resource_get(api_endpoint)
+      doc      = Nokogiri::XML(response)
+      objects  = doc.xpath("//#{element_names}/#{element_name}")
+    end
+
+    def self.all(service)
+      all_xml_objects(service).collect { |xml| self.create_from_xml(service, xml) }
+    end
+
+    def self.find_by_name(service, name)
+      all_xml_objects(service).each do |xml|
+        obj = self.create_from_xml(service, xml)
+        return obj if obj[:name] == name
+      end
+      nil
+    end
+
+    def self.find_by_id(service, id)
+      find_by_href(service, "#{api_endpoint}/#{id}")
+    end
+
+    def self.find_by_href(service, href)
+      response = service.resource_get(href)
+      doc = Nokogiri::XML(response)
+      xml = doc.xpath("//#{element_name}").first
+      self.create_from_xml(service, xml)
+    rescue RestClient::ResourceNotFound
+      return nil
+    end
+
+    attr_accessor :attributes, :operations, :relationships, :service
+
+    def initialize(service, options = {})
+      @service       = service
+      @relationships = options.delete(:relationships) || {}
+      @operations    = options.delete(:actions)       || {}
+      @attributes    = options
+    end
+
+    def replace(obj)
+      @relationships = obj.relationships
+      @operations    = obj.operations
+      @attributes    = obj.attributes
+    end
+
+    def reload
+      self.replace(self.class.find_by_href(@service, self[:href]))
+    end
+
+    def method_missing(m, *args)
+      if @relationships.has_key?(m)
+        rel_str        = m.to_s
+        rel_str        = 'storage_domains' if rel_str == 'storagedomains'
+        rel_str        = 'data_centers'    if rel_str == 'datacenters'
+        singular       = rel_str.singularize
+        klass          = singular.camelize.constantize
+        xml            = @service.resource_get(@relationships[m])
+        doc            = Nokogiri::XML(xml)
+        return doc.root.xpath(singular).collect { |node| klass.create_from_xml(@service, node) }
+      end
+
+      return operation(m, args) if @operations.has_key?(m)
+
+      super
+    end
+
+    def operation(method, *args)
+      if @operations.has_key?(method.to_sym)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.action { yield xml if block_given? }
+        end
+        data = builder.doc.root.to_xml
+
+        @service.resource_post(@operations[method.to_sym], data)
+      else
+        raise "Method:<#{method}> is not available for object <#{self.class.name}>"
+      end
+    end
+
+    def destroy
+      @service.resource_delete(@attributes[:href])
+    end
+
+    def class_suffix
+      self.class.name[5..-1]
+    end
+
+    def api_endpoint
+      self[:href] || "#{self.class.api_endpoint}/#{self[:id]}"
+    end
+
+    def update!(&block)
+      response = update(&block)
+
+      obj = self.class.create_from_xml(@service, response)
+      self.replace(obj)
+    end
+
+    def update
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.send(namespace.last.downcase) { yield xml if block_given? }
+      end
+      data = builder.doc.root.to_xml
+
+      @service.resource_put(api_endpoint, data)
+    end
+
+    def keys
+      @attributes.keys
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+  end
+end

data/lib/ovirt/permission.rb

@@ -0,0 +1,20 @@
+module Ovirt
+  class Permission < Object
+
+    self.top_level_objects  = [:role, :user]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      [:template].each do |type|
+        subject_node = node.xpath(type.to_s).first
+        next if subject_node.nil?
+        subject        = hash_from_id_and_href(subject_node)
+        subject[:type] = type
+        hash[:subject] = subject
+      end
+
+      hash
+    end
+  end
+end

data/lib/ovirt/permit.rb

@@ -0,0 +1,14 @@
+module Ovirt
+  class Permit < Object
+
+    self.top_level_strings  = [:name]
+    self.top_level_booleans = [:administrative]
+    self.top_level_objects  = [:role]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      hash
+    end
+  end
+end

data/lib/ovirt/role.rb

@@ -0,0 +1,13 @@
+module Ovirt
+  class Role < Object
+
+    self.top_level_strings  = [:name, :description]
+    self.top_level_booleans = [:administrative, :mutable]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      hash
+    end
+  end
+end