xenapi-ruby 0.1.29

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    xenapi-ruby (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.4)
+    diff-lcs (1.1.3)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec
+  ruby-debug19
+  xenapi-ruby!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Locaweb <development@locaweb.com.br>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,26 @@
+= xenapi-ruby
+
+xenapi-ruby is a ruby gem to deal with xen api, executing commands acording to your xenserver version api documentation.
+
+== Usage
+
+Usage here
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request.
+
+== Contributors
+
+* Fabio Kung
+
+== Copyright
+
+Copyright (c) 2009 Locaweb <development@locaweb.com>. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/config/xenapi.yml

@@ -0,0 +1,4 @@
+xenapi:
+  xenurl: "https://10.20.64.3"
+  user: "root"
+  password: "lerolero"

data/config/xenapi.yml.example

@@ -0,0 +1,4 @@
+xenapi:
+  xenurl: "https://127.0.0.1"
+  user: "root"
+  password: "My4w3s0m3P455w0rd"

data/lib/xenapi-ruby.rb

@@ -0,0 +1 @@
+require "xenapi"

data/lib/xenapi.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+require "yaml"
+require "xenapi/virtual_machine"
+require "xenapi/storage"
+require "xenapi/vdi"
+require "xenapi/vbd"
+require "xenapi/task"
+require "xenapi/network"
+
+require "xenapi/session"
+require "xenapi/error"
+require "xenapi/hypervisor_connection"

data/lib/xenapi/dispatcher.rb

@@ -0,0 +1,48 @@
+module XenAPI
+  class Dispatcher
+    undef_method :clone
+    
+    def initialize(proxy, &error_callback)
+      @proxy = adjust_proxy_methods!(proxy)
+      @error_callback = error_callback
+    end
+
+    def method_missing(name, *args)
+      begin
+        response = @proxy.send(name, *args)
+        raise XenAPI::ErrorFactory.create(*response['ErrorDescription']) unless response['Status'] == 'Success'
+        response['Value']
+      rescue Exception => exc
+        error = XenAPI::ErrorFactory.wrap(exc)
+        if @error_callback
+          @error_callback.call(error) do |new_session|
+            prefix = @proxy.prefix.delete(".").to_sym
+            dispatcher = new_session.send(prefix)
+            dispatcher.send(name, *args)
+          end
+        else
+          raise error
+        end
+      end
+    end
+    
+    private
+      def adjust_proxy_methods!(proxy)
+        proxy.instance_eval do
+          def clone(*args)
+            method_missing(:clone, *args)
+          end
+          def copy(*args)
+            method_missing(:copy, *args)
+          end
+
+          def prefix
+            @prefix
+          end
+        end
+
+        proxy
+      end
+
+  end
+end

data/lib/xenapi/error.rb

@@ -0,0 +1,71 @@
+require 'openssl'
+
+module XenAPI
+
+  class Error < RuntimeError
+  end
+  
+  class ConnectionError < Error
+  end
+  
+  class AuthenticationError < Error
+  end
+  
+  class ExpirationError < Error
+  end
+  
+  class TimeoutError < Error
+  end
+  
+  class UnauthenticatedClient < Error
+    def initialize(message = "Client needs to be authenticated first")
+      super
+    end
+  end
+
+  class NotMasterError < Error
+		attr_accessor :master_ip
+
+  	def initialize(message)
+  	  super
+			@master_ip = (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/).match(message)[0]
+  	end
+  end
+  
+  module ErrorFactory
+	  
+	  API_ERRORS = {
+	    "SESSION_AUTHENTICATION_FAILED" => AuthenticationError,
+	    "HOST_IS_SLAVE" => NotMasterError,
+	    "HOST_STILL_BOOTING" => ConnectionError
+	  }
+	  
+	  TRANSLATIONS = {
+	    EOFError => ExpirationError,
+	    OpenSSL::SSL::SSLError => ExpirationError,
+	    Errno::EHOSTUNREACH => ConnectionError,
+	    Errno::ECONNREFUSED => ConnectionError,
+	    Errno::EPIPE => ConnectionError,
+	    Timeout::Error => TimeoutError
+	  }
+	  
+	  def create(*args)
+	    key = args[0]
+	    message = args.join(": ")
+	    error_class = API_ERRORS[key]
+	    
+	    return error_class.new message if error_class
+	    Error.new message
+    end
+	  
+		def wrap(error)
+			return error if error.is_a? Error
+			
+			error_class = TRANSLATIONS[error.class]
+			return error_class.new error.to_s if error_class
+			Error.new "<#{error.class}> #{error}"
+		end
+
+    module_function :create, :wrap
+	end
+end

data/lib/xenapi/hypervisor_connection.rb

@@ -0,0 +1,46 @@
+# -*- coding: UTF-8 -*-
+module XenAPI
+  module HypervisorConnection
+    class << self
+      def hypervisor_session(host)
+        sessions[host.ip] ||= hypervisor_session!(host)
+      end
+
+      def hypervisor_session!(host)
+        Rails.logger.info "Connecting to hypervisor on #{host.ip} with user #{host.username}"
+        session = SessionFactory.create(host.ip, host.username, host.password) do |error, &called_method|
+          Rails.logger.error(error)
+          session = HypervisorErrorHandler.new(host.pool, error).handle_error
+
+          if called_method
+            called_method.call(session)
+          else
+            session
+          end
+        end
+      end
+
+      def close_hypervisor_session!
+        sessions.each do |host, session|
+          begin
+            session.close unless session.nil?
+          rescue Exception => error
+            Rails.logger.error("Error while trying to close connection to #{host}")
+            Rails.logger.error(error)
+          end
+        end
+        @sessions = {}
+      end
+
+     private
+      def sessions
+        @sessions ||= {}
+      end
+    end
+
+    def hypervisor_session
+      raise "Pool not found for #{self.inspect}" unless self.pool
+      HypervisorConnection.hypervisor_session(self.pool.master)
+    end
+  end
+end

data/lib/xenapi/network.rb

@@ -0,0 +1,8 @@
+# -*- encoding: utf-8 -*-
+module XenAPI
+  module Network
+    def network_name_label(name_label)
+      self.network.get_by_name_label(name_label)
+    end
+  end
+end

data/lib/xenapi/session.rb

@@ -0,0 +1,61 @@
+module XenAPI
+  require "xmlrpc/client"
+  require 'xenapi/dispatcher'
+
+  class Session
+    include XenAPI::VirtualMachine
+    include XenAPI::Vdi
+    include XenAPI::Vbd
+    include XenAPI::Storage
+    include XenAPI::Task
+    include XenAPI::Network
+
+    attr_reader :key
+
+    def initialize(uri, &block)
+      @uri, @block = uri, block
+    end
+
+    def login_with_password(username, password, timeout = 1200)
+      begin
+        @client = XMLRPC::Client.new2(@uri, nil, timeout)
+        @session = @client.proxy("session")
+
+        response = @session.login_with_password(username, password)
+        raise XenAPI::ErrorFactory.create(*response['ErrorDescription']) unless response['Status'] == 'Success'
+
+        @key = response["Value"]
+
+        #Let's check if it is a working master. It's a small pog due to xen not working as we would like
+        self.pool.get_all
+
+        self
+      rescue Exception => exc
+        error = XenAPI::ErrorFactory.wrap(exc)
+        if @block
+          # returns a new session
+          @block.call(error)
+        else
+          raise error
+        end
+      end
+    end
+
+    def close
+      @session.logout(@key)
+    end
+
+    # Avoiding method missing to get lost with Rake Task
+    # (considering Xen tasks as Rake task (???)
+    def task(*args)
+      method_missing("task", *args)
+    end
+
+    def method_missing(name, *args)
+      raise XenAPI::UnauthenticatedClient.new unless @key
+
+      proxy = @client.proxy(name.to_s, @key, *args)
+      Dispatcher.new(proxy, &@block)
+    end
+  end
+end

data/lib/xenapi/storage.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+module XenAPI
+  module Storage
+    def storage_ref(uuid)
+      self.SR.get_by_uuid(uuid)
+    end
+
+    def storage_record(ref)
+      self.SR.get_record(ref)
+    end
+
+    def storage_record_by_uuid(uuid)
+      self.SR.get_record(self.SR.get_by_uuid(uuid))
+    end
+
+    def storage_name(uuid)
+      self.SR.get_name_label storage_ref(uuid)
+    end
+
+    def all_storages
+      self.SR.get_all
+    end
+  end
+end

data/lib/xenapi/task.rb

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+module XenAPI
+  module Task
+    def task_record(ref)
+      self.task.get_record ref
+    end
+
+    def task_destroy(ref)
+      self.task.destroy ref
+    end
+
+    def task_create(name, description="Task creation")
+      self.task.create(name, description)
+    end
+  end
+end

data/lib/xenapi/vbd.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+module XenAPI
+  module Vbd
+    def create_VBD_for(vm_ref, disk_uuid, disk_number)
+      self.VBD.create({
+        :VM => vm_ref,
+        :VDI => self.VDI.get_by_uuid(disk_uuid),
+        :userdevice => disk_number.to_s,
+        :bootable => false,
+        :mode => "RW",
+        :type => "Disk",
+        :unpluggable => false,
+        :empty => false,
+        :other_config => {},
+        :qos_algorithm_type => "",
+        :qos_algorithm_params => {}
+      })
+    end
+  end
+end

data/lib/xenapi/vdi.rb

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+module XenAPI
+  module Vdi
+    def create_VDI_for(storage_ref, vm_object, vdi_number)
+      vdi_ref = self.VDI.create({
+        :name_label => "#{vm_object.name} DISK #{vdi_number}",
+        :name_description => "#{vm_object.name} DISK #{vdi_number}",
+        :SR => storage_ref,
+        :virtual_size => (vm_object.hdd - vm_object.hdd_size).gigabytes.to_s,
+        :type => "system",
+        :sharable => false,
+        :read_only => false,
+        :other_config => {},
+        :xenstore_data => {},
+        :sm_config => {},
+        :tags => []
+      })
+
+      self.VDI.get_record(vdi_ref)["uuid"]
+    end
+
+    def vdi_ref(uuid)
+      self.VDI.get_by_uuid(uuid)
+    end
+
+    def vdi_record(ref)
+      self.VDI.get_record(ref)
+    end
+
+    def vdi_clone(ref)
+      self.VDI.clone(vdi_ref)
+    end
+
+    def vdi_virtual_size(ref)
+      self.VDI.get_virtual_size(ref).to_i/(1024**3)
+    end
+
+    def vdi_resize(ref, new_size)
+      self.VDI.resize(ref, new_size.to_s)
+    end
+
+    def vdi_name_label=(ref, label)
+      self.VDI.set_name_label(ref, label)
+    end
+
+    def vdi_name_label(label)
+      self.VDI.get_by_name_label(label).first
+    end
+
+    def vdi_name_description=(ref, label)
+      self.VDI.set_name_description(ref, label)
+    end
+  end
+end

data/lib/xenapi/version.rb

@@ -0,0 +1,8 @@
+module XenAPI
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 29
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

data/lib/xenapi/virtual_machine.rb

@@ -0,0 +1,211 @@
+module XenAPI
+  module VirtualMachine
+    def vm_ref(uuid)
+      self.VM.get_by_uuid(uuid)
+    end
+
+    def vm_record(ref)
+      self.VM.get_record(ref)
+    end
+
+    def vm_clone(ref_to_clone, name)
+      self.VM.clone(ref_to_clone, name)
+    end
+
+    def tools_outdated?(ref)
+      guest_ref = self.VM.get_guest_metrics(ref)
+      guest_ref == "OpaqueRef:NULL" || !self.VM_guest_metrics.get_PV_drivers_up_to_date(guest_ref)
+    rescue Exception
+      false
+    end
+
+    def vbds(ref, opts = {})
+      vm_vbds_refs = self.VM.get_record(ref)["VBDs"]
+
+      vm_vbds_refs.inject({}) do |disks, vm_vbd_ref|
+        vm_vbd_record = self.VBD.get_record(vm_vbd_ref)
+
+        disks[vm_vbd_ref] = vm_vbd_record if opts[:include_cd] || vm_vbd_record["type"] == "Disk"
+        disks
+      end
+    rescue => e
+      {}
+    end
+
+    def hdd_physical_utilisation(vm_ref)
+      vbds(vm_ref).values.inject(0) do |disk_size, vbd_record|
+        disk_size += self.VDI.get_physical_utilisation(vbd_record['VDI']).to_i
+      end / (1024**3) # in GB
+    end
+
+    def hdd_size(vm_ref)
+      vbds(vm_ref).values.inject(0) do |disk_size, vbd_record|
+        disk_size += self.VDI.get_virtual_size(vbd_record['VDI']).to_i
+      end / (1024**3) # in GB
+    end
+
+    def vm_main_vif_ref(ref)
+      self.VM.get_VIFs(ref).find do |vif_ref|
+        self.VIF.get_device(vif_ref) == "0"
+      end
+    end
+
+    def vifs(ref)
+      vif_refs = self.VM.get_VIFs(ref)
+      vif_refs.inject({}) do |interfaces, vif_ref|
+        network_ref = self.VIF.get_network(vif_ref)
+        network_label = self.network.get_name_label(network_ref)
+        interfaces[vif_ref] = self.VIF.get_record(vif_ref).merge("network_label" => network_label)
+
+        interfaces
+      end
+    rescue
+      {}
+    end
+
+    def remove_disks_from_hypervisor(vm_ref)
+      vbds(vm_ref).each_value do |vbd_record|
+        self.VDI.destroy(vbd_record['VDI'])
+      end
+    end
+
+    def next_disk_number(vm_ref)
+      device_map = {}
+
+      vbds(vm_ref, :include_cd => true).each_pair do |vbd_ref, vbd_record|
+        userdevice = vbd_record["userdevice"].to_i
+        device_map[userdevice] = vbd_ref
+      end
+
+      disk_number = 0
+
+      device_map.size.times do
+        break if device_map[disk_number].nil?
+        disk_number +=1
+      end
+
+      disk_number
+    end
+
+    def cd_ref(vm_ref)
+      vbds(vm_ref, :include_cd => true).each_pair do |ref, record|
+        return ref if record["type"] == "CD"
+      end
+      nil
+    end
+
+    def insert_iso_cd(cd_ref, iso_ref)
+      self.VBD.set_bootable(cd_ref, false)
+      self.VBD.insert(cd_ref, iso_ref)
+      true
+    end
+
+    def master_address
+      pool_ref = self.pool.get_all.first
+      master_ref = self.pool.get_master pool_ref
+      self.host.get_address master_ref
+    end
+
+    def configure_network_interfaces_on(vm_ref)
+      vif_refs = self.VM.get_VIFs(vm_ref)
+      raise "Template doesn't have any network interfaces" if vif_refs.nil? || vif_refs.empty?
+      vif_record = self.VIF.get_record(vm_main_vif_ref(vm_ref))
+      vif_record["MAC"]
+    end
+
+    def exists_on_hypervisor?(uuid)
+      self.VM.get_by_uuid(uuid)
+      true
+    rescue XenAPI::Error
+      false
+    end
+
+    def set_memory_size(vm_ref, memory_in_MB)
+      memory_in_MB = memory_in_MB.to_s
+      self.VM.set_memory_limits(vm_ref, memory_in_MB, memory_in_MB, memory_in_MB, memory_in_MB)
+      self
+    end
+
+    def created_vifs(vm_ref)
+      vifs(vm_ref).to_a.inject({}) do |map, pair|
+        map[pair.last["network_label"]] = pair.first
+        map
+      end
+    end
+
+    def set_cpus_size(vm_ref, cpus)
+      cpus = cpus.to_s
+      max_cpus = self.VM.get_VCPUs_max(vm_ref).to_i
+
+      # On upgrade, we want set VCPUS max before VCPUS at startup and vice versa
+      if cpus.to_i > max_cpus
+        self.VM.set_VCPUs_max(vm_ref, cpus)
+        self.VM.set_VCPUs_at_startup(vm_ref, cpus)
+      else
+        self.VM.set_VCPUs_at_startup(vm_ref, cpus)
+        self.VM.set_VCPUs_max(vm_ref, cpus)
+      end
+
+      self
+    end
+
+    def adjust_vcpu_settings(vm_ref, new_settings)
+      parameters = self.VM.get_VCPUs_params(vm_ref)
+      parameters.merge!(new_settings)
+      self.VM.set_VCPUs_params(vm_ref, parameters)
+
+      self
+    end
+
+    def import(file_path, storage_uuid = nil)
+      file = File.open(file_path, "rb")
+
+      session_ref = self.key
+      storage_ref = storage_uuid ? self.SR.get_by_uuid(storage_uuid) : nil
+      task_ref = self.task.create "import vm #{file_path}", "importat job"
+
+      path = "/import?session_id=#{session_ref}&task_id=#{task_ref}"
+      path += "&sr_id=#{storage_ref}" if storage_ref
+
+      http = Net::HTTP.new(master_address, 80)
+      request = Net::HTTP::Put.new(path, {})
+      request.body_stream = file
+      request.content_length = file.size
+      begin
+        http.request(request)
+      rescue Errno::ECONNRESET
+        Rails.logger.warn "VM import did a connection reset, but does not indicate an error"
+      rescue Timeout::Error
+        error = "Could not import VM due to timeout error: check if your image is valid"
+        Rails.logger.error error
+        raise error
+      end
+
+      task_rec = self.task.get_record task_ref
+      vm_ref = task_rec["result"].gsub(/<.*?>/, "")
+      self.VM.get_uuid(vm_ref)
+    ensure
+      file.close rescue nil
+      self.task.destroy(task_ref) rescue nil
+    end
+
+    def export(vm_uuid, options = {})
+      options = {:to => "/tmp/export_file"}.merge(options)
+      file = File.open(options[:to], "wb")
+      session_ref = self.key
+      task_ref = self.task.create "export vm #{vm_uuid}", "export job"
+
+      path = "/export?session_id=#{session_ref}&task_id=#{task_ref}&ref=#{self.vm_ref(vm_uuid)}"
+      uri  = URI.parse "http://#{master_address}#{path}"
+
+      Net::HTTP.get_response(uri) do |res|
+        res.read_body {|chunk| file.write chunk }
+      end
+
+      options[:to]
+    ensure
+      file.close rescue nil
+      self.task.destroy(task_ref) rescue nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'xenapi-ruby'
+
+::OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:verify_mode] = ::OpenSSL::SSL::VERIFY_NONE
+
+# Requiring all support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include(Mock::XenAPIMockery)
+end

data/spec/support/xen_api_mockery.rb

@@ -0,0 +1,29 @@
+# -*- coding: UTF-8 -*-
+module Mock
+  module XenAPIMockery
+    def mock_session
+      SessionMock.new
+    end
+
+    def success_response
+      {'Status' => 'Success', 'Value' => ''}
+    end
+
+    class SessionMock
+      def initialize
+        @mocks = {}
+      end
+
+      def copy; end
+
+      def method_missing(name, *args)
+        unless @mocks.has_key?(name)
+          @mocks[name] = SessionMock.new
+          self.stub(name).and_return @mocks[name]
+        end
+
+        @mocks[name]
+      end
+    end
+  end
+end

data/spec/xenapi/dispatcher_spec.rb

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe XenAPI::Dispatcher do
+  FAKE_ERROR_MESSAGE = 'ERROR'
+  FAKE_ERROR_DETAIL = 'WRONG METHOD'
+
+  class FakeProxy
+    def initialize
+      @prefix = 'vm.'
+    end
+
+    def successful_call
+      {'Status' => 'Success', 'Value' => :success}
+    end
+
+    def unsuccessful_call
+      {'Status' => 'Failure', 'Value' => :failure, 'ErrorDescription' => [FAKE_ERROR_MESSAGE, FAKE_ERROR_DETAIL]}
+    end
+  end
+
+  subject { XenAPI::Dispatcher.new(FakeProxy.new) }
+
+  it "should forward any call to clone to method missing" do
+    subject.should_receive(:method_missing).with(:clone)
+    subject.clone
+  end
+  it "should forward any call to copy to method missing" do
+    subject.should_receive(:method_missing).with(:copy)
+    subject.copy
+  end
+
+  context "when sucessfully forwarding calls to the proxy" do
+    it "should return 'value' from the response hash" do
+      subject.successful_call.should == :success
+    end
+  end
+
+  context "when failing to forward calls to the proxy" do
+    it "should raise an error with the message returned by the result's 'ErrorDescription'" do
+      expect{ subject.unsuccessful_call }.to raise_error(Exception, "#{FAKE_ERROR_MESSAGE}: #{FAKE_ERROR_DETAIL}")
+    end
+
+    context "with a callback" do
+      before do
+        @dispatcher = subject.class.new(FakeProxy.new) do |error, &original_call|
+          rpc_proxy = mock(:rpc)
+          rpc_proxy.should_receive(:retry_method)
+          new_session = mock(:session)
+          new_session.should_receive(:send).with(:vm).and_return(rpc_proxy)
+          original_call.call(new_session)
+        end
+      end
+
+      it "should call the callback passed as a block to the initializer and not raise an error" do
+        @dispatcher.instance_variable_get(:@error_callback).should_receive(:call)
+        lambda{@dispatcher.unsuccessful_call}.should_not raise_error
+      end
+
+      it "should create a new session and retry to call the missing method on the new session proxy" do
+        @dispatcher.retry_method
+      end
+    end
+  end
+end

data/spec/xenapi/error_spec.rb

@@ -0,0 +1,85 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe XenAPI::Error do
+  context "when dealing with Xen API errors" do
+    it "should generate an XenAPI::AuthenticationError object for authentication error" do
+      error_description = "SESSION_AUTHENTICATION_FAILED"
+      error = XenAPI::ErrorFactory.create(*error_description)
+      error.should be_instance_of(XenAPI::AuthenticationError)
+    end
+
+    it "should generate an XenAPI::ConnectionError object for host still booting error" do
+      error_description = "HOST_STILL_BOOTING"
+      error = XenAPI::ErrorFactory.create(*error_description)
+      error.should be_instance_of(XenAPI::ConnectionError)
+    end
+
+    it "should generate an XenAPI::Error object for unknown error" do
+      error_description = "UNKNWON_STATE"
+      error = XenAPI::ErrorFactory.create(*error_description)
+      error.should be_instance_of(XenAPI::Error)
+    end
+
+    context "for not master error" do
+      before do
+        error_description = ["HOST_IS_SLAVE", "10.11.0.11"]
+        @error = XenAPI::ErrorFactory.create(*error_description)
+      end
+
+      it "should generate the right error" do
+        @error.should be_instance_of(XenAPI::NotMasterError)
+      end
+
+      it "should parse not master error message and return master ip" do
+        @error.master_ip.should == "10.11.0.11"
+      end
+    end
+  end
+
+  context "when selecting errors, it should generate a specific error message" do
+    it "for expiration error" do
+      expiration_error = EOFError.new "end of file reached"
+      error = XenAPI::ErrorFactory.wrap(expiration_error)
+      error.should be_instance_of(XenAPI::ExpirationError)
+    end
+
+    it "for timeout error" do
+      expiration_error = Timeout::Error.new "execution expired"
+      error = XenAPI::ErrorFactory.wrap(expiration_error)
+      error.should be_instance_of(XenAPI::TimeoutError)
+    end
+
+    it "for XenAPI::Error instance" do
+      xenapi_error = XenAPI::UnauthenticatedClient.new
+      error = XenAPI::ErrorFactory.wrap(xenapi_error)
+      error.should === xenapi_error
+    end
+
+    context "for connection error" do
+      it "when host is unreachable" do
+        connection_error = Errno::EHOSTUNREACH.new "No route to host"
+        error = XenAPI::ErrorFactory.wrap(connection_error)
+        error.should be_instance_of(XenAPI::ConnectionError)
+      end
+
+      it "when connection is refused" do
+        connection_error = Errno::ECONNREFUSED.new "Connection refused – connect(2)"
+        error = XenAPI::ErrorFactory.wrap(connection_error)
+        error.should be_instance_of(XenAPI::ConnectionError)
+      end
+
+      it "when there is a broken pipe" do
+        connection_error = Errno::EPIPE.new "Broken pipe"
+        error = XenAPI::ErrorFactory.wrap(connection_error)
+        error.should be_instance_of(XenAPI::ConnectionError)
+      end
+    end
+
+    it "for generic error" do
+      generic_error = RuntimeError.new "Generic Error"
+      error = XenAPI::ErrorFactory.wrap(generic_error)
+      error.should be_instance_of(XenAPI::Error)
+    end
+  end
+end

data/spec/xenapi/network_spec.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class A; include XenAPI::Network; end
+
+describe XenAPI::Network do
+  subject { A.new }
+
+  pending "Write real tests"
+
+  it "should contain the network_name_label method" do
+    subject.should respond_to(:task_create)
+  end
+end

data/spec/xenapi/session_spec.rb

@@ -0,0 +1,83 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe XenAPI::Session do
+  before(:all) do
+    @configs = YAML.load_file(File.dirname(__FILE__) + '/../../config/xenapi.yml')["xenapi"]
+  end
+
+  subject { XenAPI::Session.new(@configs["xenurl"]) }
+
+  it "should process method_missing only if client is already authenticated" do
+    expect{ subject.invalid_method }.to raise_error(XenAPI::UnauthenticatedClient)
+  end
+
+  context "when generating a proxy" do
+    it "should undefine its copy method"
+    it "should undefine its clone method"
+    it "should add a prefix method to it"
+  end
+
+  describe "without custom block" do
+    before do
+      subject.login_with_password(@configs["user"], @configs["password"])
+    end
+
+    after do
+      subject.close
+    end
+
+    it "should list VMs" do
+      response = subject.VM.get_all
+      response.should_not be_nil
+      response.should respond_to("[]", "each")
+      response.first.should =~ /^OpaqueRef:.*$/
+    end
+
+    it "should raise an error for invalid call by default" do
+      code_block = lambda {subject.VM.get_all("arg that makes test to raise an error")}
+      code_block.should raise_error(XenAPI::Error)
+    end
+
+    it "should raise an error if unable to login" do
+      lambda { subject.login_with_password('','') }.should raise_error
+    end
+  end
+
+  describe "with custom block" do
+    subject do
+      XenAPI::Session.new(@configs["xenurl"]) do |error, &called_method|
+        @called_method = called_method
+      end
+    end
+
+    before(:each) do
+      subject.login_with_password(@configs["user"], @configs["password"])
+    end
+
+    after(:each) do
+      subject.close
+    end
+
+    it "should not call block if no error happens" do
+      subject.VM.get_all
+      @called_method.should be_nil
+    end
+
+    it "should call block if any xen error happens" do
+      subject.VM.get_all("arg that makes test to raise an error")
+      @called_method.should be_a(Proc)
+    end
+  end
+
+  describe "when no xen api is up" do
+    it "should call block if can't connect" do
+      @session = XenAPI::Session.new("https://169.167.161.160") do |error|
+        @method_called = true
+      end
+
+      @session.login_with_password(@configs["user"], @configs["password"], 1)
+      @method_called.should be_true
+    end
+  end
+end

data/spec/xenapi/storage_spec.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class A; include XenAPI::Storage; end
+
+describe XenAPI::Storage do
+  subject { A.new }
+
+  it "should contain the storage_ref method" do
+    subject.should respond_to(:storage_ref)
+  end
+
+  it "should contain the storage_record_by_uuid method" do
+    subject.should respond_to(:storage_record_by_uuid)
+  end
+
+  it "should contain the storage_record method" do
+    subject.should respond_to(:storage_record)
+  end
+
+  it "should contain the storage_name method" do
+    subject.should respond_to(:storage_name)
+  end
+
+  it "should contain the all_storages method" do
+    subject.should respond_to(:all_storages)
+  end
+end

data/spec/xenapi/task_spec.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class A; include XenAPI::Task; end
+
+describe XenAPI::Task do
+  subject { A.new }
+
+  pending "Write real tests"
+
+  it "should contain the task_record method" do
+    subject.should respond_to(:task_record)
+  end
+
+  it "should contain the task_destroy method" do
+    subject.should respond_to(:task_destroy)
+  end
+
+  it "should contain the task_create method" do
+    subject.should respond_to(:task_create)
+  end
+end

data/spec/xenapi/vbd_spec.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class A; include XenAPI::Vbd; end
+
+describe XenAPI::Vbd do
+  subject { A.new }
+
+  it "should contain the create_for method" do
+    subject.should respond_to(:create_VBD_for)
+  end
+end

data/spec/xenapi/vdi_spec.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class A; include XenAPI::Vdi; end
+
+describe XenAPI::Vdi do
+  subject { A.new }
+
+  pending "Write real tests"
+
+  it "should contain the create_for method" do
+    subject.should respond_to(:create_VDI_for)
+  end
+
+  it "should contain the vdi_ref method" do
+    subject.should respond_to(:vdi_ref)
+  end
+
+  it "should contain the vdi_record method" do
+    subject.should respond_to(:vdi_record)
+  end
+
+  it "should contain the vdi_clone method" do
+    subject.should respond_to(:vdi_clone)
+  end
+
+  it "should contain the vdi_virtual_size method" do
+    subject.should respond_to(:vdi_virtual_size)
+  end
+
+  it "should contain the vdi_resize method" do
+    subject.should respond_to(:vdi_resize)
+  end
+
+  it "should contain the vdi_name_label method" do
+    subject.should respond_to(:vdi_name_label)
+  end
+
+  it "should contain the vdi_name_label= method" do
+    subject.should respond_to(:vdi_name_label=)
+  end
+
+  it "should contain the vdi_name_description= method" do
+    subject.should respond_to(:vdi_name_description=)
+  end
+end

data/spec/xenapi/virtual_machine_spec.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class A; include XenAPI::VirtualMachine; end
+
+describe XenAPI::VirtualMachine do
+  subject { A.new }
+
+  before { subject.stub(:VM).and_return(@hypervisor_session = mock) }
+
+  it "should call the xen clone method" do
+    @hypervisor_session.should_receive(:clone).with("OpaqueRef:...","TheName")
+    subject.vm_clone("OpaqueRef:...", "TheName")
+  end
+
+  it "should call the xen method to get the vm ref" do
+    @hypervisor_session.should_receive(:get_by_uuid).with("262a2a64-3128-9e1a-1f05-49dc7012bb2c")
+    subject.vm_ref("262a2a64-3128-9e1a-1f05-49dc7012bb2c")
+  end
+
+  it "should call the xen method to get the vm record" do
+    @hypervisor_session.should_receive(:get_record).with("OpaqueRef:...")
+    subject.vm_record("OpaqueRef:...")
+  end
+
+  it "should adjust the vcpu settings for a given hash" do
+    settings = {"weight" => "100", "cap" => "200"}
+    @hypervisor_session.stub(:get_VCPUs_params).and_return({})
+    @hypervisor_session.should_receive(:set_VCPUs_params).with(anything, settings)
+    subject.adjust_vcpu_settings("ref", settings)
+  end
+end

data/xenapi-ruby.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "xenapi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "xenapi-ruby"
+  s.version     = XenAPI::Version::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Cloud Team"]
+  s.email       = ["willian.molinari@locaweb.com.br"]
+  s.homepage    = "http://www.locaweb.com.br"
+  s.description = %Q{A simple gem to deal with Xen API}
+  s.summary     = s.description
+
+  s.files         = Dir["./**/*"].reject {|file| file =~ /\.git|pkg/}
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "ruby-debug19"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: xenapi-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.29
+  prerelease: 
+platform: ruby
+authors:
+- Cloud Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &19513640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19513640
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &19512980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19512980
+description: A simple gem to deal with Xen API
+email:
+- willian.molinari@locaweb.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./Gemfile.lock
+- ./VERSION
+- ./config/xenapi.yml
+- ./config/xenapi.yml.example
+- ./xenapi-ruby.gemspec
+- ./README.rdoc
+- ./LICENSE
+- ./spec/support/xen_api_mockery.rb
+- ./spec/spec_helper.rb
+- ./spec/xenapi/virtual_machine_spec.rb
+- ./spec/xenapi/network_spec.rb
+- ./spec/xenapi/dispatcher_spec.rb
+- ./spec/xenapi/task_spec.rb
+- ./spec/xenapi/storage_spec.rb
+- ./spec/xenapi/session_spec.rb
+- ./spec/xenapi/error_spec.rb
+- ./spec/xenapi/vbd_spec.rb
+- ./spec/xenapi/vdi_spec.rb
+- ./Gemfile
+- ./Rakefile
+- ./lib/xenapi.rb
+- ./lib/xenapi-ruby.rb
+- ./lib/xenapi/virtual_machine.rb
+- ./lib/xenapi/version.rb
+- ./lib/xenapi/hypervisor_connection.rb
+- ./lib/xenapi/dispatcher.rb
+- ./lib/xenapi/network.rb
+- ./lib/xenapi/error.rb
+- ./lib/xenapi/vbd.rb
+- ./lib/xenapi/task.rb
+- ./lib/xenapi/storage.rb
+- ./lib/xenapi/session.rb
+- ./lib/xenapi/vdi.rb
+homepage: http://www.locaweb.com.br
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: A simple gem to deal with Xen API
+test_files: []