ovirt 0.1.0

data/lib/ovirt/service.rb

@@ -0,0 +1,332 @@
+require 'nokogiri'
+
+module Ovirt
+  class Service
+    DEFAULT_OPTIONS  = {}
+    REQUIRED_OPTIONS = [:server, :username, :password]
+    DEFAULT_PORT_3_0 = 8443
+    DEFAULT_PORT_3_1 =  443
+    DEFAULT_PORT     = DEFAULT_PORT_3_1
+    DEFAULT_SCHEME   = 'https'.freeze
+    SESSION_ID_KEY   = 'JSESSIONID'.freeze
+
+    attr_accessor :session_id
+
+    def self.name_to_class(name)
+      Ovirt.const_get(name.camelize)
+    end
+
+    def xml_to_object(klass, xml)
+      klass.create_from_xml(self, xml)
+    end
+
+    def initialize(options={})
+      @options = DEFAULT_OPTIONS.merge(options)
+      parse_domain_name
+      REQUIRED_OPTIONS.each { |key| raise "No #{key.to_s} specified" unless @options.has_key?(key) }
+      @password = @options.delete(:password)
+      @session_id = @options[:session_id]
+    end
+
+    def inspect # just like the default inspect, but WITHOUT @password
+      "#<#{self.class.name}:0x#{(self.object_id << 1).to_s(16).rjust(14,'0')} @options=#{@options.inspect}>"
+    end
+
+    def api(reload = false)
+      @api   = nil if reload
+      @api ||= xml_to_object(Api, resource_get)
+    end
+
+    def product_info
+      @product_info ||= api[:product_info]
+    end
+
+    def name
+      @name ||= product_info[:name]
+    end
+
+    def vendor
+      @vendor ||= product_info[:vendor]
+    end
+
+    def version
+      @version ||= product_info[:version]
+    end
+
+    def version_string
+      @version_string ||= "#{version[:major]}.#{version[:minor]}.#{version[:revision]}.#{version[:build]}"
+    end
+
+    def version_3_0?
+      version_string.starts_with?("3.0")
+    end
+
+    def summary
+      api(true)[:summary] # This is volatile information
+    end
+
+    def special_objects
+      @special_objects ||= api[:special_objects]
+    end
+
+    def blank_template
+      @blank_template ||= begin
+        href = special_objects[:"templates/blank"]
+        href.blank? ? nil : Template.find_by_href(self, href)
+      end
+    end
+
+    def root_tag
+      @root_tag ||= begin
+        href = special_objects[:"tags/root"]
+        href.blank? ? nil : Tag.find_by_href(self, href)
+      end
+    end
+
+    def iso_storage_domain
+      @iso_storage_domain ||= StorageDomain.iso_storage_domain(self)
+    end
+
+    def iso_images
+      iso_storage_domain.nil? ? [] : iso_storage_domain.iso_images
+    end
+
+    def disconnect
+    end
+
+    def get_resource_by_ems_ref(uri_suffix, element_name = nil)
+      xml     = resource_get(uri_suffix)
+      doc     = Nokogiri::XML(xml)
+      element_name ||= doc.root.name
+      klass   = self.class.name_to_class(element_name)
+      xml_to_object(klass, doc.root)
+    end
+
+    def standard_collection(uri_suffix, element_name = nil, paginate=false, sort_by=:name)
+      if paginate
+        doc = paginate_resource_get(uri_suffix, sort_by)
+      else
+        xml = resource_get(uri_suffix)
+        doc = Nokogiri::XML(xml)
+      end
+      element_name ||= uri_suffix.singularize
+      klass   = self.class.name_to_class(element_name)
+
+      xml_path = uri_suffix == 'api' ? element_name : "#{element_name.pluralize}/#{element_name}"
+      objects = doc.xpath("//#{xml_path}")
+      objects.collect { |obj| xml_to_object(klass, obj) }
+    end
+
+    def status(link)
+      response = resource_get(link)
+
+      node = Object.xml_to_nokogiri(response)
+      node.xpath('status/state').text
+    end
+
+    def api_uri(path = nil)
+      uri = "#{base_uri}/api"
+      unless path.nil?
+        parts = path.to_s.split('/')
+        parts.shift if parts.first == ''    # Remove leading slash
+        parts.shift if parts.first == 'api' # We already have /api in our URI
+        uri += "/#{parts.join('/')}" unless parts.empty?
+      end
+      uri
+    end
+
+    def paginate_resource_get(path = nil, sort_by=:name, direction=:asc)
+      log_header = "#{self.class.name}#paginate_resource_get"
+      page = 1
+      full_xml = nil
+      loop do
+        uri = "#{path}?search=sortby%20#{sort_by}%20#{direction}%20page%20#{page}"
+        partial_xml_str = self.resource_get(uri)
+        if full_xml.nil?
+          full_xml = Nokogiri::XML(partial_xml_str)
+        else
+          partial_xml = Nokogiri::XML(partial_xml_str)
+          break if partial_xml.root.children.count == 0
+          $rhevm_log.debug "#{log_header}: Combining resource elements for <#{path}> from page:<#{page}>" if $rhevm_log && $rhevm_log.debug?
+          full_xml.root << partial_xml.root.children
+        end
+        page += 1
+      end
+      $rhevm_log.debug "#{log_header}: Combined elements for <#{path}>.  Total elements:<#{full_xml.root.children.count}>" if $rhevm_log && $rhevm_log.debug?
+      return full_xml
+    end
+
+    def resource_get(path = nil)
+      resource_verb(path, :get)
+    end
+
+    def resource_put(path, payload, additional_headers={:content_type => :xml, :accept => :xml})
+      resource_verb(path, :put, payload, additional_headers)
+    end
+
+    def resource_post(path, payload, additional_headers={:content_type => :xml, :accept => :xml})
+      resource_verb(path, :post, payload, additional_headers)
+    end
+
+    def resource_delete(path)
+      resource_verb(path, :delete)
+    end
+
+    def create_resource(path = nil)
+      require "rest-client"
+      RestClient::Resource.new(api_uri(path), resource_options)
+    end
+
+    private
+
+    def resource_verb(path, verb, *args)
+      log_header = "#{self.class.name}#resource_#{verb}"
+
+      resource = create_resource(path)
+      $rhevm_log.info "#{log_header}: Sending URL: <#{resource.url}>" if $rhevm_log
+      $rhevm_log.debug "#{log_header}: With args: <#{args.inspect}>" if $rhevm_log.try(:debug?)
+      resource.send(verb, *args) do |response, request, result, &block|
+        case response.code
+        when 200
+          parse_normal_response(response, resource)
+        when 400, 409
+          parse_error_response(response)
+        else
+          response.return!(request, result, &block)
+        end
+      end
+    rescue RestClient::Unauthorized
+      if self.session_id
+        self.session_id = nil
+        retry
+      else
+        raise
+      end
+    rescue RestClient::ResourceNotFound, Ovirt::Error
+      raise
+    rescue Exception => e
+      msg = "#{log_header}: class = #{e.class.name}, message=#{e.message}, URI=#{resource.url}"
+      if $rhevm_log.nil?
+        puts msg
+      else
+        $rhevm_log.error msg
+      end
+      raise
+    end
+
+    def parse_normal_response(response, resource)
+      parse_set_cookie_header(response.headers[:set_cookie])
+      if $rhevm_log
+        log_header = "#{self.class.name}#parse_normal_response"
+        $rhevm_log.info  "#{log_header}: Return from URL: <#{resource.url}> Data length:#{response.length}"
+        $rhevm_log.debug "#{log_header}: Return from URL: <#{resource.url}> Data:#{response}" if $rhevm_log.debug?
+      end
+      response
+    end
+
+    def parse_error_response(response)
+      doc    = Nokogiri::XML(response)
+      action = doc.xpath("action").first
+      node   = action || doc
+      reason = node.xpath("fault/detail").text
+      raise Ovirt::Error, reason
+    end
+
+    def parse_set_cookie_header(set_cookie_header)
+      set_cookie_header = set_cookie_header.first if set_cookie_header.kind_of?(Array)
+      set_cookie_header.to_s.split(";").each do |kv|
+        k, v = kv.strip.split("=")
+        self.session_id = v if k == SESSION_ID_KEY
+      end
+    end
+
+    def base_uri
+      if port.blank?
+        "#{scheme}://#{server}"
+      else
+        "#{scheme}://#{server}:#{port}"
+      end
+    end
+
+    def resource_options
+      headers = merge_headers({ 'Prefer' => 'persistent-auth' })
+      options = { :ssl_version => :SSLv3 }
+
+      if self.session_id
+        headers[:cookie]     = "#{SESSION_ID_KEY}=#{self.session_id}"
+      else
+        options[:user]       = fully_qualified_username
+        options[:password]   = password
+      end
+
+      options[:headers]      = headers
+      options[:timeout]      = timeout      if timeout
+      options[:open_timeout] = open_timeout if open_timeout
+      options
+    end
+
+    def merge_headers(hash)
+      h = @options[:headers] || {}
+      h.merge(hash)
+    end
+
+    def authorization_header
+      @authorization_header ||= { :authorization => "Basic #{authorization_value}" }
+    end
+
+    def authorization_value
+      @authorization_value ||= begin
+        require "base64"
+        Base64.encode64 "#{fully_qualified_username}:#{password}"
+      end
+    end
+
+    def scheme
+      @options[:scheme] || DEFAULT_SCHEME
+    end
+
+    def server
+      @options[:server]
+    end
+
+    def port
+      @options[:port] || DEFAULT_PORT
+    end
+
+    def fully_qualified_username
+      domain.blank? ? username : "#{username}@#{domain}"
+    end
+
+    def username
+      @options[:username]
+    end
+
+    def password
+      @password
+    end
+
+    def domain
+      @options[:domain]
+    end
+
+    def timeout
+      @options[:timeout]        # NetHTTPSession's read_timeout
+    end
+
+    def open_timeout
+      @options[:open_timeout]   # NetHTTPSessions's open_timeout
+    end
+
+    # Parse domain out of the username string
+    def parse_domain_name
+      if @options[:domain].blank? && !@options[:username].blank?
+        if @options[:username].include?('\\')
+          @options[:domain], @options[:username] = username.split('\\')
+        elsif @options[:username].include?('/')
+          @options[:domain], @options[:username] = username.split('/')
+        end
+      end
+    end
+
+  end
+end

data/lib/ovirt/snapshot.rb

@@ -0,0 +1,28 @@
+module Ovirt
+  class Snapshot < Object
+
+    self.top_level_strings    = [:description, :snapshot_status, :type]
+    self.top_level_timestamps = [:date]
+    self.top_level_objects    = [:vm]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      hash
+    end
+
+    def initialize(service, options = {})
+      super
+      @relationships[:disks] = self[:href] + "/disks"
+    end
+
+    def delete
+      response = destroy
+      while self[:snapshot_status] == "locked" || self[:snapshot_status] == "ok"
+        sleep 2
+        break if (obj = self.class.find_by_href(@service, self[:href])).nil?
+        self.replace(obj)
+      end
+    end
+  end
+end

data/lib/ovirt/statistic.rb

@@ -0,0 +1,37 @@
+module Ovirt
+  class Statistic < Object
+
+    self.top_level_strings    = [:name, :description, :type, :unit]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      values               = []
+      values_node          = node.xpath('values').first
+      values_type          = values_node['type']
+      values = values_node.xpath('value').collect do |v|
+        datum = v.xpath('datum').text
+        case values_type
+        when 'INTEGER'
+          datum = datum.to_i
+        when 'DECIMAL'
+          datum = datum.to_f
+        else
+          raise "unknown Values TYPE of <#{values_type}>"
+        end
+        datum
+      end
+      hash[:values]        = values
+
+      [:vm, :nic, :disk].each do |type|
+        parent_node = node.xpath(type.to_s).first
+        next if parent_node.nil?
+        parent = hash_from_id_and_href(parent_node)
+        parent[:type] = type
+        hash[:parent] = parent
+      end
+
+      hash
+    end
+  end
+end

data/lib/ovirt/storage.rb

@@ -0,0 +1,14 @@
+module Ovirt
+  class Storage < Object
+
+    self.top_level_objects  = [:host]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      parse_first_node(node, :volume_group, hash, :attribute => [:id])
+
+      hash
+    end
+  end
+end

data/lib/ovirt/storage_domain.rb

@@ -0,0 +1,48 @@
+module Ovirt
+  class StorageDomain < Object
+
+    self.top_level_strings    = [:name, :type, :storage_format]
+    self.top_level_booleans   = [:master]
+    self.top_level_integers   = [:available, :used, :committed]
+    self.top_level_objects    = [:data_center]
+
+    def self.element_name
+      "storage_domain"
+    end
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      parse_first_node(node, :status,  hash, :node => [:state])
+      parse_first_node(node, :storage, hash, :node => [:type, :address, :path])
+      parse_first_node(node, :storage, hash, :attribute => [:id])
+
+      node.xpath('storage/volume_group').each do |vg|
+        node.xpath('storage').each do |storage_node|
+          parse_first_node(storage_node, :volume_group, hash[:storage], :attribute => [:id])
+        end
+
+        vg_hash = hash[:storage][:volume_group]
+        unless vg_hash.blank?
+          parse_first_node(vg, :logical_unit, vg_hash, :attribute => [:id])
+
+          unless vg_hash.blank?
+            parse_first_node(vg, :logical_unit, vg_hash,
+              :node => [:address, :port, :target, :username, :serial, :vendor_id, :product_id, :lun_mapping, :portal, :size, :paths])
+          end
+        end
+      end
+
+      hash
+    end
+
+    def self.iso_storage_domain(service)
+      all(service).detect { |s| s[:type] == "iso" }
+    end
+
+    def iso_images
+      return [] if self[:type] != "iso"
+      @service.standard_collection(relationships[:files], 'file')
+    end
+  end
+end

data/lib/ovirt/tag.rb

@@ -0,0 +1,23 @@
+module Ovirt
+  class Tag < Object
+
+    self.top_level_strings = [:name, :description]
+    self.top_level_objects = [:host, :user, :vm]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      parent_node = node.xpath('parent').first
+      unless parent_node.nil?
+        tag_node = parent_node.xpath('tag').first
+        unless tag_node.nil?
+          parent = hash_from_id_and_href(tag_node)
+          parent[:type] = 'tag'
+          hash[:parent] = parent
+        end
+      end
+
+      hash
+    end
+  end
+end

data/lib/ovirt/template.rb

@@ -0,0 +1,185 @@
+module Ovirt
+  class Template < Object
+
+    self.top_level_strings    = [:name, :description, :type]
+    self.top_level_booleans   = [:stateless]
+    self.top_level_integers   = [:memory]
+    self.top_level_timestamps = [:creation_time]
+    self.top_level_objects    = [:cluster]
+
+    def self.parse_xml(xml)
+      node, hash = xml_to_hash(xml)
+
+      parse_first_node(node, :status, hash, :node => [:state])
+
+      parse_first_node(node, :display, hash,
+                       :node      => [:type, :address],
+                       :node_to_i => [:port, :monitors])
+
+      parse_first_node(node, :usb, hash,
+                       :node_to_bool => [:enabled])
+
+      parse_first_node_with_hash(node, 'cpu/topology', hash.store_path(:cpu, :topology, {}),
+                       :attribute_to_i => [:sockets, :cores])
+
+      parse_first_node(node, :high_availability, hash,
+                       :node_to_bool => [:enabled],
+                       :node_to_i    => [:priority])
+
+      parse_first_node(node, :os, hash,
+                       :attribute => [:type],
+                       :node      => [:kernel, :initrd, :cmdline])
+
+      hash[:os][:boot_order] = boot_order = []
+      #Collect boot order
+      node.xpath('os/boot').each do |boot|
+        dev = boot['dev']
+        boot_order << {:dev => dev} unless dev.blank?
+      end
+
+      hash[:custom_attributes] = []
+      node.xpath('custom_properties/custom_property').each do |ca|
+        hash[:custom_attributes] << {:name => ca[:name], :value => ca[:value]}
+      end
+
+
+      hash
+    end
+
+    def os_type
+      self.attributes.fetch_path(:os, :type) || 'unassigned'
+    end
+
+    def getCfg(snap=nil)
+      #mor = snap ? getSnapMor(snap) : @vmMor
+      cfgProps = self.attributes
+
+      raise MiqException::MiqVimError, "Failed to retrieve configuration information for VM" if cfgProps.nil?
+
+      cfgHash = {}
+      cfgHash['displayname'] = cfgProps[:name]
+      cfgHash['guestos'] = cfgProps.fetch_path(:os, :type)
+      cfgHash['memsize'] = cfgProps[:memory] / 1048576  # in MB
+      cfgHash['numvcpu'] = cfgProps.fetch_path(:cpu, :sockets)
+
+      # Collect disk information
+      self.attributes[:disks] = self.send(:disks, :disk) if self[:disks].nil?
+      self.disks.each_with_index do |disk, idx|
+        storage_domain = disk[:storage_domains].first
+        storage_id = storage_domain && storage_domain[:id]
+        disk_key = disk[:image_id].blank? ? :id : :image_id
+        file_path = storage_id && File.join('/dev', storage_id, disk[disk_key])
+
+        tag = "scsi0:#{idx}"
+        cfgHash["#{tag}.present"]    = "true"
+        cfgHash["#{tag}.devicetype"] = "disk"
+        cfgHash["#{tag}.filename"]   = file_path.to_s
+        cfgHash["#{tag}.format"]     = disk[:format]
+        #cfgHash["#{tag}.mode"] = dev['backing']['diskMode']
+      end
+      return cfgHash
+    end
+
+    REQUIRED_CLONE_PARAMETERS     = [:name, :cluster]
+    CLONE_ATTRIBUTES_WITH_SCALARS = [:memory, :stateless, :type]
+    CLONE_ATTRIBUTES_WITH_HASHES  = [:display, :usb, :cpu, :high_availability]
+    ALLOWED_CLONE_TYPES           = [:full, :linked, :skeletal]
+
+    def create_vm(options = {})
+      options = options.dup
+      determine_clone_type(options)
+      options[:storage] = Object.object_to_id(options[:storage]) if options[:storage]
+
+      case options[:clone_type]
+      when :full;     clone_to_vm(options)
+      when :linked;   clone_to_vm(options)
+      when :skeletal; clone_to_vm_via_blank_template(options)
+      end
+    end
+
+    private
+
+    def determine_clone_type(options)
+      # Return the clone_type from the options if it matches one of the types in the allowed array
+      #  otherwise return the first type from the allowed array as a default
+      options[:clone_type] = ALLOWED_CLONE_TYPES.include?(options[:clone_type]) ? options[:clone_type] : ALLOWED_CLONE_TYPES.first
+    end
+
+    def clone_to_vm_via_blank_template(options)
+      # Create a VM based the VM on the blank template using parameters from this template
+      # Disks are created from scratch, not copied
+      (CLONE_ATTRIBUTES_WITH_SCALARS + CLONE_ATTRIBUTES_WITH_HASHES).each do |key|
+        options[key] ||= self[key]
+      end
+      options[:os_type] ||= self.os_type
+
+      skeleton_options = options.dup
+      skeleton_options[:clone_type] = :linked
+      vm = @service.blank_template.create_vm(skeleton_options)
+
+      create_new_disks_from_template(vm, options)
+      vm
+    end
+
+    def create_new_disks_from_template(vm, options)
+      self.disks.each do |disk_object|
+        disk_options            = disk_object.attributes_for_new_disk
+        disk_options[:sparse]   = options[:sparse]  unless options[:sparse].nil?
+        disk_options[:storage]  = options[:storage] unless options[:storage].blank?
+        vm.create_disk(disk_options)
+      end
+    end
+
+    def clone_to_vm(options)
+      # Create a VM based on this template
+      REQUIRED_CLONE_PARAMETERS.each do |key|
+        raise ArgumentError, "#{key.inspect} cannot be blank" if options[key].blank?
+      end
+
+      response = @service.resource_post(:vms, build_clone_xml(options))
+      Vm.create_from_xml(@service, response)
+    rescue Ovirt::Error => err
+      raise VmAlreadyExists, err.message if err.message.include?("VM with the same name already exists")
+      raise
+    end
+
+    def build_clone_xml(options)
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.vm do
+          xml.name options[:name]
+          xml.cluster(:id => Object.object_to_id(options[:cluster]))
+          xml.template(:id => self[:id])
+
+          CLONE_ATTRIBUTES_WITH_SCALARS.each do |key|
+            xml.send("#{key}_", options[key] || self[key])
+          end
+
+          CLONE_ATTRIBUTES_WITH_HASHES.each do |key|
+            xml.send("#{key}_") do
+              hash = options[key] || self[key]
+              hash.each { |k, v| xml.send("#{k}_", v) } unless hash.nil?
+            end
+          end
+
+          xml.os(:type => options[:os_type] || self.os_type) do
+            xml.boot(:dev => 'hd')
+          end
+
+          if options[:clone_type] == :full
+            xml.disks do
+              xml.clone_ true
+              self.disks.each do |disk_object|
+                xml.disk(:id => disk_object.attributes[:id]) do
+                  xml.sparse options[:sparse] unless options[:sparse].nil?
+                  xml.storage_domains { xml.storage_domain(:id => options[:storage]) } if options[:storage]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      builder.doc.root.to_xml
+    end
+  end
+end

data/lib/ovirt/user.rb

@@ -0,0 +1,15 @@
+module Ovirt
+  class User < Object
+
+    self.top_level_strings  = [:name, :description, :domain, :user_name]
+    self.top_level_booleans = [:logged_in]
+
+    def self.parse_xml(xml)
+      node, hash    = xml_to_hash(xml)
+      groups_node   = node.xpath('groups').first
+      hash[:groups] = groups_node.xpath('group').collect { |group_node| group_node.text } unless groups_node.nil?
+
+      hash
+    end
+  end
+end

data/lib/ovirt/version.rb

@@ -0,0 +1,3 @@
+module Ovirt
+  VERSION = "0.1.0"
+end