gapinc-fog 1.12.1a

data/lib/fog/xenserver/CHANGELOG.md

@@ -0,0 +1,77 @@
+# 1.10.1 2013/04/04
+
+* It's now possible to manage XS/XCP VLANs and Networks
+
+  See https://github.com/fog/fog/blob/master/lib/fog/xenserver/examples/networks-and-vlans.rb
+
+# 1.9.0 2013/01/19 
+
+* Added missing HostCpu model
+
+  So you can retrieve things like the CPU model, speed, flags
+  utilisation, vendor, etc.
+
+  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host_cpu
+
+* Host model improvements 
+
+  Added missing host attributes:
+
+  - edition
+  - software_version
+  - enable
+  - disable
+  - shutdown
+  - reboot
+
+  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host
+
+* PBD model improvements
+
+  - Added missing currently_attached attribute
+  - A PBD can be unplugged now
+
+  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=PBD
+
+* StorageRepository model improvements
+
+  - Added missing create/destroy/save operations
+  - Added missing generic set_attribute method
+  
+  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=SR
+
+* Pool model improvements 
+
+  - Added missing suspend_image_sr attribute
+  - Added default_sr getter/setter
+  - Added suspend_image_sr getter/setter
+  - Added generic set_attribute method
+
+  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=pool
+
+* Switch to nokogiri XML parser
+
+  Use Nokogiri instead of slow REXML for parsing, greatly improving
+  parsing time under some ruby implementations.
+
+* Greatly improved documentation
+
+  New tutorials included with the provider:
+
+  - Getting started: the compute service
+  - How To Change the Default Storage Repository to File-based VHD-on-EXT3
+  - Example that covers a Citrix KB ctx116324 article
+  - Creating servers (VMs) and templates
+  - Managing Storage Repositories
+
+  See https://github.com/fog/fog/tree/master/lib/fog/xenserver/examples
+
+* Added missing HostMetrics model
+
+  Retrieve the metrics associated with a host.
+
+  See http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host_metrics
+
+* Fixed authentication issues when using numeric-only passwords
+
+* Better test coverage

data/lib/fog/xenserver/compute.rb

@@ -0,0 +1,137 @@
+require 'fog/xenserver'
+require 'fog/compute'
+
+module Fog
+  module Compute 
+    class XenServer < Fog::Service
+
+      require 'fog/xenserver/utilities'
+      require 'fog/xenserver/parser'
+      
+      requires :xenserver_username
+      requires :xenserver_password
+      requires :xenserver_url
+      recognizes :xenserver_defaults
+      
+      model_path 'fog/xenserver/models/compute'
+      model :server
+      collection :servers
+      model :host
+      collection :hosts
+      collection :vifs
+      model :vif
+      collection :storage_repositories
+      model :storage_repository
+      collection :pools
+      model :pool
+      collection :vbds
+      model :vbd
+      collection :vdis
+      model :vdi
+      collection :networks
+      model :network
+      collection :pifs
+      model  :pif
+      collection :pbds
+      model  :pbd
+      model  :guest_metrics
+      model  :vbd_metrics
+      model  :host_metrics
+      model  :host_cpu
+      model  :vlan
+      collection :vlans
+
+      request_path 'fog/xenserver/requests/compute'
+      request :create_server
+      request :create_vif
+      request :create_vdi
+      request :create_vbd
+      request :destroy_vif
+      request :clone_server
+      request :destroy_server
+      request :unplug_vbd
+      request :eject_vbd
+      request :insert_vbd
+      request :destroy_vdi
+      request :shutdown_server
+      request :start_vm
+      request :start_server
+      request :get_record
+      request :get_records
+      request :set_affinity
+      request :set_attribute
+      request :reboot_server
+      request :provision_server
+      request :scan_sr
+      request :unplug_pbd
+      request :destroy_sr
+      request :create_sr
+      request :reboot_host
+      request :disable_host
+      request :enable_host
+      request :shutdown_host
+      request :create_network
+      request :destroy_network
+      request :create_vlan
+      request :destroy_vlan
+    
+      class Real
+        
+        def initialize(options={})
+          @host        = options[:xenserver_url]
+          @username    = options[:xenserver_username]
+          @password    = options[:xenserver_password]
+          @defaults    = options[:xenserver_defaults] || {}
+          @connection  = Fog::XenServer::Connection.new(@host)
+          @connection.authenticate(@username, @password)
+        end
+
+        def reload
+          @connection.authenticate(@username, @password)
+        end
+        
+        def default_template=(name)
+          @defaults[:template] = name
+        end
+
+        def default_template
+          return nil if @defaults[:template].nil?
+          (servers.custom_templates + servers.builtin_templates).find do |s|
+            (s.name == @defaults[:template]) or (s.uuid == @defaults[:template])
+          end
+        end
+        
+        def default_network
+          networks.find { |n| n.name == (@defaults[:network] || "Pool-wide network associated with eth0") }
+        end
+        
+      end
+      
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+        
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+        
+        def initialize(options={})
+          @host        = options[:xenserver_pool_master]
+          @username    = options[:xenserver_username]
+          @password    = options[:xenserver_password]
+          @connection  = Fog::Connection.new(@host)
+          @connection.authenticate(@username, @password)
+        end
+        
+      end
+    end
+  end
+end
+
+

data/lib/fog/xenserver/examples/README.md

@@ -0,0 +1,11 @@
+# fog/xenserver compute examples
+
+fog/xenserver examples contributed by BVox World S.L.U.
+Original examples from https://github.com/bvox/fog-xenserver-examples
+
+Maintainer: Sergio Rubio <rubiojr@bvox.net>
+
+A general introduction to Fog is available at:
+
+http://fog.io
+

data/lib/fog/xenserver/examples/chage_default_storage_repository.md

@@ -0,0 +1,99 @@
+# How To Change the Default Storage Repository to File-based VHD-on-EXT3 
+
+**NOTE: Requires fog > 1.8 (currently in development as of this writing)**
+
+This tutorial explains how to convert a local Logical Volume Manager (LVM) 
+based storage repository into a file-based (VHD) storage repository.
+
+It's the fog/xenserver version of the original Citrix KB article:
+
+http://support.citrix.com/article/ctx116324
+
+To create this tutorial, I've used a vanilla XCP 1.6 ISO install in VirtualBox.
+
+## Create the connection
+
+```ruby
+require 'fog'
+
+conn = Fog::Compute.new({
+  :provider => 'XenServer',
+  :xenserver_url => '192.168.1.39',
+  :xenserver_username => 'root',
+  :xenserver_password => 'secret'
+})
+```
+
+## Remove the LVM-backed storage repository (SR).
+
+Find the default LVM storage repository:
+
+```ruby
+#
+# Equivalent to:
+# xe sr-list type=lvm
+#
+lvm_sr = nil 
+conn.storage_repositories.each do |sr|
+  lvm_sr = sr if sr.type == 'lvm'
+end
+```
+
+Determine the UUID for your default SR's physical block device:
+
+```ruby
+#
+# Equivalent to:
+# xe pbd-list sr-uuid=your SR UUID
+#
+if lvm_sr
+  conn.pbds.each do |pbd|
+    # Unplug it if found
+    # Equivalent to:
+    # xe pbd-unplug uuid=your PBD UUID
+    #
+    pbd.unplug if pbd.storage_repository.uuid == lvm_sr.uuid
+  end
+  # Destroy the SR
+  lvm_sr.destroy 
+end
+```
+
+Create a new VHD-backed SR:
+
+```ruby
+#
+# Equivalent to:
+#
+# xe sr-create content-type="local SR" \
+#              host-uuid=5d189b7a-cd5e-4029-9940-d4daaa34633d \ 
+#              type=ext device-config-device=/dev/sda3 shared=false \
+#              name-label="Local File SR"
+#
+sr = conn.storage_repositories.create :name => 'Local File SR',
+                                      :host => conn.hosts.first,
+                                      :type => 'ext',
+                                      :content_type => 'local SR',
+                                      :device_config => { :device => '/dev/sda3' },
+                                      :shared => false
+```
+
+Set your SR as the default SR on the system:
+
+```ruby
+#
+# Equivalent command:
+# xe pool-param-set suspend-image-SR='YOUR NEW SR UUID' uuid=bleh
+#
+conn.pools.first.default_storage_repository = sr
+```
+
+Set your SR as the default location for suspended VM images:
+
+```ruby
+#
+# Equivalent command:
+# xe pool-param-set suspend-image-SR= YOUR NEW SR UUID  uuid=bleh
+#
+conn.pools.first.suspend_image_sr = sr
+```

data/lib/fog/xenserver/examples/creating_servers.md

@@ -0,0 +1,168 @@
+# Creating servers (VMs) and templates
+
+The basic server creation steps are detailed in the getting started tutorial.
+
+Now let's do something a little bit more complex and probably more useful in
+day-to-day operations. That is:
+
+1. Uploading a VHD image.
+2. Create a new template with it.
+3. Spin a new server using the recently added template.
+
+## Part I: Upload the VHD
+
+Assuming we have an image file 'ubuntu.vhd' ready to be uploaded, let's create
+the connection to the XenServer host and upload the image to the storage repository,
+using SSH. The code also assumes that you have a file storage repository mounted
+somewhere in /var/run/sr-mount/#{sr-UUID} (the standard XenServer base directory
+for mounted storage repositories).
+
+    require 'fog'                                                               
+    require 'net/scp'
+    require 'uuidtools'
+    
+    #
+    # Create the connection to the XenServer host
+    #
+    xenserver = Fog::Compute.new({
+      :provider           => 'XenServer',
+      :xenserver_url      => 'xenserver-test',
+      :xenserver_username => 'root',
+      :xenserver_password => 'secret',
+    })
+
+
+We'll be uploading the image to the "Local File SR" storage repository, so
+we need the reference to this SR (Storage Repository):
+  
+    sr = xenserver.storage_repositories.find { |sr| sr.name ==  "Local File SR" }
+
+XenServer uses UUIDs to store images in the storage repositories, so we will
+emulate that behavior, creating a new UUID for our image and uploading it.
+
+    #
+    # Use the excelent uuidtools gem to create the new UUID
+    # for the image
+    #
+    image_uuid = UUIDTools::UUID.random_create.to_s
+
+
+To upload the new image using SCP, we need the destination directory, where the
+SR is mounted. In our case, the storage repository mount point is 
+/var/run/sr-mount/#{sr.uuid} (where sr.uuid is the UUID of the storage
+repository). We will upload the new image there:
+
+    sr_mount_point = "/var/run/sr-mount/#{sr.uuid}"
+    # Target image file path. We will upload the local image to the destination
+    # using SCP
+    destination = File.join(sr_mount_point, "#{image_uuid}.vhd")
+    # source image, located in the current directory
+    source = 'ubuntu.vhd'
+    # Use the XenServer root credentials to upload
+    Net::SSH.start('xenserver-test', 'root', :password => 'secret') do |ssh|              
+      ssh.scp.upload!(source, destination) do |ch, name, sent, total|              
+        # print progress
+        p = (sent.to_f * 100 / total.to_f).to_i.to_s                        
+        print "\rProgress: #{p}% completed"                     
+      end                                                                   
+    end 
+
+We need to let the XenServer know, that there's a new image:
+
+    sr.scan
+ 
+Now that XenServer is aware of the new image, get its reference
+and set the image name attribute to 'ubuntu-template'
+
+    ubuntu_vdi = xenserver.vdis.find { |vdi| vdi.uuid == image_uuid }
+    ubuntu_vdi.set_attribute 'name_label', 'ubuntu-template'
+
+Good! the image is ready to be used.
+
+## Part II: create the server template
+
+We have the image ready to be used by our new template.
+
+Templates are regular servers, so let's create one with 512 MB of RAM, 1 CPU
+and a network card. The main difference with a regular server from an API 
+point of view is that we will not start it.
+
+We will also create the template as PV (paravirtual):
+
+    server_mem = (512 * 1024 * 1024).to_s 
+    server = xenserver.servers.new :name               => "ubuntu-template",
+                                   # Required when using Server.new
+                                   :affinity           => xenserver.hosts.first,
+                                   :other_config       => {},
+                                   :pv_bootloader      => 'pygrub',          # PV related
+                                   :hvm_boot_policy    => '',                # PV related
+                                   :pv_args            => '-- console=hvc0', # PV related
+                                   :memory_static_max  => mem,
+                                   :memory_static_min  => mem,
+                                   :memory_dynamic_max => mem,                       
+                                   :memory_dynamic_min => mem 
+    server.save
+
+We need to attach the disk image to a VBD and to the server
+
+    xenserver.vbds.create :server => server, :vdi => ubuntu_vdi
+
+Note that we're using Server.new here, instead of Server.create.
+Server.create would start the server, and that's not what we want here.
+
+Let's add the NIC (VIF or virtual interface) to the server.
+
+I have a network in my XenServer named "Pool-wide network associated with eth0"
+bridged to the physical eth0 NIC and I will attach the new NIC to that network.
+
+Don't be scared by the VIF creation code. There are easier ways to create a
+VIF, and we'll be dealing with that and some other cases in the networking 
+tutorial (TODO).
+
+First, let's find the network since we'll need the reference.
+
+    net = xenserver.networks.find { |n| n.name == 'Pool-wide network associated with eth0' }
+
+To create the VM VIF, we need to set some attributes and use the 
+create_vif_custom request:
+
+    vif_attr = {
+      'MAC_autogenerated' => 'True',
+      'VM'                => server.reference, # we need the VM reference here
+      'network'           => net.reference, # we need the Network reference here
+      'MAC'               => '', # ignored, since we use autogeneration
+      'device'            => '0',
+      'MTU'               => '0',
+      'other_config'      => {},
+      'qos_algorithm_type' => 'ratelimit',                                 
+      'qos_algorithm_params' => {}
+    }
+    xenserver.create_vif_custom vif_attr
+    
+
+The template is now ready to be used and we can list it!
+
+    xenserver.servers.custom_templates.find { |t| puts t.name }
+
+## Party III: spin a new server using the brand new template
+
+Now that we have the template in place, it's easy to create as many servers
+as you want. All of them will share hardware specs with the template. That is,
+512 MB of RAM, 1 CPU, 1 NIC attached to the 'Pool-wide network...':
+
+    xenserver.servers.create :name => 'my-brand-new-server',
+                             :template_name => 'ubuntu-template'
+
+
+# The End
+
+Pretty similar code is used by knife-xenserver (http://github.com/bvox/knife-xenserver)
+to upload new templates. Have a look at it if you're interested, it's full of
+examples and fog/xenserver tricks to manage XenServer/XCP hosts.
+
+The full source code used in this tutorial is available at:
+
+https://github.com/bvox/fog-xenserver-examples/blob/master/upload_template_and_create.rb
+
+Enjoy!
+

data/lib/fog/xenserver/examples/getting_started.md

@@ -0,0 +1,163 @@
+# Getting started: the compute service
+
+## Connecting, retrieving and managing server objects
+
+First, create a connection to the XenServer host:
+
+    require 'fog'
+    require 'pp'
+    
+    #
+    # http://rubydoc.info/github/fog/fog/Fog/Compute/XenServer/Real
+    #
+    conn = Fog::Compute.new({
+      :provider => 'XenServer',
+      :xenserver_url => 'xenserver-test',
+      :xenserver_username => 'root',
+      :xenserver_password => 'changeme',
+      :xenserver_defaults => { 
+        :template => "squeeze-test" 
+      }
+    })
+
+## Listing servers (VMs) and templates
+
+We try to follow fog naming conventions and behavior as much as we can, so the
+terminology used in fog/xenserver is a little bit different from the one
+used in XAPI/XenServer documents. In particular:
+
+* A Fog::Compute::XenServer::Server is a XenServer VM or DomU
+
+* A Fog::Compute::XenServer::Host is a Hypervisor or Dom0
+
+Having that in mind, we can start doing things with out XenServer host.
+
+Listing all the servers (VMs):
+
+    conn.servers.all 
+
+This will return a list of Fog::Compute::XenServer::Server.
+
+List all the servers whose name matches Ubuntu:
+
+    conn.servers.all :name_matches => "Ubuntu"
+
+Listing the first server running (templates aren't included by default 
+in the list):
+
+    server = conn.servers.first
+
+Listing custom templates, that is, the ones created by the user:
+
+    custom = conn.servers.custom_templates
+
+Listing built-in templates (the templates available after a fresh install):
+
+    built_in = conn.servers.builtin_templates
+
+Templates are regular Fog::Compute::XenServer::Server objects too, so you can
+inspect some of their attributes. The relevant XAPI documentation:
+
+http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VM
+
+Fog::Compute::XenServer::Server attributes and operations usually map to the
+ones found in the official Citrix documentation, and they are available at:
+
+http://rubydoc.info/github/fog/fog/Fog/Compute/XenServer/Server
+
+and 
+
+https://github.com/fog/fog/blob/master/lib/fog/xenserver/models/compute/server.rb
+
+## Server operations and attributes
+
+Getting server VIFs (virtual network interfaces):
+
+    # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VIF
+    server.networks
+    # or server.vifs
+
+Listing the server VBDs (virtual block devices):
+
+    # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VBD
+    server.vbds
+
+
+Get VDIs objects (virtual disk images) attached to the server:
+
+    server.vbds.each do |vbd|
+      # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VDI
+      vdi = vbd.vdi
+      # In bytes
+      puts vdi.virtual_size
+      puts vdi.physical_utilisation
+    end
+
+## Server creation and life-cycle management
+
+Creating a new server/VM:
+
+    server = conn.servers.create :name => 'foobar',
+                                 :template_name => 'squeeze-test'
+
+The server is automatically started after that.
+
+Note that template_name is optional if you have specified the ':template'
+parameter when when creating the connection.
+
+If you don't want to automatically start the server, use 'new' instead of 'create':
+
+    server = conn.servers.new :name => 'foobar',
+                              :template_name => 'squeeze-test'
+
+and set auto_start to false when saving it:
+
+    server.save :auto_start => false
+
+Shutting down the server, By forcing it
+
+    server.stop 'hard'
+    # server.hard_shutdown is equivalent
+
+Doing a clean shutdown
+
+    server.stop 'clean'
+    # server.clean_shutdown is equivalent
+
+And finally, destroy it (it will force a shutdown first if running):
+
+    server.destroy
+
+# XenServer Host (Dom0) operations
+
+The are some operations that can be performed on the host, without retrieving
+and/or manipulating servers:
+
+Listing all the VBDs (virtual block devices):
+
+    # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VBD
+    conn.vbds.all
+
+This will retrieve the list of every single VBD available in the XenServer.
+
+Same thing applies to the virtual disk images:
+
+    conn.vdis.all
+
+Listing Storage Repositories (Xen SRs), where the disk images are stored:
+    
+    # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=SR
+    conn.storage_repositories
+
+
+XenServer Pools:
+
+    # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=pool
+    conn.pools
+
+
+Retrieve the default storage repository in a pool:
+
+    conn.pools.first.default_storage_repository
+    # or the equivalent conn.pools.first.default_sr
+

data/lib/fog/xenserver/examples/networks-and-vlans.rb

@@ -0,0 +1,45 @@
+require 'fog'                                                               
+
+#
+# Create the connection to the XenServer host
+#
+xenserver = Fog::Compute.new({
+  :provider           => 'XenServer',
+  :xenserver_url      => '1.2.3.4',
+  :xenserver_username => 'root',
+  :xenserver_password => 'secret',
+})
+
+# We have a bonded interface in XenServer, bond0 and
+# we want to add the VLANs there.
+# Note the VLAN ID -1, it is important since you
+# will problably have many PIFs with device == bond0
+# but we need the one without a proper VLAN ID
+#
+bondmaster_pif = xenserver.pifs.find do |pif| 
+  pif.vlan == "-1" and pif.device == "bond0"
+end
+
+# Another valid way of finding a PIF, without bonding
+# pif = xenserver.pifs.find { |pif| pif.physical and pif.device == 'eth0' }
+
+# We want to create these new VLANs
+vlans = [
+  { "name" => "VLAN 44", "vlanid" => 44},
+  { "name" => "VLAN 55", "vlanid" => 55}
+]
+
+
+vlans.each do |vlan|
+  # Do not create duplicated networks
+  if xenserver.networks.find { |n| n.name == vlan['name'] }
+    puts "Network #{vlan['name']} available, skipping"
+    next
+  end
+
+  puts "Craeting Network #{vlan['name']}, VLAN ID #{vlan['vlanid']}"
+  network = xenserver.networks.create :name => vlan['name']
+  xenserver.vlans.create :tag => vlan['vlanid'],
+                         :network => network,
+                         :pif => bondmaster_pif
+end