rxen 0.1.1

data/README.rdoc

@@ -0,0 +1,70 @@
+== rxen
+
+Ruby wrapper to access the Xen XML-RPC API via simple to use ruby methods, not 
+all methods are implemented, yet. They can be easily added by simply extending the
+Session class RPC_METHODS Hash to include the correct Regular Expression mathing the
+call.
+
+== example
+
+	# Get the rxen gem
+	require 'rxen'
+
+	# create a Session with the Xen Server you want to control
+	xs = Session.new("https://my.xenserver.company.com/")
+
+	# login with username and password
+	xs.login_with_password("root", "password")
+
+	# Some example calls, all possible calls can be found in the XenAPI 
+	# Documentation. Calls are build by class_function(parameters), it is not needed
+	# to pass the session id since it is done automatically.
+	# Get IDs for the VMs running on the Server
+	xs.VM_get_all()
+
+	# register for all task events 
+	xs.event_register(["task"])
+
+	# get the next event from the queue
+	xs.event_next()
+
+	# unregister from the task events 
+	xs.event_unregister(["task"])
+
+	# logout of the XenServer 
+	xs.logout()
+
+Alternativly config based login can be done via 
+	
+	xs = Session.new_with_config("configfile.json")
+
+== license 
+
+(the BSD license)
+
+Copyright 2010 Philipp Fehre. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY PHILIPP FEHRE ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those of the
+authors and should not be interpreted as representing official policies, either expressed
+or implied, of Philipp Fehre.
+

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+
+ 
+spec = Gem::Specification.new do |s|
+  s.name = "rxen"
+  s.version = "0.1.1"
+  s.authors = ['Philipp Fehre']
+  s.email = "philipp.fehre@googlemail.com"
+  s.homepage = "http://sideshowcoder.com/rxen"
+  s.description = "Ruby wrapper to acces the Xen XML-RPC API via simple ruby methods" 
+  s.summary = "Handles login, and after that all other Xen API methods exposed via XML-RPC by XenServer"
+  
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc"]
+  
+  s.require_path = 'lib'
+  s.autorequire = 'rxen'
+  s.files = %w(README.rdoc Rakefile) + Dir.glob("{lib,tests,bin}/*")
+  
+  s.bindir = 'bin'
+  s.executables = ['rxen']
+  s.test_files = Dir.glob('tests/*.rb')  
+  s.add_dependency('json')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+end
+
+task :default => "pkg/#{spec.name}-#{spec.version}.gem" do
+    puts "generated latest version"
+end

data/lib/rxen.rb

@@ -0,0 +1,244 @@
+#!/usr/bin/env ruby
+
+# Access via XML-RPC
+require "xmlrpc/client"
+
+# Read Config json file
+require "rubygems"
+require "json"
+
+# Override XMLRPC Client to not throw a waring on self sign Certificate because 
+# XenServer Certificates are always self signed
+
+require "net/https"
+require "openssl"
+require "pp"
+
+# enable debugger
+# require "ruby-debug"
+
+
+# Get rid of message that Cerificate from Server is self signed, since XenServer uses
+# a self signed Cert in the default case and we know to which Server we connect anyway
+module SELF_SSL
+
+	class Net_HTTP < Net::HTTP
+		def initialize(*args)
+			super
+			@ssl_context = OpenSSL::SSL::SSLContext.new
+			# Set verify mode to VERIFY_NONE to not display a warning on 
+			# self signed certificates
+			@ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+		end
+	end
+ 
+	class XMLRPC_Client < XMLRPC::Client
+		def initialize(*args)
+			super
+			# Use patched NET::HTTP module for XMLRPC
+			@http = SELF_SSL::Net_HTTP.new( @host, @port, 
+						       @proxy_host,@proxy_port )
+			@http.use_ssl = @use_ssl if @use_ssl
+			@http.read_timeout = @timeout
+			@http.open_timeout = @timeout
+		end
+	end
+
+end
+
+
+# XenAPI 
+
+# Define Xen Api Error to make clearer it clearer Exception belongs to XenApi
+class XenApiError < RuntimeError; end
+# Define Config Error
+class XenApiConfigError < RuntimeError; end
+
+# Handle a session with a given XenServer
+class Session
+
+	# Methods to respond to
+	RPC_METHODS = {		
+			# Login / Logout 
+			:login => /^login/,					
+			:logout => /^logout/,
+			
+			# Session
+			:session_change_password => /^session_change_password/,	
+			:session_get_all_subject_identifiers => /^session_get_all_subject_identifiers/,
+			:session_logout_subject_identifier => /^session_logout_subject_identifier/,
+			:session_get_uuid => /^session_get_uuid/,
+			:session_get_this_user => /^session_get_this_user/,
+			:session_get_this_host => /^session_get_this_host/,
+			:session_get_last_active => /^session_get_last_active/,
+			:session_get_pool => /^session_get_pool/,
+			:session_get_other_config => /^session_get_other_config/,
+			:session_set_other_config => /^session_set_other_config/,
+
+			# Task
+			:task_create => /^task_create/,
+			:task_destroy => /^task_destroy/,
+			:task_get_all => /^task_get_all/,
+
+			# Event
+			:event_register => /^event_register/,
+			:event_unregister => /^event_unregister/,
+			:event_next => /^event_next/,
+			:event_get_current_id => /^event_get_current_id/,
+
+			# VM
+			:vm_snapshot => /^VM_snapshot/,
+			:vm_clone => /^VM_clone/,
+			:vm_copy => /^VM_copy/,
+			:vm_start => /^VM_start/,
+			:vm_start_on => /^VM_start_on/,
+			:vm_pause => /^VM_pause/,
+			:vm_unpause => /^VM_unpause/,
+			:vm_suspend => /^VM_suspend/,
+			:vm_resume => /^VM_resume/,
+			:vm_clean_shutdown => /^VM_clean_shutdown/,
+			:vm_clean_reboot => /^VM_clean_reboot/,
+			:vm_hard_showdown => /^VM_hard_shutdown/,
+			:vm_pool_migrate => /^VM_pool_migrate/,
+			:vm_get_possible_hosts => /^VM_get_possible_hosts/,
+			:vm_assert_agile => /^VM_assert_agile/,
+			:vm_get_uuid => /^VM_get_uuid/,
+			:vm_get_powerstate => /^VM_get_powerstate/,
+			:vm_get_name_label => /^VM_name_label/,
+			:vm_get_resident_on => /^VM_get_resident_on/,
+			:vm_get_all => /^VM_get_all/
+	}
+
+	# Access the Session ID
+	attr_reader :session, :xenserver 
+
+	# Access and set session attributes
+	attr_accessor :uri, :user, :password
+
+	# Initialize with Server URI
+	def initialize(uri)
+		@uri = uri
+		@xenserver = SELF_SSL::XMLRPC_Client.new2(@uri)
+	end
+
+	# Initialize with JSON config
+	class << self
+		def new_with_config(config)
+			config = JSON.parse(File.read(config))["xenserver"]
+			if config.nil?
+				raise XenApiConfigError, "malformed config"
+			end
+			
+			@password = config["password"]
+			@user = config["user"]
+			@uri = config["uri"]
+			if @password.nil? || @user.nil? || @uri.nil?
+				raise XenApiConfigError, "missing uri, user, or password"
+			end
+
+			s = self.new(@uri)
+			s.login_with_password(@user, @password)
+			return s
+		end
+	end
+
+	# Since methods are just forwarded to the Server with params they don't have to be implemented itself
+	# but via responding to method_missing in the correct form
+	def method_missing(method, *args, &block)
+		RPC_METHODS.each do |m|
+			if method.to_s =~ m.last
+				return xenapi_request(method, *args)
+			end
+		end
+		# Call super class method missing
+		super
+	end
+
+	# If methods are only implemented via method_missing the responds to is not working correctly anymore 
+	# therefor it needs to be updated with the correct methods to be called
+	
+	def respond_to?(method)
+		# Check if any RPC methods match the call
+		RPC_METHODS.each do |m|
+			return true if method.to_s =~ m.last 
+		end
+		# Call super class responds_to?
+		super
+	end
+
+	# Declare a XenAPI request to be only called by object itself
+	private
+	
+	def xenapi_request(method, *params)
+		# Catch login method
+		if method.to_s =~ RPC_METHODS[:login]
+			return login(method, *params)
+		end
+
+		if method.to_s =~ RPC_METHODS[:logout]
+			return logout(method)
+		end
+	
+		# Pass method to server
+		# First part of method name is the class, so _ got to be replace by a .
+		method = method.to_s
+		method.sub!(/_/, ".")
+		
+		# Check if we are logged in
+		raise XenApiError, "not logged in" unless @session 
+
+		# Call Server with method passed
+		res = @xenserver.call(method, @session, *params)
+		if res["Status"] == "Success"
+			# return the result value passed back via XMLRPC
+			return res["Value"]
+		else
+			# get the error if one occurs
+			raise XenApiError, res["ErrorDescription"][0]
+		end
+		
+	end
+	
+	# Login Method needs to save the session cookie for further requests so it 
+	# does not have to be passed every single call
+	def login(method, *params)
+		# Use saved passwords if nothing is passed
+		if params.empty?
+			params << @user
+			params << @password
+		else 
+			# save password and user for quicker reloggon
+			@user = params[0]
+			@password = params[1]
+		end
+
+		res =  @xenserver.call("session.#{method}", *params)
+		
+		if res["Status"] == "Success"
+			@session = res["Value"]
+			return @session
+		else
+			raise XenApiError, res["ErrorDescription"][0]
+		end
+	end
+
+	# Logout needs to clear the session cookie saved by login
+	def logout(method)
+		# Check if logged on, else session should be nil
+		unless @session.nil?
+			res = @xenserver.call("session.#{method}", @session)
+		else 
+			# If not logged in logout will always be successful (common sense)
+			return true
+		end
+
+		# Check if logout was Successful and clear session if so
+		if res["Status"] == "Success"
+			@session = nil
+			return true
+		else
+			raise XenApiError, res["ErrorDescription"][0]
+		end
+	end
+
+end

data/tests/tc_rxen_session.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+
+require "test_helper"
+require "test/unit"
+require "rxen"
+require "net/http"
+require "net/https"
+require "json"
+
+class SessionTest < Test::Unit::TestCase
+
+	# define Server config file
+	SERVER_CONFIG = "test_server.json"
+	MALFORMED_CONFIG = "test_malformed.json"
+	MALFORMED_CONFIG_USER = "test_malformed_user.json"
+
+	# Methods that can be called on the xensession at the moment
+	METHODS = [
+			:session_change_password,	
+			:session_get_all_subject_identifiers,
+			:session_logout_subject_identifier,
+			:session_get_uuid,
+			:session_get_this_user,
+			:session_get_this_host,
+			:session_get_last_active,
+			:session_get_pool,
+			:session_get_other_config,
+			:session_set_other_config,
+			:task_create,
+			:task_destroy,
+			:task_get_all,
+			:event_register,
+			:event_unregister,
+			:event_next,
+			:event_get_current_id,
+			:VM_snapshot,
+			:VM_clone,
+			:VM_copy,
+			:VM_start,
+			:VM_start_on,
+			:VM_pause,
+			:VM_unpause,
+			:VM_suspend,
+			:VM_resume,
+			:VM_clean_shutdown,
+			:VM_clean_reboot,
+			:VM_hard_shutdown,
+			:VM_pool_migrate,
+			:VM_get_possible_hosts,
+			:VM_assert_agile,
+			:VM_get_uuid,
+			:VM_get_powerstate,
+			:VM_name_label,
+			:VM_get_resident_on,
+			:VM_get_all
+	]
+
+	# Methods used for testing do to them being non blocking and do not require specific order
+	# of execution
+	METHODS_TEST_SAVE = {
+			:session_get_all_subject_identifiers => [],
+			:task_get_all => [],
+			:event_register => ["task"],
+			:event_unregister => ["task"],
+			:event_get_current_id => [],
+			:VM_get_all => []
+	}
+
+	# Setup 
+	def setup
+		config = JSON.parse(File.read(SERVER_CONFIG))["xenserver"]
+		@serveruri = config["uri"]
+		@user = config["user"]
+		@password = config["password"]
+		@xensession = Session.new(@serveruri)
+	end
+
+	def test_login
+		# Check if Session responds to login
+		assert_respond_to(@xensession, :login_with_password)
+
+		# Check if login works
+		assert_nothing_raised(XenApiError) do
+			@xensession.login_with_password(@user, @password)
+		end
+		assert_not_nil( @xensession.session )
+		assert_not_nil( @xensession.user )
+		assert_not_nil( @xensession.password )
+
+		# Login credentials should be saved, and not be required again
+		assert_nothing_raised(XenApiError) do
+			@xensession.login_with_password()
+		end
+		
+		# Check if login fails with wrong password and username, overwriting 
+		# saved ones
+		assert_raise(XenApiError) do
+			@xensession.login_with_password("toor", "12345")
+		end
+		assert_equal( @xensession.user, "toor" )
+		assert_equal( @xensession.password, "12345" )
+
+	end
+
+	def test_new_with_config
+		test_session = nil
+		assert_nothing_raised(XenApiConfigError) do
+			test_session = Session.new_with_config(SERVER_CONFIG)
+		end
+
+		assert_not_nil( test_session.session )
+
+		assert_raises(XenApiConfigError) do
+			Session.new_with_config(MALFORMED_CONFIG)
+		end
+		
+		assert_raises(XenApiConfigError) do
+			Session.new_with_config(MALFORMED_CONFIG_USER)
+		end
+	end
+
+	def test_logout
+		# Check if Session responds to logout
+		assert_respond_to(@xensession, :logout)
+
+		# Logout should always be successful if not logged in
+		assert_equal(true, @xensession.logout())
+
+		# Login first
+		@xensession.login_with_password(@user, @password)
+		
+		# Check if we are logged in
+		assert_not_nil( @xensession.session )
+		
+		# Logout
+		assert_nothing_raised(XenApiError) do
+			@xensession.logout()
+		end
+		assert_nil( @xensession.session )
+	end
+
+	def test_respond_to_method
+		# Check to see if we are responding to correct methods
+		METHODS.each do |m|
+			assert_respond_to( @xensession, m ) 
+		end
+	end
+
+	def test_method_basic_function
+		# Check if no methods defined throw an error
+		# Start by loggin in
+		assert_nothing_raised(XenApiError) {@xensession.login_with_password(@user, @password)}
+		
+		# Methods able to call
+		METHODS_TEST_SAVE.each do |m|
+			assert_nothing_raised(XenApiError) do
+				if m[1].empty?
+					@xensession.send(m[0])
+				else
+					@xensession.send(m[0], m[1])
+				end
+			end
+		end
+
+		# End by loggin out
+		assert_nothing_raised(XenApiError) {@xensession.logout()}
+	end
+
+	def test_method_call_deep
+		# We should not be able to call a method unless we are logged in
+		assert_raise(XenApiError) do
+			@xensession.VM_get_all()
+		end
+
+		# Login now 
+		@xensession.login_with_password(@user, @password)
+
+		# Method should run fine now
+		assert_nothing_raised(XenApiError) do
+			@xensession.VM_get_all()
+		end
+	end
+	
+end

data/tests/test_helper.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "rubygems"
+$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/../lib' )
+$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/../bin' )

data/tests/test_malformed.json

@@ -0,0 +1,6 @@
+{"server":{
+	"uri":"https://xxxx/",
+	"user":"root",
+	"password":"xxxx"
+	     }
+}

data/tests/test_malformed_user.json

@@ -0,0 +1,5 @@
+{"xenserver":{
+	"uri":"https://xxxx/",
+	"password":"xxxx"
+	     }
+}

data/tests/test_server.json

@@ -0,0 +1,6 @@
+{"xenserver":{
+	"uri":"https://xxxx/",
+	"user":"root",
+	"password":"xxxx"
+	     }
+}

data/tests/ts_alltests.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "test/unit"
+require "tc_rxen_session"
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: rxen
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Philipp Fehre
+autorequire: rxen
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Ruby wrapper to acces the Xen XML-RPC API via simple ruby methods
+email: philipp.fehre@googlemail.com
+executables: 
+- rxen
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/rxen.rb
+- tests/tc_rxen_session.rb
+- tests/test_helper.rb
+- tests/test_malformed.json
+- tests/test_malformed_user.json
+- tests/test_server.json
+- tests/ts_alltests.rb
+- bin/rxen
+has_rdoc: true
+homepage: http://sideshowcoder.com/rxen
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Handles login, and after that all other Xen API methods exposed via XML-RPC by XenServer
+test_files: 
+- tests/tc_rxen_session.rb
+- tests/test_helper.rb
+- tests/ts_alltests.rb