xencap 1.0.0

data/lib/xencap/plugin.rb

@@ -0,0 +1,28 @@
+require 'xencap/xenapi'
+
+module Xencap
+  module Plugin
+    attr_reader :session, :request_dispatcher
+
+    def setup(uri, options = {})
+      @session = XenAPI::Session.new(uri)
+      _ignore_ssl_errors if options.fetch(:ignore_ssl_errors, false)
+
+       @session.login_with_password(options.fetch(:login), options.fetch(:password))
+       @request_dispatcher = Xencap::RequestDispatcher.new(@session)
+    end
+
+    def teardown
+      @session.logout unless @session.nil?
+    end
+
+    def method_missing(method, *args)
+      @request_dispatcher.dispatch(method, *args)
+    end
+
+    def _ignore_ssl_errors
+      # Allow self-signed certs
+      @session.instance_variable_get(:@http).instance_variable_set(:@verify_mode, OpenSSL::SSL::VERIFY_NONE)
+    end
+  end
+end

data/lib/xencap/request_dispatcher.rb

@@ -0,0 +1,21 @@
+class Xencap::RequestDispatcher
+  def initialize(session)
+    @session = session
+    @proxy_classes = Dir[File.expand_path("../session_proxy/*rb", __FILE__)]
+    @proxies = {}
+
+  end
+
+  def dispatch(scope, *args)
+    if @proxies.has_key?(scope)
+      # nothing to do here
+    elsif filename = @proxy_classes.detect {|file| File.basename(file, ".rb").downcase == scope.to_s}
+      require filename
+      @proxies[scope] = Xencap::SessionProxy.const_get(scope.capitalize).new(@session)
+    else
+      @proxies[scope] = Xencap::SessionProxy.new(@session, scope)
+    end
+
+    @proxies[scope]
+  end
+end

data/lib/xencap/session_proxy/vm.rb

@@ -0,0 +1,33 @@
+class Xencap::SessionProxy::Vm < Xencap::SessionProxy
+  def initialize(session)
+    @session = session
+    @scope = "VM"
+  end
+
+  def get_control_dom0
+    get_all_records.select do |vm|
+      vm['is_control_domain']
+    end
+  end
+
+  def get_templates
+    get_all_records.select do |vm|
+      vm['is_a_template']
+    end
+  end
+
+  def get_vms
+    get_all_records.reject do |vm|
+      vm['is_a_template'] || vm['is_control_domain']
+    end
+  end
+
+  def clone_template(template_name, name)
+    template_ref, template_record = get_all_records.detect do |ref, record|
+      record['is_a_template'] == true && record['name_label'] == template_name
+    end
+    ref = clone(template_ref, name)
+    set_is_a_template(ref, false)
+    ref
+  end
+end

data/lib/xencap/session_proxy.rb

@@ -0,0 +1,39 @@
+class Xencap::SessionProxy
+  def initialize(session, scope)
+    @session = session
+
+    if scope.length <= 3
+      @scope = scope.upcase
+    else
+      @scope = scope
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    _request(method, *args)
+  end
+
+  def clone(*args)
+    if args.length > 0
+      _request(:clone, *args)
+    else
+      super
+    end
+  end
+
+  def find_all_records(options = {})
+    get_all_records.select do |ref, record|
+      options.all? do |key, value|
+        record[key.to_s] == value
+      end
+    end
+  end
+
+  def find_record(options = {})
+    find_all_records(options).first
+  end
+
+  def _request(method, *args)
+    @session.send(@scope).send(method, *args)
+  end
+end

data/lib/xencap/tasks.rb

@@ -0,0 +1,36 @@
+Capistrano::Configuration.instance.load do
+  set :xencap_server_uri, nil
+  set :xencap_login, "root"
+  set :xencap_password, do
+    Capistrano::CLI.password_prompt("xen password: ")
+  end
+  set :xencap_ignore_ssl_errors, false
+
+  on :exit do
+    xencap.session.teardown
+  end
+
+  namespace :xencap do
+    namespace :session do
+      task :setup do
+        xencap_plugin.setup(
+          xencap_server_uri,
+          :login => xencap_login,
+          :password => xencap_password,
+          :ignore_ssl_errors => xencap_ignore_ssl_errors
+        )
+      end
+
+      task :teardown do
+        xencap_plugin.teardown
+      end
+    end
+
+    namespace :vm do
+      task :list do
+        xencap.session.setup
+        xencap_plugin.vm.get_all_records.reject {|ref, record| record['is_a_template'] || record['is_control_domain'] }.values.each {|v| puts v['name_label'] }
+      end
+    end
+  end
+end

data/lib/xencap/xenapi.rb

@@ -0,0 +1,232 @@
+# ===========================================================================
+# Copyright (c) 2010 Holger Just
+#
+# 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.
+#
+# ===========================================================================
+#
+# This library is based on
+# {XenAPI.py}[http://community.citrix.com/download/attachments/38633496/XenAPI.py]
+# by XenSource Inc., licensed under the LGPL.
+# ---------------------------------------------------------------------------
+#
+# ===========================================================================
+# Grabbed on 2013-04-21 by plainlystated
+# from: https://github.com/meineerde/xenapi.rb
+# ---------------------------------------------------------------------------
+
+require 'uri'
+require 'xmlrpc/client'
+
+module XenAPI
+  API_VERSION_1_1 = '1.1'
+  API_VERSION_1_2 = '1.2'
+
+  RETRY_COUNT = 3
+
+  class SessionInvalidError < Exception; end
+  class Failure < Exception
+    def initialize(details = [])
+      if details.is_a? Array
+        @error_type = details[0]
+        @error_details = details[1..-1] || []
+      else
+        @error_details = []
+      end
+    end
+
+    def to_s
+      details = case @error_details.length
+        when 0 then ""
+        when 1 then @error_details[0]
+        else @error_details.inspect
+      end
+
+      "#{@error_type.to_s}: #{details}"
+    end
+
+    attr_reader :error_type, :error_details
+  end
+
+  class Session < ::XMLRPC::Client
+    def initialize(uri, proxy_host=nil, proxy_port=nil)
+      # uri can be one of:
+      #  * "http://server.name/path"
+      #  * "https://server.name/path"
+      #  * "socket:///var/xapi/xapi"
+      # proxy_host and proxy_port can be used to specify an HTTP proxy
+      @uri = URI.parse(uri)
+
+      case @uri.scheme.downcase
+      when 'http', 'https'
+        super(
+          @uri.host,
+          @uri.path.empty? ? "/" : @uri.path,
+          @uri.port,
+          proxy_host,
+          proxy_port,
+          nil, # user
+          nil, # password
+          (@uri.scheme.downcase == "https")
+        )
+      when 'socket'
+        raise NotImplementedError.new("Sockets are not supported yet. Sorry")
+      else
+        raise ArgumentError.new("Unknown scheme")
+      end
+
+      @api_version = API_VERSION_1_1
+      @session = ""
+    end
+
+    attr_reader :uri, :api_version
+    def session_id
+      @session
+    end
+
+    LOGIN_METHODS = %w(login_with_password slave_local_login_with_password)
+    LOGIN_METHODS.each do |method|
+      class_eval <<-"END_EVAL", __FILE__, __LINE__
+        def #{method}(*args)
+          begin
+            result = self.session.#{method}(*args)
+          rescue SessionInvalidError
+            raise ::XMLRPC::FaultException.new(500,
+              'Received SESSION_INVALID when logging in')
+          end
+
+          @session = result
+          @last_login_method = :#{method}
+          @last_login_params = args
+          @api_version = _api_version
+        end
+      END_EVAL
+    end
+
+    def logout
+      # preferred method to logout the session
+      if @last_login_method.to_s.start_with?("slave_local")
+        self.session.local_logout
+      else
+        self.session.logout
+      end
+    end
+
+    def proxy(prefix=nil, *args)
+      # Overrides base method to use our custom Proxy class
+      XenAPIProxy.new(self, prefix, args, :call)
+    end
+
+    def proxy2(prefix=nil, *args)
+      # Overrides base method to use our custom Proxy class
+      XenAPIProxy.new(self, prefix, args, :call2)
+    end
+
+    def method_missing(sym, *args)
+      self.proxy(sym.to_s, *args)
+    end
+
+  private
+    def _api_version()
+      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
+
+    def _logout
+      # called from proxy object to release all session state
+      @session = ""
+      @last_login_method = nil
+      @last_login_params = nil
+      @api_version = API_VERSION_1_1
+    end
+  end
+
+  class XenAPIProxy < ::XMLRPC::Client::Proxy
+    def method_missing(method, *args, &block)
+      begin
+        if (@prefix == 'session.') && (Session::LOGIN_METHODS.include? method.to_s)
+          parse_result super(method, *args, &block)
+        else
+          retry_count = 0
+          while (retry_count < RETRY_COUNT)
+            session_args = [server(:session)] + args
+            begin
+              return parse_result super(method, *session_args, &block)
+            rescue SessionInvalidError
+              retry_count += 1
+              if server(:last_login_method)
+                @server.send(server(:last_login_method), *server(:last_login_params))
+              else
+                raise XMLRPC::FaultException.new(401, "You must log in")
+              end
+            end
+          end
+
+          raise ::XMLRPC::FaultException.new(500,
+            "Tried #{RETRY_COUNT} times to get a valid session, but failed")
+        end
+      ensure
+        # ensure we clear the global state on logout
+        @server.send(:_logout) if (@prefix == 'session.') && (method == :logout)
+      end
+    end
+
+    # method name clash between built-in clone and the method to clone a VM
+    def clone(*args)
+      args.length > 0 ? method_missing(:clone, *args) : super
+    end
+
+  private
+    def server(arg)
+      # returns an instance variable of the server
+      @server.instance_variable_get("@#{arg.to_s}")
+    end
+
+    def parse_result(result)
+      unless result.is_a?(Hash) && result.include?('Status')
+        raise XMLRPCClientError.new('Missing Status in response from server: ' + result.inspect)
+      end
+
+      if result['Status'] == 'Success'
+        if result.include? 'Value'
+          result['Value']
+        else
+          raise ::XMLRPC::FaultException.new('Missing Value in response from server')
+        end
+      else
+        if result.include? 'ErrorDescription'
+          if result['ErrorDescription'][0] == 'SESSION_INVALID'
+            raise SessionInvalidError
+          else
+            raise Failure.new(result['ErrorDescription'])
+          end
+        else
+          raise ::XMLRPC::FaultException.new('Missing ErrorDescription in response from server')
+        end
+      end
+    end
+  end
+end
+

data/lib/xencap.rb

@@ -0,0 +1,9 @@
+module Xencap
+  require File.expand_path('../xencap/tasks', __FILE__)
+
+  autoload :Plugin, File.expand_path('../xencap/plugin', __FILE__)
+  autoload :RequestDispatcher, File.expand_path('../xencap/request_dispatcher', __FILE__)
+  autoload :SessionProxy, File.expand_path('../xencap/session_proxy', __FILE__)
+end
+
+Capistrano.plugin :xencap_plugin, Xencap::Plugin

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: xencap
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Patrick Schless
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-01 00:00:00.000000000 Z
+dependencies: []
+description: Should work with any xen system that uses XAPI (including XenServer &
+  XCP)
+email: patrick@plainlystated.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./lib/xencap/plugin.rb
+- ./lib/xencap/request_dispatcher.rb
+- ./lib/xencap/session_proxy/vm.rb
+- ./lib/xencap/session_proxy.rb
+- ./lib/xencap/tasks.rb
+- ./lib/xencap/xenapi.rb
+- ./lib/xencap.rb
+homepage: https://github.com/plainlystated/xencap
+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.24
+signing_key: 
+specification_version: 3
+summary: Capistrano support for managing XenServer
+test_files: []