knife-xapi 0.4.3 → 0.4.6

data/lib/chef/knife/xapi_base.rb

@@ -21,10 +21,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
 
 require 'chef/knife'
 require 'units/standard'
-require 'xenapi'
+
+require_relative '../../xenapi/xenapi.rb'
 
 class Chef::Knife
     module XapiBase
@@ -35,7 +44,7 @@ class Chef::Knife
       includer.class_eval do
 
         deps do
-          require 'xenapi'
+          require_relative '../../xenapi/xenapi.rb'
           require 'highline'
           require 'highline/import'
           require 'readline'
@@ -70,6 +79,11 @@ class Chef::Knife
           :default => false,
           :description => "Don't colorize the output"
 
+        option :xapi_ssl_verify,
+          :long => "--xapi-ssl-verify",
+          :default => false,
+          :description => "Enable SSL cert verification, Disabled by defaul because xenservers don't ship with proper certs"
+
       end
     end
 
@@ -100,7 +114,9 @@ class Chef::Knife
       @xapi ||= begin
 
         ui.fatal "Must provide a xapi host with --host "unless locate_config_value(:xapi_host)
-        session = XenApi::Client.new(  locate_config_value(:xapi_host) )
+        verify = :verify_none
+        verify = :verify_peer if locate_config_value(:xapi_ssl_verify) == true
+        session = XenApi::Client.new(  locate_config_value(:xapi_host), 10, verify )
 
         # get the password from the user
         password =  locate_config_value(:xapi_password) || nil
@@ -375,11 +391,11 @@ class Chef::Knife
 	  #detach_vdi
 	  def detach_vdi(vdi_ref)
 	    vbd_refs = xapi.VDI.get_VBDs(vdi_ref)
-     
+
       # more than one VBD, so we ned to find the vbd with the vdi
       ref = nil
       Chef::Log.debug "VBD Refs: #{vbd_refs.inspect}"
-      if vbd_refs.length > 1 
+      if vbd_refs.length > 1
         vbd_refs.each do |vbd|
           record = xapi.VBD.get_record vbd
           Chef::Log.debug "Checking VBD: #{vbd}, #{record["device"]}, #{record["VDI"]}==#{vdi_ref}"
@@ -388,7 +404,7 @@ class Chef::Knife
             break
           end
         end
-      else 
+      else
         # if only vbd use it
         ref = vbd_refs.first
       end
@@ -396,7 +412,7 @@ class Chef::Knife
       unless ref
         raise ArgumentError, "We weren't able to find a VBD for that VDI: #{vdi_ref}"
       end
-      
+
       task = xapi.Async.VBD.destroy(ref)
       ui.msg "Waiting for VDI detach"
       task_ref = get_task_ref(task)
@@ -405,7 +421,7 @@ class Chef::Knife
 	  def get_vbd_by_uuid(id)
 	    xapi.VBD.get_by_uuid(id)
 	  end
-     
+
     # try to get a guest ip and return it
     def get_guest_ip(vm_ref)
       guest_ip = "unknown"
@@ -440,7 +456,7 @@ class Chef::Knife
         color = [ :clear, :clear ]
       end
       ui.msg "#{h.color( key, color[0])} #{ h.color( value, color[1])}"
-    end 
+    end
 
     def print_vdi_info(vdi)
       record = xapi.VDI.get_record vdi
@@ -456,19 +472,19 @@ class Chef::Knife
         color_kv "    VM state: ",   "#{xapi.VM.get_power_state(vm) } \n"
       end
 
-      if record["VBDs"].length == 0 
+      if record["VBDs"].length == 0
         ui.msg h.color "  No VM Attached", :red
       end
-      
+
       ui.msg ""
     end
 
-    # return true (yes) false (no) 
+    # return true (yes) false (no)
     # to the asked question
     def yes_no?(msg)
       answer = ui.ask( "#{msg} yes/no ? " ) do |res|
         res.case = :down
-        res.validate = /y|n|yes|no/ 
+        res.validate = /y|n|yes|no/
         res.responses[:not_valid] = "Use 'yes', 'no', 'y', 'n':"
       end
 
@@ -482,7 +498,7 @@ class Chef::Knife
 
     def destroy_vdi(vdi_ref)
       vbds = get_vbds_from_vdi(vdi_ref)
-      unless vbds.empty? 
+      unless vbds.empty?
         detach_vdi(vdi_ref)
       end
       task = xapi.Async.VDI.destroy(vdi_ref)

data/lib/chef/knife/xapi_guest_create.rb

@@ -74,6 +74,11 @@ class Chef
         :description => "You can add more boot options to the vm e.g.: \"ks='http://foo.local/ks'\"",
         :proc => Proc.new { |key| Chef::Config[:knife][:kernel_params] = key }
 
+      option :xapi_skip_disk,
+        :long => "--xapi-skip-disk",
+        :proc =>  Proc.new { |key| Chef::Config[:knife][:xapi_skip_disk] = key },
+        :description => "Don't try to add disks to the new VM"
+
       option :xapi_disk_size,
         :short => "-D Size of disk. 1g 512m etc",
         :long  =>  "--xapi-disk-size",
@@ -256,6 +261,8 @@ class Chef
           # if no hostname param set hostname to given vm name
           boot_args << " hostname=#{server_name}" unless boot_args.match(/hostname=.+\s?/)
           # if domainname is supplied we put that in there as well
+          # ubuntu/debian wants domain rhat wants dnsdomain
+          boot_args << " domain=#{domainname}" unless boot_args.match(/domain=.+\s?/)
           boot_args << " dnsdomain=#{domainname}" unless boot_args.match(/dnsdomain=.+\s?/)
 
           xapi.VM.set_PV_args( vm_ref, boot_args )
@@ -270,40 +277,46 @@ class Chef
             end
           end
 
-          if locate_config_value(:xapi_sr)
-            sr_ref = get_sr_by_name( locate_config_value(:xapi_sr) )
-          else
-            sr_ref = find_default_sr
-          end
+          unless locate_config_value(:xapi_skip_disk)
+            sr_ref = nil
+            if locate_config_value(:xapi_sr)
+              sr_ref = get_sr_by_name( locate_config_value(:xapi_sr) )
+            else
+              sr_ref = find_default_sr
+            end
 
-          if sr_ref.nil?
-            ui.error "SR specified not found or can't be used Aborting"
-            fail(vm_ref) if sr_ref.nil?
-          end
-          Chef::Log.debug "SR: #{h.color sr_ref, :cyan}"
-        
-          # setup disks 
-          if locate_config_value(:xapi_disk_size)
-            # when a template already has disks, we decide the position number based on it. 
-	    	    position = xapi.VM.get_VBDs(vm_ref).length
-
-            # Create the VDI
-            vdi_ref = create_vdi("#{server_name}-root", sr_ref, locate_config_value(:xapi_disk_size) )
-            fail(vm_ref) unless vdi_ref
-
-            # Attach the VDI to the VM
-            # if its position is 0 set it bootable
-            vbd_ref = create_vbd(vm_ref, vdi_ref, position, position == 0)
-	          fail(vm_ref) unless vbd_ref
-          end
+            if sr_ref.nil?
+              ui.error "SR specified not found or can't be used Aborting"
+              fail(vm_ref) if sr_ref.nil?
+            end
+            Chef::Log.debug "SR: #{h.color sr_ref, :cyan}"
+       
 
+            disk_size = locate_config_value(:xapi_disk_size)
+            # setup disks 
+            if disk_size != nil and disk_size.to_i > 0
+              # when a template already has disks, we decide the position number based on it. 
+              position = xapi.VM.get_VBDs(vm_ref).length 
+
+              # Create the VDI
+              vdi_ref = create_vdi("#{server_name}-root", sr_ref, locate_config_value(:xapi_disk_size) )
+              fail(vm_ref) unless vdi_ref
+
+              # Attach the VDI to the VM
+              # if its position is 0 set it bootable
+              position == 0 ?  bootable=true : bootable=false
+
+              vbd_ref = create_vbd(vm_ref, vdi_ref, position, bootable)
+              fail(vm_ref) unless vbd_ref
+            end
+          end
 
           ui.msg "Provisioning new Guest: #{h.color(fqdn, :bold, :cyan )}"
           ui.msg "Boot Args: #{h.color boot_args,:bold, :cyan}"
           ui.msg "Install Repo: #{ h.color(repo,:bold, :cyan)}"
           ui.msg "Memory: #{ h.color( locate_config_value(:xapi_mem).to_s, :bold, :cyan)}"
           ui.msg "CPUs:   #{ h.color( locate_config_value(:xapi_cpus).to_s, :bold, :cyan)}"
-          ui.msg "Disk:   #{ h.color( locate_config_value(:xapi_disk_size).to_s, :bold, :cyan)}"
+          ui.msg "Disk:   #{ h.color( disk_size.to_s, :bold, :cyan)}"
           provisioned = xapi.VM.provision(vm_ref)
 
           ui.msg "Starting new Guest #{h.color( provisioned, :cyan)} "

data/lib/knife-xapi/version.rb

@@ -1,3 +1,3 @@
 module KnifeXenserver
-  VERSION = "0.4.3"
+  VERSION = "0.4.6"
 end

data/lib/xenapi/README

@@ -0,0 +1,3 @@
+I've decided to pull in xenapi with ssl support instead of using the external gem that still has no ssl verification options
+
+if the upstream does implemnt some version of this we can adjust

data/lib/xenapi/xen_api.rb

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

data/lib/xenapi/xenapi.rb

@@ -0,0 +1,47 @@
+module XenApi
+  autoload :Client,           File.expand_path('../xenapi/client',            __FILE__)
+  autoload :Errors,           File.expand_path('../xenapi/errors',            __FILE__)
+  autoload :Dispatcher,       File.expand_path('../xenapi/dispatcher',        __FILE__)
+  autoload :AsyncDispatcher,  File.expand_path('../xenapi/async_dispatcher',  __FILE__)
+  autoload :XMLRPCClient,     File.expand_path('../xenapi/xmlrpc_client',     __FILE__)
+
+  # Perform some action in a session context
+  #
+  # @param [String,Array] hosts
+  #   Host or hosts to try to connect to. Pass multiple URLs to allow to find
+  #   the pool master even if the originally designated host is not reachable.
+  # @param [String] username Username used for login
+  # @param [String] password Password used for login
+  # @param [Hash(Symbol => Boolean, String)] options
+  #   Additional options:
+  #     +:api_version+:: Force the usage of this API version if true
+  #     +:slave_login+:: Authenticate locally against a slave in emergency mode if true.
+  #     +:keep_session+:: Don't logout afterwards to keep the session usable if true
+  #     +:timeout+:: Maximum number of seconds to wait for an API response
+  #     +:ssl_verify+:: SSL certificate verification mode. Can be one of :verify_none or :verify_peer
+  # @yield client
+  # @yieldparam [Client] client Client instance
+  # @return [Object] block return value
+  # @raise [NoHostsAvailable] No hosts could be contacted
+  def self.connect(uris, username, password, options={})
+    uris = uris.respond_to?(:shift) ? uris.dup : [uris]
+    method = options[:slave_login] ? :slave_local_login_with_password : :login_with_password
+
+    client = Client.new(uris, options[:timeout] || 10, options[:ssl_verify] || :verify_peer)
+    begin
+      args = [method, username, password]
+      args << options[:api_version] if options.has_key?(:api_version)
+      client.send(*args)
+
+      if block_given?
+        return yield client
+      else
+        options[:keep_session] = true
+        return client
+      end
+    ensure
+      client.logout unless options[:keep_session] || client.xenapi_session.nil?
+    end
+  end
+end
+

data/lib/xenapi/xenapi/async_dispatcher.rb

@@ -0,0 +1,36 @@
+module XenApi #:nodoc:
+  # @private
+  # This class helps to provide the ability for the +XenApi::Client+
+  # to accept +async+ method calls. Calls are similar to synchronous
+  # method calls except that the names are prefixed with 'Async'.
+  #
+  #   client = XenApi::Client.new('http://xenapi.test/')
+  #   client.async            #=> AsyncDispatcher instance
+  #   client.async.VM         #=> Dispatcher instance for 'Async.VM'
+  #   client.async.VM.start() #=> Performs XMLRPC 'Async.VM.start' call
+  #
+  # further calls on instances of this object will create a +Dispatcher+
+  # instance which then handle actual method calls.
+  class AsyncDispatcher
+    # @param [Client] client XenApi::Client instance
+    # @param [Symbol] sender XenApi::Client method to call when prefix method is invoked
+    def initialize(client, sender)
+      @client = client
+      @sender = sender
+    end
+
+    # @see Object#inspect
+    def inspect
+      "#<#{self.class}>"
+    end
+
+    # Create a new +Dispatcher+ instance to handle the +Async.meth+ prefix.
+    #
+    # @param [String,Symbol] meth Method prefix name
+    # @param [...] args Method arguments
+    # @return [Dispatcher] dispatcher instance to handle the +Async.meth+ prefix
+    def method_missing(meth, *args)
+      Dispatcher.new(@client, "Async.#{meth}", @sender)
+    end
+  end  
+end

data/lib/xenapi/xenapi/client.rb

@@ -0,0 +1,382 @@
+require 'uri'
+require 'xmlrpc/client'
+
+module XenApi #:nodoc:
+  # This class permits the invocation of XMLRPC API calls
+  # through a ruby-like interface
+  #
+  #   client = XenApi::Client.new('http://xenapi.test')
+  #   client.login_with_password('root', 'password')
+  #   client.VM.get_all
+  #
+  # == Authenticating with the API
+  # Authentication with the API takes place through the API
+  # +session+ class, usually using the +login_with_password+
+  # method. The +Client+ handles this method specially to
+  # enable it to retain the session identifier to pass to
+  # invoked methods and perform reauthentication should the
+  # session become stale.
+  #
+  #   client = XenApi::Client.new('http://xenapi.test')
+  #   client.login_with_password('root', 'password')
+  #
+  # It is worth noting that only +login*+ matching methods
+  # are specially passed through to the +session+ class.
+  #
+  # == Running code after API login
+  # The +Client+ provides the ability for running code
+  # after the client has successfully authenticated with
+  # the API. This is useful for either logging authentication
+  # or for registering for certain information from the API.
+  #
+  # The best example of this is when needing to make use of
+  # the Xen API +event+ class for asynchronous event handling.
+  # To use the API +event+ class you first have to register
+  # your interest in a specific set of event types.
+  #
+  #   client = XenApi::Client.new('http://xenapi.test')
+  #   client.after_login do |c|
+  #     c.event.register %w(vm) # register for 'vm' events
+  #   end
+  #
+  # == Asynchronous Methods
+  # To call asynchronous methods on the Xen XMLRPC API you
+  # first call +Async+ on the +Client+ instance followed by
+  # the normal method name.
+  # For example:
+  #
+  #   client = XenApi::Client.new('http://xenapi.test')
+  #   client.login_with_password('root', 'password')
+  #
+  #   vm_ref = client.VM.get_by_name_label('my vm')
+  #   task = client.Async.VM.clone(vm_ref)
+  #   while client.Task.get_status(task) == "pending":
+  #        progress = client.Task.get_progress(task)
+  #        update_progress_bar(progress)
+  #        time.sleep(1)
+  #   client.Task.destroy(task)
+  #
+  # Calling either +Async+ or +async+ will work as the
+  # capitalised form will always be sent when calling
+  # a method asynchronously.
+  #
+  # Note that only some methods are available in an asynchronous variant.
+  # An XMLRPC::FaultException is thrown if you try to call a method
+  # asynchrounously that is not available.
+  class Client
+    # The +LoginRequired+ exception is raised when
+    # an API request requires login and no login
+    # credentials have yet been provided.
+    #
+    # If you don't perform a login before receiving this
+    # exception then you will want to catch it, log into
+    # the API and then retry your request.
+    class LoginRequired < RuntimeError; end
+
+    # The +SessionInvalid+ exception is raised when the
+    # API session has become stale or is otherwise invalid.
+    #
+    # Internally this exception will be handled a number of
+    # times before being raised up to the calling code.
+    class SessionInvalid < RuntimeError; end
+
+    # The +ResponseMissingStatusField+ exception is raised
+    # when the XMLRPC response is missing the +Status+ field.
+    # This typically indicates an unrecoverable error with
+    # the API itself.
+    class ResponseMissingStatusField < RuntimeError; end
+
+    # The +ResponseMissingValueField+ exception is raised
+    # when the XMLRPC response is missing the +Value+ field.
+    # This typically indicates an unrecoverable error with
+    # the API itself.
+    class ResponseMissingValueField < RuntimeError; end
+
+    # The +ResponseMissingErrorDescriptionField+ exception
+    # is raised when an error is returned in the XMLRPC
+    # response, but the type of error cannot be determined
+    # due to the lack of the +ErrorDescription+ field.
+    class ResponseMissingErrorDescriptionField < RuntimeError; end
+
+    # @see Object#inspect
+    def inspect
+      "#<#{self.class} #{@uri}>"
+    end
+
+    # @param [String,Array] uri URL to the Xen API endpoint
+    # @param [Integer] timeout Maximum number of seconds to wait for an API response
+    # @param [Symbol] ssl_verify SSL certificate verification mode.
+    #   Can be one of :verify_none or :verify_peer
+    def initialize(uris, timeout=10, ssl_verify=:verify_peer)
+      @timeout = timeout
+      @ssl_verify = ssl_verify
+      @uris = [uris].flatten.collect do |uri|
+        uri = URI.parse(uri)
+        uri.path = '/' if uri.path == ''
+        uri
+      end.uniq
+      @uri = @uris.first
+    end
+
+    attr_reader :uri, :uris
+
+    # @overload after_login
+    #   Adds a block to be called after successful login to the XenAPI.
+    #   @note The block will be called whenever the receiver has to authenticate
+    #     with the XenAPI. This includes the first time the receiver recieves a
+    #     +login_*+ method call and any time the session becomes invalid.
+    #   @yield client
+    #   @yieldparam [optional, Client] client Client instance
+    # @overload after_login
+    #   Calls the created block, this is primarily for internal use only
+    # @return [Client] receiver
+    def after_login(&block)
+      if block
+        @after_login = block
+      elsif @after_login
+        case @after_login.arity
+        when 1
+          @after_login.call(self)
+        else
+          @after_login.call
+        end
+      end
+      self
+    end
+
+    # @overload before_reconnect
+    #   Adds a block to be called before an attempted reconnect to another server.
+    #   @note The block will be called whenever the receiver has to chose a
+    #     new server because the current connection got invalid.
+    #   @yield client
+    #   @yieldparam [optional, Client] client Client instance
+    # @overload before_reconnect
+    #   Calls the created block, this is primarily for internal use only
+    # @return [Client] receiver
+    def before_reconnect(&block)
+      if block
+        @before_reconnect = block
+      elsif @before_reconnect
+        case @before_reconnect.arity
+        when 1
+          @before_reconnect.call(self)
+        else
+          @before_reconnect.call
+        end
+      end
+      self
+    end
+
+    # Returns the current session identifier.
+    #
+    # @return [String] session identifier
+    def xenapi_session
+      @session
+    end
+
+    # Returns the current API version
+    #
+    # @return [String] API version
+    def api_version
+      @api_version ||= begin
+        pool = self.pool.get_all()[0]
+        host = self.pool.get_master(pool)
+        major = self.host.get_API_version_major(host)
+        minor = self.host.get_API_version_minor(host)
+        "#{major}.#{minor}"
+      end
+    end
+
+    # Handle API method calls.
+    #
+    # If the method called starts with +login+ then the method is
+    # assumed to be part of the +session+ namespace and will be
+    # called directly. For example +login_with_password+
+    #
+    #   client = XenApi::Client.new('http://xenapi.test/')
+    #   client.login_with_password('root', 'password)
+    #
+    # If the method called is +async+ then an +AsyncDispatcher+
+    # will be created to handle the asynchronous API method call.
+    #
+    #   client = XenApi::Client.new('http://xenapi.test/')
+    #   client.async.host.get_servertime(ref)
+    #
+    # The final case will create a +Dispatcher+ to handle the
+    # subsequent method call such as.
+    #
+    #   client = XenApi::Client.new('http://xenapi.test/')
+    #   client.host.get_servertime(ref)
+    #
+    # @note +meth+ names are not validated
+    #
+    # @param [String,Symbol] meth Method name
+    # @param [...] args Method args
+    # @return [true,AsyncDispatcher,Dispatcher]
+    def method_missing(meth, *args)
+      case meth.to_s
+      when /^(slave_local_)?login/
+        _login(meth, *args)
+      when /^async/i
+        AsyncDispatcher.new(self, :_call)
+      else
+        Dispatcher.new(self, meth, :_call)
+      end
+    end
+
+    # Logout and destroy the current session. After calling logout, the
+    # object state is invalid. No API calls can be performed unless one of
+    # the login methods is called again.
+    def logout
+      begin
+        if @login_meth.to_s.start_with? "slave_local"
+          _do_call("session.local_logout", [@session])
+        else
+          _do_call("session.logout", [@session])
+        end
+      rescue
+        # We don't care about any error. If it works: great, if not: shit happens...
+        nil
+      ensure
+        @session = ""
+        @login_meth = nil
+        @login_args = []
+        @api_version = nil
+      end
+    end
+
+  protected
+    # @param [String,Symbol] meth API method to call
+    # @param [Array] args Arguments to pass to the method call
+    # @raise [SessionInvalid] Reauthentication failed
+    # @raise [LoginRequired] Authentication required, unable to login automatically
+    # @raise [EOFError] XMLRPC::Client exception
+    # @raise [Errno::EPIPE] XMLRPC::Client exception
+    def _call(meth, *args)
+      begin
+        _do_call(meth, args.dup.unshift(@session))
+      rescue SessionInvalid
+        _relogin_attempts = (_relogin_attempts || 0) + 1
+        _relogin
+        retry unless _relogin_attempts > 2
+        _reconnect ? retry : raise
+      rescue Timeout::Error
+        _timeout_retries = (_timeout_retries || 0) + 1
+        @client = nil
+        retry unless _timeout_retries > 1
+        _reconnect ? retry : raise
+      rescue EOFError
+        _eof_retries = (_eof_retries || 0) + 1
+        @client = nil
+        retry unless _eof_retries > 1
+        _reconnect ? retry : raise
+      rescue Errno::EPIPE
+        _epipe_retries = (_epipe_retries || 0) + 1
+        @client = nil
+        retry unless _epipe_retries > 1
+        _reconnect ? retry : raise
+      rescue Errno::EHOSTUNREACH
+        @client = nil
+        _reconnect ? retry : raise
+      end
+    end
+
+  private
+    # Reauthenticate with the API
+    # @raise [LoginRequired] Missing authentication credentials
+    def _relogin
+      raise LoginRequired if @login_meth.nil? || @login_args.nil? || @login_args.empty?
+      _login(@login_meth, *@login_args)
+    end
+
+    # Try to reconnect to another available server in the same pool
+    #
+    # @note Will call the +before_reconnect+ block before trying to reconnect
+    #
+    # @raise [Errors::NoHostsAvailable] No further hosts available to connect to
+    # @raise [LoginRequired] Missing authentication credentials
+    def _reconnect
+      return false if @i_am_reconnecting
+
+      @i_am_reconnecting = true
+      failed_uris = [@uri]
+      while (available_uris = (@uris - failed_uris)).count > 0
+        @uri = available_uris[0]
+        @client = nil
+
+        begin
+          before_reconnect
+          _relogin
+          @i_am_reconnecting = false
+          return true
+        rescue LoginRequired
+          raise
+        rescue
+          failed_uris << @uri
+        end
+      end
+      raise Errors::NoHostsAvailable.new("No server reachable. Giving up.")
+    end
+
+    # Login to the API
+    #
+    # @note Will call the +after_login+ block if login is successful
+    #
+    # @param [String,Symbol] meth Login method name
+    # @param [...] args Arguments to pass to the login method
+    # @return [Boolean] true
+    # @raise [Exception] any exception raised by +_do_call+ or +after_login+
+    def _login(meth, *args)
+      begin
+        @session = _do_call("session.#{meth}", args)
+      rescue Errors::HostIsSlave => e
+        @uri = @uri.dup
+        @uri.host = e.description[0]
+        @uris.unshift(@uri).uniq!
+        @client = nil
+        retry
+      end
+
+      @login_meth = meth
+      @login_args = args
+      after_login
+      true
+    end
+
+    # Return or initialize new +XMLRPC::Client+
+    #
+    # @return [XMLRPC::Client] XMLRPC client instance
+    def _client
+      @client ||= XMLRPCClient.new(@uri.host, @uri.path, @uri.port, nil, nil, nil, nil, @uri.scheme == "https" ? @ssl_verify : false, @timeout)
+    end
+
+    # Perform XMLRPC method call.
+    #
+    # @param [String,Symbol] meth XMLRPC method to call
+    # @param [Array] args XMLRPC method arguments
+    # @param [Integer] attempts Number of times to retry the call, presently unused
+    # @return [Object] method return value
+    # @raise [ResponseMissingStatusField] XMLRPC response does not have a +Status+ field
+    # @raise [ResponseMissingValueField] XMLRPC response does not have a +Value+ field
+    # @raise [ResponseMissingErrorDescriptionField] API response error missing +ErrorDescription+ field
+    # @raise [SessionInvalid] API session has expired
+    # @raise [Errors::GenericError] API method specific error
+    def _do_call(meth, args, attempts = 3)
+      r = _client.call(meth, *args)
+      raise ResponseMissingStatusField unless r.has_key?('Status')
+
+      if r['Status'] == 'Success'
+        return r['Value'] if r.has_key?('Value')
+        raise ResponseMissingValueField
+      else
+        raise ResponseMissingErrorDescriptionField unless r.has_key?('ErrorDescription')
+        raise SessionInvalid if r['ErrorDescription'][0] == 'SESSION_INVALID'
+
+        ed = r['ErrorDescription'].shift
+        ex = Errors.exception_class_from_desc(ed)
+        r['ErrorDescription'].unshift(ed) if ex == Errors::GenericError
+        raise ex, r['ErrorDescription']
+      end
+    end
+  end
+end

data/lib/xenapi/xenapi/dispatcher.rb

@@ -0,0 +1,48 @@
+module XenApi #:nodoc:
+  # @private
+  # This class helps to provide XMLRPC method dispatching.
+  #
+  # Calls made to the top level +XenApi::Client+ instance
+  # will generate instances of this class to provide scoping
+  # of methods by their prefix. All Xen API method calls are
+  # two level, the first level specifies a namespace or prefix
+  # for the second level method call. Taking +VM.start+ as
+  # an example, +VM+ is the namespace prefix and +start+ is
+  # the method name.
+  #
+  # Calling Xen API XMLRPC methods therefore consists of
+  # first creating a +Dispatcher+ instance with the prefix
+  # name and then calling a method on the +Dispatcher+
+  # instance to create the XMLRPC method name to be called
+  # by the +XenApi::Client+ instance.
+  #
+  #   client = XenApi::Client.new('http://xenapi.test/')
+  #   client.VM             #=> Dispatcher instance for 'VM'
+  #   client.VM.start()     #=> Performs XMLRPC 'VM.start' call
+  class Dispatcher
+    undef :clone  # to allow for VM.clone calls
+
+    # @param [Client] client XenApi::Client instance
+    # @param [String] prefix Method prefix name
+    # @param [Symbol] sender XenApi::Client method to call when prefix method is invoked
+    def initialize(client, prefix, sender)
+      @client = client
+      @prefix = prefix
+      @sender = sender
+    end
+
+    # @see Object#inspect
+    def inspect
+      "#<#{self.class} #{@prefix}>"
+    end
+
+    # Calls a method on +XenApi::Client+ to perform the XMLRPC method
+    #
+    # @param [String,Symbol] meth Method name to be combined with the receivers +prefix+
+    # @param [...] args Method arguments
+    # @return [Object] XMLRPC response value
+    def method_missing(meth, *args)
+      @client.send(@sender, "#{@prefix}.#{meth}", *args)
+    end
+  end
+end

data/lib/xenapi/xenapi/errors.rb

@@ -0,0 +1,469 @@
+module XenApi #:nodoc:
+  module Errors #:nodoc:
+    # Generic errror case, all XenApi exceptions inherit from this for ease of catching
+    class GenericError < RuntimeError;
+      # The raw error description according to the server, typically an array
+      attr_reader :description
+
+      def initialize(*args, &block)
+        @description = args[0]
+        args[0] = args[0].inspect unless args[0].is_a? String || args[0].nil?
+        super(*args, &block)
+      end
+    end
+
+    # The bootloader returned an error.
+    #
+    # Raised by
+    # - VM.start
+    # - VM.start_on
+    class BootloaderFailed < GenericError; end
+
+    # The device is not currently attached
+    #
+    # Raised by
+    # - VBD.unplug
+    class DeviceAlreadyDetached < GenericError; end
+
+    # The VM rejected the attempt to detach the device.
+    #
+    # Raised by
+    # - VBD.unplug
+    class DeviceDetachRejected < GenericError; end
+
+    # Some events have been lost from the queue and cannot be retrieved.
+    #
+    # Raised by
+    # - event.next
+    class EventsLost < GenericError; end
+
+    # This operation cannot be performed because it would invalidate VM
+    # failover planning such that the system would be unable to guarantee
+    # to restart protected VMs after a Host failure.
+    #
+    # Raised by
+    # - VM.set_memory_static_max
+    class HAOperationWouldBreakFailoverPlan < GenericError; end
+
+    # The host can not be used as it is not the pool master. The data
+    # contains the location of the current designated pool master.
+    #
+    # Raised by
+    # - sesssion.login_with_password
+    class HostIsSlave < GenericError; end
+
+    # The host name is invalid
+    #
+    # Raised by
+    # - host.set_hostname_live
+    class HostNameInvalid < GenericError; end
+
+    # Not enough host memory is available to perform this operation
+    #
+    # Raised by
+    # - VM.assert_can_boot_here
+    class HostNotEnoughFreeMemory < GenericError; end
+
+    # You tried to create a VLAN or tunnel on top of a tunnel access
+    # PIF - use the underlying transport PIF instead.
+    #
+    # Raised by
+    # - tunnel.create
+    class IsTunnelAccessPIF < GenericError; end
+
+    # The host joining the pool cannot contain any shared storage.
+    #
+    # Raised by
+    # - pool.join
+    class JoiningHostCannotContainSharedSRs < GenericError; end
+
+    # This operation is not allowed under your license.
+    # Please contact your support representative.
+    #
+    # Raised by
+    # - VM.start
+    class LicenceRestriction < GenericError; end
+
+    # There was an error processing your license. Please contact
+    # your support representative.
+    #
+    # Raised by
+    # - host.license_apply
+    class LicenseProcessingError < GenericError; end
+
+    # There were no hosts available to complete the specified operation.
+    #
+    # Raised by
+    # - VM.start
+    class NoHostsAvailable < GenericError; end
+
+    # This operation needs the OpenVSwitch networking backend to be
+    # enabled on all hosts in the pool.
+    #
+    # Raised by
+    # - tunnel.create
+    class OpenvswitchNotActive < GenericError; end
+
+    # You attempted an operation that was not allowed.
+    #
+    # Raised by
+    # - task.cancel
+    # - VM.checkpoint
+    # - VM.clean_reboot
+    # - VM.clean_shutdown
+    # - VM.clone
+    # - VM.copy
+    # - VM.hard_reboot
+    # - VM.hard_shutdown
+    # - VM.pause
+    # - VM.pool_migrate
+    # - VM.provision
+    # - VM.resume
+    # - VM.resume_on
+    # - VM.revert
+    # - VM.snapshot
+    # - VM.snapshot_with_quiesce
+    # - VM.start
+    # - VM.start_on
+    # - VM.suspend
+    # - VM.unpause
+    class OperationNotAllowed < GenericError; end
+
+    # Another operation involving the object is currently in progress
+    #
+    # Raised by
+    # - VM.clean_reboot
+    # - VM.clean_shutdown
+    # - VM.hard_reboot
+    # - VM.hard_shutdown
+    # - VM.pause
+    # - VM.pool_migrate
+    # - VM.start
+    # - VM.start_on
+    # - VM.suspend
+    class OtherOperationInProgress < GenericError; end
+
+    # You tried to destroy a PIF, but it represents an aspect of the physical
+    # host configuration, and so cannot be destroyed. The parameter echoes the
+    # PIF handle you gave.
+    #
+    # Raised by
+    # - PIF.destroy
+    # @deprecated the PIF.destroy method is deprecated in XenServer 4.1 and replaced
+    # by VLAN.destroy and Bond.destroy
+    class PIFIsPhysical < GenericError; end
+
+    # Operation cannot proceed while a tunnel exists on this interface.
+    #
+    # Raised by
+    # - PIF.forget
+    class PIFTunnelStillExists < GenericError; end
+
+    # The credentials given by the user are incorrect, so access has been
+    # denied, and you have not been issued a session handle.
+    #
+    # Raised by
+    # - session.login_with_password
+    class SessionAuthenticationFailed < GenericError; end
+
+    # This session is not registered to receive events. You must call
+    # event.register before event.next. The session handle you are
+    # using is echoed.
+    #
+    # Raised by
+    # - event.next
+    class SessionNotRegistered < GenericError; end
+
+    # The SR is full. Requested new size exceeds the maximum size
+    #
+    # Raised by
+    # - VM.checkpoint
+    # - VM.clone
+    # - VM.copy
+    # - VM.provision
+    # - VM.revert
+    # - VM.snapshot
+    # - VM.snapshot_with_quiesce
+    class SRFull < GenericError; end
+
+    # The SR is still connected to a host via a PBD. It cannot be destroyed.
+    #
+    # Raised by
+    # - SR.destroy
+    # - SR.forget
+    class SRHasPDB < GenericError; end
+
+    # The SR backend does not support the operation (check the SR's allowed operations)
+    #
+    # Raised by
+    # - VDI.introduce
+    # - VDI.update
+    class SROperationNotSupported < GenericError; end
+
+    # The SR could not be connected because the driver was not recognised.
+    #
+    # Raised by
+    # - PBD.plug
+    # - SR.create
+    class SRUnknownDriver < GenericError; end
+
+    # The tunnel transport PIF has no IP configuration set.
+    #
+    # Raised by
+    # - PIF.plug
+    # - tunnel.create
+    class TransportPIFNotConfigured < GenericError; end
+
+    # The requested bootloader is unknown
+    #
+    # Raised by
+    # - VM.start
+    # - VM.start_on
+    class UnknownBootloader < GenericError; end
+
+    # Operation could not be performed because the drive is empty
+    #
+    # Raised by
+    # - VBD.eject
+    class VBDIsEmpty < GenericError; end
+
+    # Operation could not be performed because the drive is not empty
+    #
+    # Raised by
+    # - VBD.insert
+    class VBDNotEmpty < GenericError; end
+
+    # Media could not be ejected because it is not removable
+    #
+    # Raised by
+    # - VBD.eject
+    # - VBD.insert
+    class VBDNotRemovableMedia < GenericError; end
+
+    # You tried to create a VLAN, but the tag you gave was invalid --
+    # it must be between 0 and 4094. The parameter echoes the VLAN tag you gave.
+    #
+    # Raised by
+    # - PIF.create_VLAN (deprecated)
+    # - pool.create_VLAN (deprecated)
+    # - pool.create_VLAN_from_PIF
+    class VlanTagInvalid < GenericError; end
+
+    # You attempted an operation on a VM that was not in an appropriate
+    # power state at the time; for example, you attempted to start a VM
+    # that was already running. The parameters returned are the VM's
+    # handle, and the expected and actual VM state at the time of the call.
+    #
+    # Raised by
+    # - VM.checkpoint
+    # - VM.clean_reboot
+    # - VM.clean_shutdown
+    # - VM.checkpoint
+    # - VM.clean_reboot
+    # - VM.clean_shutdown
+    # - VM.clone
+    # - VM.copy
+    # - VM.hard_reboot
+    # - VM.hard_shutdown
+    # - VM.pause
+    # - VM.pool_migrate
+    # - VM.provision
+    # - VM.resume
+    # - VM.resume_on
+    # - VM.revert
+    # - VM.send_sysrq
+    # - VM.send_trigger
+    # - VM.snapshot
+    # - VM.snapshot_with_quiesce
+    # - VM.start
+    # - VM.start_on
+    # - VM.suspend
+    # - VM.unpause
+    class VMBadPowerState < GenericError; end
+
+    # An error occured while restoring the memory image of the
+    # specified virtual machine
+    #
+    # Raised by
+    # - VM.checkpoint
+    class VMCheckpointResumeFailed < GenericError; end
+
+    # An error occured while saving the memory image of the
+    # specified virtual machine
+    #
+    # Raised by
+    # - VM.checkpoint
+    class VMCheckpointSuspendFailed < GenericError; end
+
+    # HVM is required for this operation
+    #
+    # Raised by
+    # - VM.start
+    class VMHvmRequired < GenericError; end
+
+    # The operation attempted is not valid for a template VM
+    #
+    # Raised by
+    # - VM.clean_reboot
+    # - VM.clean_shutdown
+    # - VM.hard_reboot
+    # - VM.hard_shutdown
+    # - VM.pause
+    # - VM.pool_migrate
+    # - VM.resume
+    # - VM.resume_on
+    # - VM.start
+    # - VM.start_on
+    # - VM.suspend
+    # - VM.unpause
+    class VMIsTemplate < GenericError; end
+
+    # An error occurred during the migration process.
+    #
+    # Raised by
+    # - VM.pool_migrate
+    class VMMigrateFailed < GenericError; end
+
+    # You attempted an operation on a VM which requires PV drivers
+    # to be installed but the drivers were not detected.
+    #
+    # Raised by
+    # -VM.pool_migrate
+    class VMMissingPVDrivers < GenericError; end
+
+    # You attempted to run a VM on a host which doesn't have access to an SR
+    # needed by the VM. The VM has at least one VBD attached to a VDI in the SR
+    #
+    # Raised by
+    # - VM.assert_can_boot_here
+    class VMRequiresSR < GenericError; end
+
+    # An error occured while reverting the specified virtual machine
+    # to the specified snapshot
+    #
+    # Raised by
+    # - VM.revert
+    class VMRevertFailed < GenericError; end
+
+    # The quiesced-snapshot operation failed for an unexpected reason
+    #
+    # Raised by
+    # - VM.snapshot_with_quiesce
+    class VMSnapshotWithQuiesceFailed < GenericError; end
+
+    # The VSS plug-in is not installed on this virtual machine
+    #
+    # Raised by
+    # - VM.snapshot_with_quiesce
+    class VMSnapshotWithQuiesceNotSupported < GenericError; end
+
+    # The VSS plug-in cannot be contacted
+    #
+    # Raised by
+    # - VM.snapshot_with_quiesce
+    class VMSnapshotWithQuiescePluginDoesNotRespond < GenericError; end
+
+    # The VSS plug-in has timed out
+    #
+    # Raised by
+    # - VM.snapshot_with_quiesce
+    class VMSnapshotWithQuiesceTimeout < GenericError; end
+
+    # Returns the class for the exception appropriate for the error description given
+    #
+    # @param [String] desc ErrorDescription value from the API
+    # @return [Class] Appropriate exception class for the given description
+    def self.exception_class_from_desc(desc)
+      case desc
+      when 'BOOTLOADER_FAILED'
+        BootloaderFailed
+      when 'DEVICE_ALREADY_DETACHED'
+        DeviceAlreadyDetached
+      when 'DEVICE_DETACH_REJECTED'
+        DeviceDetachRejected
+      when 'EVENTS_LOST'
+        EventsLost
+      when 'HA_OPERATION_WOULD_BREAK_FAILOVER_PLAN'
+        HAOperationWouldBreakFailoverPlan
+      when 'HOST_IS_SLAVE'
+        HostIsSlave
+      when 'HOST_NAME_INVALID'
+        HostNameInvalid
+      when 'HOST_NOT_ENOUGH_FREE_MEMORY'
+        HostNotEnoughFreeMemory
+      when 'IS_TUNNEL_ACCESS_PIF'
+        IsTunnelAccessPIF
+      when 'JOINING_HOST_CANNOT_CONTAIN_SHARED_SRS'
+        JoiningHostCannotContainSharedSRs
+      when 'LICENCE_RESTRICTION'
+        LicenceRestriction
+      when 'LICENSE_PROCESSING_ERROR'
+        LicenseProcessingError
+      when 'NO_HOSTS_AVAILABLE'
+        NoHostsAvailable
+      when 'OPENVSWITCH_NOT_ACTIVE'
+        OpenvswitchNotActive
+      when 'OPERATION_NOT_ALLOWED'
+        OperationNotAllowed
+      when 'OTHER_OPERATION_IN_PROGRESS'
+        OtherOperationInProgress
+      when 'PIF_IS_PHYSICAL'
+        PIFIsPhysical
+      when 'PIF_TUNNEL_STILL_EXISTS'
+        PIFTunnelStillExists
+      when 'SESSION_AUTHENTICATION_FAILED'
+        SessionAuthenticationFailed
+      when 'SESSION_NOT_REGISTERED'
+        SessionNotRegistered
+      when 'SR_FULL'
+        SRFull
+      when 'SR_HAS_PDB'
+        SRHasPDB
+      when 'SR_OPERATION_NOT_SUPPORTED'
+        SROperationNotSupported
+      when 'SR_UNKNOWN_DRIVER'
+        SRUnknownDriver
+      when 'TRANSPORT_PIF_NOT_CONFIGURED'
+        TransportPIFNotConfigured
+      when 'UNKNOWN_BOOTLOADER'
+        UnknownBootloader
+      when 'VBD_IS_EMPTY'
+        VBDIsEmpty
+      when 'VBD_NOT_EMPTY'
+        VBDNotEmpty
+      when 'VBD_NOT_REMOVABLE_MEDIA'
+        VBDNotRemovableMedia
+      when 'VLAN_TAG_INVALID'
+        VlanTagInvalid
+      when 'VM_BAD_POWER_STATE'
+        VMBadPowerState
+      when 'VM_CHECKPOINT_RESUME_FAILED'
+        VMCheckpointResumeFailed
+      when 'VM_CHECKPOINT_SUSPEND_FAILED'
+        VMCheckpointSuspendFailed
+      when 'VM_HVM_REQUIRED'
+        VMHVMRequired
+      when 'VM_IS_TEMPLATE'
+        VMIsTemplate
+      when 'VM_MIGRATE_FAILED'
+        VMMigrateFailed
+      when 'VM_MISSING_PV_DRIVERS'
+        VMMissingPVDrivers
+      when 'VM_REQUIRES_SR'
+        VMRequiresSR
+      when 'VM_REVERT_FAILED'
+        VMRevertFailed
+      when 'VM_SNAPSHOT_WITH_QUIESCE_FAILED'
+        VMSnapshotWithQuiesceFailed
+      when 'VM_SNAPSHOT_WITH_QUIESCE_NOT_SUPPORTED'
+        VMSnapshotWithQuiesceNotSupported
+      when 'VM_SNAPSHOT_WITH_QUIESCE_PLUGIN_DOES_NOT_RESPOND'
+        VMSnapshotWithQuiescePluginDoesNotRespond
+      when 'VM_SNAPSHOT_WITH_QUIESCE_TIMEOUT'
+        VMSnapshotWithQuiesceTimeout
+      else
+        GenericError
+      end
+    end
+  end
+end

data/lib/xenapi/xenapi/xmlrpc_client.rb

@@ -0,0 +1,26 @@
+module XenApi
+  class XMLRPCClient < ::XMLRPC::Client
+    def initialize(host=nil, path=nil, port=nil, proxy_host=nil, proxy_port=nil,
+                   user=nil, password=nil, use_ssl=nil, timeout=nil)
+
+      if use_ssl == :verify_none
+        use_ssl = :verify_none
+      elsif !!use_ssl
+        use_ssl = :verify_peer
+      end
+
+      super(host, path, port, proxy_host, proxy_port, user, password, !!use_ssl, timeout)
+
+      case use_ssl
+      when :verify_peer
+        store = OpenSSL::X509::Store.new
+        store.set_default_paths
+        @http.cert_store = store
+        @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      when :verify_none
+        warn "warning: peer certificate won't be verified in this SSL session"
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-xapi
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-26 00:00:00.000000000 Z
+date: 2012-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -27,22 +27,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.9.14
-- !ruby/object:Gem::Dependency
-  name: xenapi
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +77,14 @@ files:
 - lib/chef/knife/xapi_vdi_detach.rb
 - lib/chef/knife/xapi_vdi_list.rb
 - lib/knife-xapi/version.rb
+- lib/xenapi/README
+- lib/xenapi/xen_api.rb
+- lib/xenapi/xenapi.rb
+- lib/xenapi/xenapi/async_dispatcher.rb
+- lib/xenapi/xenapi/client.rb
+- lib/xenapi/xenapi/dispatcher.rb
+- lib/xenapi/xenapi/errors.rb
+- lib/xenapi/xenapi/xmlrpc_client.rb
 homepage: https://github.com/spheromak/knife-xapi
 licenses: []
 post_install_message: 
@@ -113,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Xen API Support for Chef's Knife Command