deltacloud-core 0.1.2 → 0.3.0

data/lib/deltacloud/drivers/rhevm/rhevm_client.rb

@@ -0,0 +1,332 @@
+require 'rubygems'
+require 'base64'
+require 'restclient'
+require 'nokogiri'
+require 'digest/md5'
+require 'json'
+
+module RHEVM
+
+  def self.client(url)
+    RestClient::Resource.new(url)
+  end
+
+  class Client
+
+    attr_reader :credentials, :api_entrypoint
+
+    def initialize(username, password, api_entrypoint)
+      @credentials = { :username => username, :password => password }
+      @api_entrypoint = api_entrypoint
+    end
+
+    def vms(opts={})
+      headers = {
+        :accept => "application/xml; detail=disks; detail=nics; detail=hosts"
+      }
+      headers.merge!(auth_header)
+      if opts[:id]
+        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/vms/%s" % opts[:id]].get(headers)).root
+        [ RHEVM::VM::new(self, vm)]
+      else
+        Client::parse_response(RHEVM::client(@api_entrypoint)["/vms"].get(headers)).xpath('/vms/vm').collect do |vm|
+          RHEVM::VM::new(self, vm)
+        end
+      end
+    end
+
+    def vm_action(id, action, headers={})
+      headers.merge!(auth_header)
+      headers.merge!({
+        :content_type => 'application/xml',
+        :accept => 'application/xml',
+      })
+      if action==:delete
+        RHEVM::client(@api_entrypoint)["/vms/%s" % id].delete(headers)
+      else
+        xml_response = Client::parse_response(RHEVM::client(@api_entrypoint)["/vms/%s/%s" % [id, action]].post('<action/>', headers))
+        return false if (xml_response/'action/status').first.text!="COMPLETE"
+      end
+      return true
+    end
+
+    def create_vm(template_id, opts={})
+      opts ||= {}
+      builder = Nokogiri::XML::Builder.new do
+        vm {
+          name opts[:name] || "i-#{Time.now.to_i}"
+          template_(:id => template_id)
+          cluster(:id => opts[:realm_id] || clusters.first.id)
+          type_ opts[:hwp_id] || 'desktop'
+          memory opts[:hwp_memory] || (512*1024*1024).to_s
+          cpu {
+            topology( :cores => (opts[:hwp_cpu] || '1'), :sockets => '1' )
+          }
+        }
+      end
+      headers = opts[:headers] || {}
+      headers.merge!({
+        :content_type => 'application/xml',
+        :accept => 'application/xml',
+      })
+      headers.merge!(auth_header)
+      vm = RHEVM::client(@api_entrypoint)["/vms"].post(Nokogiri::XML(builder.to_xml).root.to_s, headers)
+      RHEVM::VM::new(self, Nokogiri::XML(vm).root)
+    end
+
+    def templates(opts={})
+      headers = {
+        :accept => "application/xml"
+      }
+      headers.merge!(auth_header)
+      if opts[:id]
+        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/templates/%s" % opts[:id]].get(headers)).root
+        [ RHEVM::Template::new(self, vm)]
+      else
+        Client::parse_response(RHEVM::client(@api_entrypoint)["/templates"].get(headers)).xpath('/templates/template').collect do |vm|
+          RHEVM::Template::new(self, vm)
+        end
+      end
+    end
+
+    def clusters(opts={})
+      headers = {
+        :accept => "application/xml; detail=datacenters"
+      }
+      headers.merge!(auth_header)
+      if opts[:id]
+        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/clusters/%s" % opts[:id]].get(headers)).root
+        [ RHEVM::Cluster::new(self, vm)]
+      else
+        Client::parse_response(RHEVM::client(@api_entrypoint)["/clusters"].get(headers)).xpath('/clusters/cluster').collect do |vm|
+          RHEVM::Cluster::new(self, vm)
+        end
+      end
+    end
+
+    def datacenters(opts={})
+      headers = {
+        :accept => "application/xml"
+      }
+      headers.merge!(auth_header)
+      if opts[:id]
+        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/datacenters/%s" % opts[:id]].get(headers)).root
+        [ RHEVM::DataCenter::new(self, vm)]
+      else
+        Client::parse_response(RHEVM::client(@api_entrypoint)["/datacenters"].get(headers)).xpath('/data_centers/data_center').collect do |vm|
+          RHEVM::DataCenter::new(self, vm)
+        end
+      end
+    end
+
+    def hosts(opts={})
+      headers = {
+        :accept => "application/xml"
+      }
+      headers.merge!(auth_header)
+      if opts[:id]
+        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/hosts/%s" % opts[:id]].get(headers)).root
+        [ RHEVM::Host::new(self, vm)]
+      else
+        Client::parse_response(RHEVM::client(@api_entrypoint)["/hosts"].get(headers)).xpath('/hosts/host').collect do |vm|
+          RHEVM::Host::new(self, vm)
+        end
+      end
+    end
+
+    def storagedomains(opts={})
+      headers = {
+        :accept => "application/xml"
+      }
+      headers.merge!(auth_header)
+      if opts[:id]
+        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/storagedomains/%s" % opts[:id]].get(headers)).root
+        [ RHEVM::StorageDomain::new(self, vm)]
+      else
+        Client::parse_response(RHEVM::client(@api_entrypoint)["/storagedomains"].get(headers)).xpath('/storage_domains/storage_domain').collect do |vm|
+          RHEVM::StorageDomain::new(self, vm)
+        end
+      end
+    end
+
+    def auth_header
+      { :authorization => "Basic " + Base64.encode64("#{@credentials[:username]}:#{@credentials[:password]}"), }
+    end
+
+    def base_url
+      url = URI.parse(@api_entrypoint)
+      "#{url.scheme}://#{url.host}:#{url.port}"
+    end
+
+    def self.parse_response(response)
+      Nokogiri::XML(response)
+    end
+
+  end
+
+  class BaseObject
+    attr_accessor :id, :href, :name
+    attr_reader :client
+
+    def initialize(client, id, href, name)
+      @id, @href, @name = id, href, name
+      @client = client
+      self
+    end
+
+  end
+
+  class Link
+    attr_accessor :id, :href, :client
+
+    def initialize(client, id, href)
+      @id, @href = id, href
+      @client = client
+    end
+
+    def follow
+      xml = Client::parse_response(RHEVM::client(@client.base_url)[@href].get(@client.auth_header))
+      object_class = ::RHEVM.const_get(xml.root.name.camelize)
+      object_class.new(@client, (xml.root))
+    end
+
+  end
+
+  class VM < BaseObject
+    attr_reader :description, :status, :memory, :profile, :display, :host, :cluster, :template, :macs
+    attr_reader :storage, :cores, :username, :creation_time
+    attr_reader :ip
+
+    def initialize(client, xml)
+      super(client, xml[:id], xml[:href], (xml/'name').first.text)
+      @username = client.credentials[:username]
+      parse_xml_attributes!(xml)
+      self
+    end
+
+    private
+
+    def parse_xml_attributes!(xml)
+      @description = ((xml/'description').first.text rescue '')
+      @status = (xml/'status').first.text
+      @memory = (xml/'memory').first.text
+      @profile = (xml/'type').first.text
+      @template = Link::new(@client, (xml/'template').first[:id], (xml/'template').first[:href])
+      @host = Link::new(@client, (xml/'host').first[:id], (xml/'host').first[:href]) rescue nil
+      @cluster = Link::new(@client, (xml/'cluster').first[:id], (xml/'cluster').first[:href])
+      @display = {
+        :type => (xml/'display/type').first.text,
+        :address => ((xml/'display/address').first.text rescue nil),
+        :port => ((xml/'display/port').first.text rescue nil),
+        :monitors => (xml/'display/monitors').first.text
+      }
+      @cores = ((xml/'cpu/topology').first[:cores] rescue nil)
+      @storage = ((xml/'disks/disk/size').first.text rescue nil)
+      @macs = (xml/'nics/nic/mac').collect { |mac| mac[:address] }
+      @creation_time = (xml/'creation_time').text
+      @ip = ((xml/'guest_info/ip').first[:address] rescue nil)
+    end
+
+  end
+
+  class Template < BaseObject
+    attr_reader :description, :status, :cluster
+
+    def initialize(client, xml)
+      super(client, xml[:id], xml[:href], (xml/'name').first.text)
+      parse_xml_attributes!(xml)
+      self
+    end
+
+    private
+
+    def parse_xml_attributes!(xml)
+      @description = ((xml/'description').first.text rescue nil)
+      @status = (xml/'status').first.text
+      @cluster = Link::new(@client, (xml/'cluster').first[:id], (xml/'cluster').first[:href])
+    end
+  end
+
+  class Cluster < BaseObject
+    attr_reader :description, :datacenter
+
+    def initialize(client, xml)
+      super(client, xml[:id], xml[:href], (xml/'name').first.text)
+      parse_xml_attributes!(xml)
+      self
+    end
+
+    private
+
+    def parse_xml_attributes!(xml)
+      @description = ((xml/'description').first.text rescue nil)
+      @datacenter = Link::new(@client, (xml/'data_center').first[:id], (xml/'data_center').first[:href])
+    end
+  end
+
+  class DataCenter < BaseObject
+    attr_reader :description, :status
+
+    def initialize(client, xml)
+      super(client, xml[:id], xml[:href], (xml/'name').first.text)
+      parse_xml_attributes!(xml)
+      self
+    end
+
+    private
+
+    def parse_xml_attributes!(xml)
+      @description = ((xml/'description').first.text rescue nil)
+      @status = (xml/'status').first.text
+    end
+  end
+
+  class Host < BaseObject
+    attr_reader :description, :status, :cluster
+
+    def initialize(client, xml)
+      super(client, xml[:id], xml[:href], (xml/'name').first.text)
+      parse_xml_attributes!(xml)
+      self
+    end
+
+    private
+
+    def parse_xml_attributes!(xml)
+      @description = ((xml/'description').first.text rescue nil)
+      @status = (xml/'status').first.text
+      @clister = Link::new(@client, (xml/'cluster').first[:id], (xml/'cluster').first[:href])
+    end
+  end
+
+  class StorageDomain < BaseObject
+    attr_reader :available, :used, :kind, :address, :path
+
+    def initialize(client, xml)
+      super(client, xml[:id], xml[:href], (xml/'name').first.text)
+      parse_xml_attributes!(xml)
+      self
+    end
+
+    private
+
+    def parse_xml_attributes!(xml)
+      @available = (xml/'available').first.text
+      @used = (xml/'used').first.text
+      @kind = (xml/'storage/type').first.text
+      @address = ((xml/'storage/address').first.text rescue nil)
+      @path = ((xml/'storage/path').first.text rescue nil)
+    end
+  end
+  
+end
+
+class String
+  unless method_defined?(:camelize)
+    # Camelize converts strings to UpperCamelCase
+    def camelize
+      self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+  end
+end
+

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -1,6 +1,4 @@
 #
-# Copyright (C) 2009  Red Hat, Inc.
-#
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
 # this work for additional information regarding copyright ownership.  The
@@ -16,8 +14,18 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+# Minihowto: Setting up this driver
+#
+# 1. Setup RHEV-M server
+# 2. Setup RHEV-M API (git://git.fedorahosted.org/rhevm-api.git - follow README)
+# 3. Set URL to API using shell variable (or HTTP header, see comment on provider_url)
+#    export API_PROVIDER="https://x.x.x.x/rhevm-api-powershell"
+# 4. Start Deltacloud using: deltacloudd -i rhevm
+# 5. Use RHEV-M credentials + append Windows Domain
+#    like: admin@rhevm.example.com
+
 require 'deltacloud/base_driver'
-require 'yaml'
+require 'deltacloud/drivers/rhevm/rhevm_client'
 
 module Deltacloud
   module Drivers
@@ -25,218 +33,261 @@ module Deltacloud
 
 class RHEVMDriver < Deltacloud::BaseDriver
 
-  SCRIPT_DIR = File.dirname(__FILE__) + '/scripts'
-  CONFIG = YAML.load_file(File.dirname(__FILE__) + '/../../../../config/rhevm_config.yml')
-  SCRIPT_DIR_ARG = '"' + SCRIPT_DIR + '"'
-  DELIM_BEGIN="<_OUTPUT>"
-  DELIM_END="</_OUTPUT>"
-  POWERSHELL="c:\\Windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe"
-  NO_OWNER=""
-
   feature :instances, :user_name
 
-  def supported_collections
-    DEFAULT_COLLECTIONS.reject { |c| [ :storage_volumes, :storage_snapshots ].include?(c) }
-  end
-
-  #
-  # Execute a Powershell command, and convert the output
-  # to YAML in order to get back an array of maps.
+  # FIXME: These values are just for ilustration
+  # Also I choosed 'SERVER' and 'DESKTOP' names
+  # because they are referred by VM (API type)
   #
-  def execute(credentials, command, *args)
-    args = args.to_a
-    argString = genArgString(credentials, args)
-    puts argString
-    outputMaps = {}
-    output = `#{POWERSHELL} -command "&{#{File.join(SCRIPT_DIR, command)} #{argString}; exit $LASTEXITCODE}`
-    exitStatus = $?.exitstatus
-    puts(output)
-    puts("EXITSTATUS #{exitStatus}")
-    st = output.index(DELIM_BEGIN)
-    if (st)
-      st += DELIM_BEGIN.length
-      ed = output.index(DELIM_END)
-      output = output.slice(st, (ed-st))
-      # Lets make it yaml
-      output.strip!
-      if (output.length > 0)
-        outputMaps = YAML.load(self.toYAML(output))
-      end
-    end
-    outputMaps
+  # Values like RAM or STORAGE are reported by VM
+  # so they are not static.
+
+  define_hardware_profile 'SERVER' do
+    cpu         ( 1..16 )
+    memory      ( 512 .. 32*1024 )
+    storage     ( 1 .. 100*1024 )
+    architecture 'x86_64'
   end
 
-  def genArgString(credentials, args)
-    commonArgs = [SCRIPT_DIR_ARG, credentials.user, credentials.password, CONFIG["domain"]]
-    commonArgs.concat(args)
-    commonArgs.join(" ")
+  define_hardware_profile 'DESKTOP' do
+    cpu         ( 1..16 )
+    memory      ( 512 .. 32*1024 )
+    storage     ( 1 .. 100*1024 )
+    architecture 'x86_64'
   end
 
-  def toYAML(output)
-    yOutput = "- \n" + output
-    yOutput.gsub!(/^(\w*)[ ]*:[ ]*([A-Z0-9a-z._ -:{}]*)/,' \1: "\2"')
-    yOutput.gsub!(/^[ ]*$/,"- ")
-    puts(yOutput)
-    yOutput
+  # Instead of setting a URL for RHEV provider
+  # do it here in driver, so it can be altered by HTTP headers
+  #
+  def provider_uri=(uri)
+    @RHEVM_URI = uri
   end
 
-  def statify(state)
-    st = state.nil? ? "" : state.upcase()
-    case st
-    when "UP"
-      "RUNNING"
-    when "DOWN"
-      "STOPPED"
-    when "POWERING UP"
-      "PENDING"
-    end
+  # Default Provider URI.
+  #
+  # IMPORTANT:
+  # This URI can be overridden using shell variable API_PROVIDER
+  # or setting provider using HTTP header X-Deltacloud-Provider to URL.
+  #
+  def provider_uri
+    Deltacloud::Drivers::driver_config[:rhevm][:entrypoints]['default']['default']
   end
 
-  define_hardware_profile 'rhevm'
+  define_instance_states do
+    start.to( :pending )          .automatically
+    pending.to( :running )        .automatically
+    pending.to( :stopped )        .automatically
+    stopped.to( :running )        .on( :start )
+    running.to( :stopping )       .on( :stop )
+    stopped.to( :finish )         .on( :destroy )
+  end
 
   #
   # Realms
   #
 
   def realms(credentials, opts=nil)
-    domains = execute(credentials, "storageDomains.ps1")
-    if (!opts.nil? && opts[:id])
-        domains = domains.select{|d| opts[:id] == d["StorageId"]}
+    client = new_client(credentials)
+    realm_arr = []
+    safely do
+      clusters = client.clusters
+      clusters.each do |r|
+        d = client.datacenters(:id => r.datacenter.id).first
+        realm_arr << convert_realm(r, d)
+      end
     end
+    realm_arr
+  end
 
-    realms = []
-    domains.each do |dom|
-      realms << domain_to_realm(dom)
+  def images(credentials, opts={})
+    client = new_client(credentials)
+    img_arr = []
+    safely do
+      templates = client.templates
+      if (!opts.nil? && opts[:id])
+        templates = templates.select{|t| opts[:id] == t.id}
+      end
+      templates.each do |t|
+        img_arr << convert_image(client, t)
+      end
     end
-    realms
+    img_arr = filter_on( img_arr, :architecture, opts )
+    img_arr.sort_by{|e| [e.owner_id, e.name]}
   end
 
-  def domain_to_realm(dom)
-    Realm.new({
-      :id => dom["StorageId"],
-      :name => dom["Name"],
-      :limit => dom["AvailableDiskSize"]
-    })
+  def instances(credentials, opts={})
+    client = new_client(credentials)
+    inst_arr = []
+    safely do
+      if opts[:id]
+        vms = client.vms(:id => opts[:id])
+      else
+        vms = client.vms
+      end
+      vms.each do |vm|
+        inst_arr << convert_instance(client, vm)
+      end
+    end
+    inst_arr = filter_on( inst_arr, :id, opts )
+    filter_on( inst_arr, :state, opts )
   end
 
+  def start_instance(credentials, id)
+    client = new_client(credentials)
+    safely do
+      raise "ERROR: Operation start failed" unless client.vm_action(id, :start)
+    end
+  end
 
+  def stop_instance(credentials, id)
+    client = new_client(credentials)
+    safely do
+      raise "ERROR: Operation start failed" unless client.vm_action(id, :shutdown)
+    end
+  end
 
-  #
-  # Images
-  #
+  def destroy_instance(credentials, id)
+    client = new_client(credentials)
+    safely do
+      raise "ERROR: Operation start failed" unless client.vm_action(id, :delete)
+    end
+  end
 
-  def images(credentials, opts=nil )
-    templates = []
-    if (opts.nil?)
-      templates = execute(credentials, "templates.ps1")
-    else
-      if (opts[:id])
-        templates = execute(credentials, "templateById.ps1", opts[:id])
+  def storage_volumes(credentials, opts={})
+    client = new_client(credentials)
+    domains_arr = []
+    safely do
+      client.storagedomains.each do |s|
+        domains_arr << convert_volume(s)
       end
     end
-    images = []
-    templates.each do |templ|
-      images << template_to_image(templ)
-    end
-    images
+    domains_arr = filter_on( domains_arr, :id, opts )
+    filter_on( domains_arr, :state, opts )
   end
 
-  def template_to_image(templ)
-    Image.new({
-      :id => templ["TemplateId"],
-      :name => templ["Name"],
-      :description => templ["Description"],
-      :architecture => templ["OperatingSystem"],
-      :owner_id => NO_OWNER,
-      :mem_size_md => templ["MemSizeMb"],
-      :instance_count => templ["ChildCount"],
-      :state => templ["Status"],
-      :capacity => templ["SizeGB"]
-    })
+  def create_instance(credentials, image_id, opts={})
+    client = new_client(credentials)
+    params = {}
+    safely do
+      params[:name] = opts[:name] if opts[:name]
+      params[:realm_id] = opts[:realm_id] if opts[:realm_id]
+      params[:hwp_id] = opts[:hwp_id] if opts[:hwp_id]
+      params[:hwp_memory] = opts[:hwp_memory] if opts[:hwp_memory]
+      params[:hwp_cpu] = opts[:hwp_cpu] if opts[:hwp_cpu]
+      convert_instance(client, client.create_vm(image_id, params))
+    end
   end
 
-  #
-  # Instances
-  #
-
-  define_instance_states do
-    start.to(:stopped)            .on( :create )
-
-    pending.to(:shutting_down)    .on( :stop )
-    pending.to(:running)          .automatically
+  def valid_credentials?(credentials)
+    retval = true
+    begin
+      realms(credentials)
+    rescue Deltacloud::BackendError
+     retval = false
+    end
+    retval
+  end
 
-    running.to(:pending)          .on( :reboot )
-    running.to(:shutting_down)    .on( :stop )
+  private
 
-    shutting_down.to(:stopped)    .automatically
-    stopped.to(:pending)          .on( :start )
-    stopped.to(:finish)           .on( :destroy )
+  def new_client(credentials)
+    url = (Thread.current[:provider] || ENV['API_PROVIDER'] || provider_uri)
+    safely do
+      ::RHEVM::Client.new(credentials.user, credentials.password, url)
+    end
   end
 
-  def instances(credentials, opts=nil)
-    vms = []
-    if (opts.nil?)
-      vms = execute(credentials, "vms.ps1")
+  def convert_instance(client, inst)
+    state = convert_state(inst.status)
+    storage_size = inst.storage.nil? ? 1 :  (inst.storage.to_i/1024/1024/1024)
+    profile = InstanceProfile::new(inst.profile.upcase, 
+                                   :hwp_memory => inst.memory.to_i/1024/1024,
+                                   :hwp_cpu => inst.cores,
+                                   :hwp_storage => "#{storage_size}"
+    )
+    # Include VNC and SPICE addresses
+    if inst.ip
+      public_addresses = [ inst.ip ]
     else
-      if (opts[:id])
-        vms = execute(credentials, "vmById.ps1", opts[:id])
-      end
-    end
-    instances = []
-    vms.each do |vm|
-      instances << vm_to_instance(vm)
+      public_addresses = [ inst.macs ]
     end
-    instances = filter_on( instances, :id, opts )
-    instances = filter_on( instances, :state, opts )
-    instances
-  end
-
-  def vm_to_instance(vm)
-    Instance.new({
-      :id => vm["VmId"],
-      :description => vm["Description"],
-      :name => vm["Name"],
-      :architecture => vm["OperatingSystem"],
-      :owner_id => NO_OWNER,
-      :image_id => vm["TemplateId"],
-      :state => statify(vm["Status"]),
-      :instance_profile => InstanceProfile.new("rhevm"),
-      :actions => instance_actions_for(statify(vm["Status"])),
-    })
-  end
-
-  def start_instance(credentials, image_id)
-    vm = execute(credentials, "startVm.ps1", image_id)
-    vm_to_instance(vm[0])
-  end
-
-  def stop_instance(credentials, image_id)
-    vm = execute(credentials, "stopVm.ps1", image_id)
-    vm_to_instance(vm[0])
-  end
-
-  def create_instance(credentials, image_id, opts)
-    name = opts[:name]
-    name = "Inst-#{rand(10000)}" if (name.nil? or name.empty?)
-    realm_id = opts[:realm_id]
-    if (realm_id.nil?)
-        realms = filter_on(realms(credentials, opts), :name, :name => "data")
-        puts realms[0]
-        realm_id = realms[0].id
+    Instance.new(
+      :id => inst.id,
+      :name => inst.name,
+      :state => state,
+      :image_id => inst.template.id,
+      :realm_id => inst.cluster.id,
+      :owner_id => inst.username,
+      :launch_time => inst.creation_time,
+      :instance_profile => profile,
+      :hardware_profile_id => profile.id,
+      :actions=>instance_actions_for( state ),
+      :public_addresses => public_addresses,
+      :private_addresses => []
+    )
+  end
+
+  # STATES: 
+  #
+  # UNASSIGNED, DOWN, UP, POWERING_UP, POWERED_DOWN, PAUSED, MIGRATING_FROM, MIGRATING_TO, 
+  # UNKNOWN, NOT_RESPONDING, WAIT_FOR_LAUNCH, REBOOT_IN_PROGRESS, SAVING_STATE, RESTORING_STATE, 
+  # SUSPENDED, IMAGE_ILLEGAL, IMAGE_LOCKED or POWERING_DOWN 
+  #
+  def convert_state(state)
+    case state
+    when 'WAIT_FOR_LAUNCH', 'REBOOT_IN_PROGRESS', 'SAVING_STATE',
+      'RESTORING_STATE', 'POWERING_DOWN', 'POWERING_UP', 'IMAGE_LOCKED', 'SAVING_STATE' then
+      'PENDING'
+    when 'UNASSIGNED', 'DOWN', 'PAUSED', 'NOT_RESPONDING', 'SUSPENDED', 'IMAGE_ILLEGAL', 'UNKNOWN' then
+      'STOPPED'
+    when 'UP', 'MIGRATING_TO', 'MIGRATING_FROM'
+      'RUNNING'
     end
-    vm = execute(credentials, "addVm.ps1", image_id, name, realm_id)
-    vm_to_instance(vm[0])
   end
 
-  def reboot_instance(credentials, image_id)
-    vm = execute(credentials, "rebootVm.ps1", image_id)
-    vm_to_instance(vm[0])
+  def convert_volume(volume)
+    StorageVolume.new(
+      :id => volume.id,
+      :state => 'AVAILABLE',
+      :capacity => ((volume.available.to_i-volume.used.to_i)/1024/1024/1024).abs,
+      :instance_id => nil,
+      :kind => volume.kind,
+      :name => volume.name,
+      :device => volume.address ? "#{volume.address}:#{volume.path}" : nil
+    )
+  end
+
+  def convert_image(client, img)
+    Image.new(
+      :id => img.id,
+      :name => img.name,
+      :description => img.description,
+      :owner_id => client.credentials[:username],
+      :architecture => 'x86_64', # All RHEV-M VMs are x86_64
+      :state => img.status
+    )
   end
 
-  def destroy_instance(credentials, image_id)
-    vm = execute(credentials, "deleteVm.ps1", image_id)
-    vm_to_instance(vm[0])
+  def convert_realm(r, dc)
+    Realm.new(
+      :id => r.id,
+      :name => dc.name,
+      :state => dc.status == 'UP' ? 'AVAILABLE' : 'DOWN',
+      :limit => :unlimited
+    )
   end
+
+  # Disabling this error catching will lead to more verbose messages
+  # on console (eg. response from RHEV-M API (so far I didn't figure our
+  # how to pass those message to our exception handling tool)
+  def catched_exceptions_list
+    {
+      :auth => [RestClient::Unauthorized],
+      :error => [RestClient::InternalServerError],
+      :glob => [ /(RestClient|RHEVM)::(\w+)/ ]
+    }
+  end
+
 end
 
     end