In Files

Parent

Class/Module Index [+]

Quicksearch

Fog::Compute::XenServer::Real

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/xenserver/compute.rb, line 80
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

Public Instance Methods

clone_server( server_name, template_ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/clone_server.rb, line 6
def clone_server( server_name, template_ref )
  # Clone the VM template
  if template_ref.kind_of? Fog::Compute::XenServer::Server
    template_ref = template_ref.reference
  end
  raise ArgumentError.new("Invalid template_ref") if template_ref.nil?
  raise ArgumentError.new("Invalid template_ref") if server_name.nil?

  ref = @connection.request(
    {:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.clone'},
    template_ref, server_name 
  )
end
create_network( name, config = {} ) click to toggle source

Create a Network

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=network

# File lib/fog/xenserver/requests/compute/create_network.rb, line 11
def create_network( name, config = {} )
  config.reject! { |k,v| v.nil? }

  default_config = { 
    :name_label => name, 
    # Description is mandatory in XenAPI but we default to empty
    :name_description => config[:description] || '',
    # Mandatory, but can be empty
    :other_config => {}
  }.merge config

  @connection.request(
    {
      :parser => Fog::Parsers::XenServer::Base.new, 
      :method => 'network.create'
    }, 
    default_config 
  )
end
create_server( name_label, template = nil, networks = [], extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/create_server.rb, line 74
def create_server( name_label, template = nil, networks = [], extra_args = {})
  if !networks.kind_of? Array
    raise "Invalid networks argument"
  end

  if template.kind_of? String
    template_string = template
    # try template by UUID 
    template = servers.templates.find { |s| s.uuid == template_string }
    if template.nil?
      # Try with the template name just in case
      template = servers.get get_vm_by_name(template_string)
    end
  end

  if template.nil?
    raise "Invalid template"
  end

  raise "Template #{template_string} does not exist" if template.allowed_operations.nil?
  raise 'Clone Operation not Allowed' unless template.allowed_operations.include?('clone')

  # Clone the VM template
  ref = clone_server name_label, template.reference
  # Add additional NICs
  networks.each do |n|
    create_vif ref, n.reference
  end
  if !extra_args[:auto_start] == false
    @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.provision'}, ref)
    start_vm( ref ) 
  end
  
  ref
end
create_server_raw(config = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/create_server.rb, line 10
def create_server_raw(config = {})
  config[:name_label] = config[:name] if config[:name]
  config.delete :name
  config[:affinity] = config[:__affinity] if config[:__affinity]
  config.delete :__affinity
  raise ArgumentError.new("Invalid :name_label attribute")              if !config[:name_label]
  raise ArgumentError.new("Invalid :affinity attribute")              if not config[:affinity]
  config[:affinity] = config[:affinity].reference              if config[:affinity].kind_of? Fog::Compute::XenServer::Host
  config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
  %{ VCPUs_at_startup 
      VCPUs_max 
      VCPUs_params
      PV_bootloader_args 
      PV_bootloader
      PV_kernel
      PV_ramdisk
      PV_legacy_args
      HVM_boot_params
      HVM_boot_params
  }.each do |k|
    if config[k.downcase.to_sym]
      config[k.to_sym] = config[k.downcase.to_sym]
      config.delete k.downcase.to_sym
    end
  end
  vm_record = {
    :name_label =>              '',
    :name_description =>        'description',
    :user_version =>            '0',
    :affinity =>                '',
    :is_a_template =>           true,
    :auto_power_on =>           false,
    :memory_static_max =>       '536870912',
    :memory_static_min =>       '536870912',
    :memory_dynamic_max =>      '536870912',
    :memory_dynamic_min =>      '536870912',
    :VCPUs_params =>            {},
    :VCPUs_max =>               '1',
    :VCPUs_at_startup =>        '1',
    :actions_after_shutdown =>  'Destroy',
    :actions_after_reboot =>    'Restart',
    :actions_after_crash =>     'Restart',
    :platform =>                { 'nx' => false, 'acpi' => true, 'apic' => 'true', 'pae' => true, 'viridian' => true},
    :platform =>                {},
    :other_config =>            {},
    :pool_name =>               '',
    :PV_bootloader =>           'pygrub', #pvgrub, eliloader
    :PV_kernel =>                '',
    :PV_ramdisk =>              '',
    :PV_args =>                 '-- quiet console=hvc0',
    :PV_bootloader_args =>      '',
    :PV_legacy_args =>          '',
    :HVM_boot_policy =>         '', 
    :HVM_boot_params =>         {},
    :PCI_bus =>                 '',
    :recommendations =>         '',
  }.merge config
  ref = @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.create' }, vm_record)
  ref
end
create_sr( host_ref, name_label, type, name_description = '', device_config = {}, physical_size = '0', content_type = 'user', shared = false, sm_config = {} ) click to toggle source

Create a storage repository (SR)

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=SR

@param [String] host_ref host reference @param [String] name_label repository label @param [String] type storage repository type @param [String] name_description storage repository description @param [Hash] device_config used to specify block device path, like { :device => /dev/sdb } for example @param [String] physical_size '0' will use the whole device (FIXME needs confirmation) @param [String] content_type the type of the SR's content. According to Citrix documentation, used only to distinguish ISO libraries from other SRs. Set it to 'iso' for storage repositories that store a library of ISOs, 'user' or " (empty) otherwise. @see docs.vmd.citrix.com/XenServer/6.1.0/1.0/en_gb/reference.html#cli-xe-commands_sr @param [String] shared

@return [String] an OpaqueRef to the storage repository

# File lib/fog/xenserver/requests/compute/create_sr.rb, line 28
def create_sr( host_ref,
               name_label, 
               type,
               name_description = '',
               device_config    = {}, 
               physical_size    = '0',
               content_type     = 'user', 
               shared           = false, 
               sm_config        = {} )

  @connection.request(
    {:parser => Fog::Parsers::XenServer::Base.new, :method => 'SR.create'}, 
    host_ref, 
    device_config || {}, 
    physical_size || '0', 
    name_label, 
    name_description || '',
    type,
    content_type, 
    shared || false,
    sm_config || {}
  )
end
create_vbd( vm_ref, vdi_ref, config = {} ) click to toggle source
# File lib/fog/xenserver/requests/compute/create_vbd.rb, line 7
def create_vbd( vm_ref, vdi_ref, config = {} )
  raise ArgumentError.new('Invalid config') if config.nil?
  vm_ref = vm_ref.reference if vm_ref.kind_of? Fog::Compute::XenServer::Server
  vdi_ref = vdi_ref.reference if vdi_ref.kind_of? Fog::Compute::XenServer::VDI
  config.reject! { |k,v| (k == :server) or (k == :vdi) }
  default_config = {
    :VM => vm_ref,
    :VDI => vdi_ref,
    :empty => false,
    :other_config => {'owner' => ''},
    :userdevice => "0",
    :bootable => true,
    :mode => 'RW',
    :qos_algorithm_type=> '',
    :qos_algorithm_params=> {},
    :qos_supported_algorithms=> [],
    :type => 'Disk'
  }.merge config

  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VBD.create'}, default_config )
end
create_vdi( config ) click to toggle source
# File lib/fog/xenserver/requests/compute/create_vdi.rb, line 7
def create_vdi( config )
  raise ArgumentError.new('Invalid config') if config.nil?
  raise ArgumentError.new('Missing virtual_size attribute') if config[:virtual_size].nil?
  raise ArgumentError.new('Missing read_only attribute') if config[:read_only].nil?
  raise ArgumentError.new('Missing type attribute') if config[:type].nil?
  raise ArgumentError.new('Missing sharable attribute') if config[:sharable].nil?
  raise ArgumentError.new('Missing other_config attribute') if config[:other_config].nil?
  raise ArgumentError.new('Missing storage_repository attribute') if config[:storage_repository].nil?
  config[:SR] = config[:storage_repository].reference
  config[:name_label] = config[:name]
  config[:name_description] = config[:description] if config[:description]
  config.reject! { |k,v| (k == :__sr) or (k == :storage_repository) }
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VDI.create'}, config )
end
create_vif( vm_ref, network_ref, device = -1) click to toggle source
# File lib/fog/xenserver/requests/compute/create_vif.rb, line 7
def create_vif( vm_ref, network_ref, device = -1)
  raise ArgumentError.new('Invalid vm_ref') if vm_ref.nil?
  raise ArgumentError.new('Invalid network_ref') if network_ref.nil?
  vm_ref = vm_ref.reference if vm_ref.kind_of? Fog::Model
  network_ref = network_ref.reference if network_ref.kind_of? Fog::Model
  vif_config = default_vif_config(vm_ref, network_ref, device.to_s)
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VIF.create'}, vif_config )
end
create_vif_custom( conf ) click to toggle source
# File lib/fog/xenserver/requests/compute/create_vif.rb, line 16
def create_vif_custom( conf )
  raise ArgumentError.new('VIF config is not a Hash') if not conf.kind_of?(Hash)
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VIF.create'}, conf )
end
create_vlan( pif_ref, vlan_id, network_ref ) click to toggle source

Create a VLAN

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VLAN

# File lib/fog/xenserver/requests/compute/create_vlan.rb, line 12
def create_vlan( pif_ref, vlan_id, network_ref )
  @connection.request(
    {
      :parser => Fog::Parsers::XenServer::Base.new, 
      :method => 'VLAN.create'
    }, 
    pif_ref,
    vlan_id.to_s,
    network_ref
  )
end
default_network() click to toggle source
# File lib/fog/xenserver/compute.rb, line 104
def default_network
  networks.find { |n| n.name == (@defaults[:network] || "Pool-wide network associated with eth0") }
end
default_template() click to toggle source
# File lib/fog/xenserver/compute.rb, line 97
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
default_template=(name) click to toggle source
# File lib/fog/xenserver/compute.rb, line 93
def default_template=(name)
  @defaults[:template] = name
end
default_vif_config( vm_ref, network_ref, device_number = '-1' ) click to toggle source
# File lib/fog/xenserver/requests/compute/create_vif.rb, line 21
def default_vif_config( vm_ref, network_ref, device_number = '-1' )
  conf = {
    'MAC_autogenerated' => 'True',
    'VM' => vm_ref,
    'network' => network_ref,
    'MAC' => '',
    'MTU' => '0',
    'other_config' => {},
    'qos_algorithm_type' => 'ratelimit',
    'qos_algorithm_params' => {}
  }
  if device_number.to_i >= 0
    conf['device'] = device_number
  else
    highest_dev = 0
    server = servers.get vm_ref
    server.vifs.each do |vif|
      dev = vif.device.to_i
      highest_dev = dev if dev > highest_dev
    end
    conf['device'] = (highest_dev + 1).to_s
  end
  conf
end
destroy_network( ref ) click to toggle source

Destroy a Network

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=network

# File lib/fog/xenserver/requests/compute/destroy_network.rb, line 12
def destroy_network( ref )
  @connection.request(
    {
      :parser => Fog::Parsers::XenServer::Base.new, 
      :method => 'network.destroy'
    }, 
    ref
  )
end
destroy_server( vm_ref , extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/destroy_server.rb, line 7
def destroy_server( vm_ref , extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.destroy'}, vm_ref)
end
destroy_sr( sr_ref ) click to toggle source

Destroy a Storage Repository

docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=SR

# File lib/fog/xenserver/requests/compute/destroy_sr.rb, line 12
def destroy_sr( sr_ref )
  @connection.request(
    {:parser => Fog::Parsers::XenServer::Base.new, :method => 'SR.destroy'}, 
    sr_ref
  )
end
destroy_vdi( vdi_ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/destroy_vdi.rb, line 7
def destroy_vdi( vdi_ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VDI.destroy'}, vdi_ref)
end
destroy_vif( ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/destroy_vif.rb, line 7
def destroy_vif( ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VIF.destroy'}, ref)
end
destroy_vlan( ref ) click to toggle source

Destroy a VLAN

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VLAN

# File lib/fog/xenserver/requests/compute/destroy_vlan.rb, line 11
def destroy_vlan( ref )
  @connection.request(
    {
      :parser => Fog::Parsers::XenServer::Base.new, 
      :method => 'VLAN.destroy'
    }, 
    ref
  )
end
disable_host( ref ) click to toggle source

Puts the host into a state in which no new VMs can be started. Currently active VMs on the host continue to execute.

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host

# File lib/fog/xenserver/requests/compute/disable_host.rb, line 13
def disable_host( ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "host.disable"}, ref)
end
eject_vbd(ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/eject_vbd.rb, line 7
def eject_vbd(ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VBD.eject'}, ref)
end
enable_host( ref ) click to toggle source

Puts the host into a state in which VMs can be started.

@see docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=host

# File lib/fog/xenserver/requests/compute/enable_host.rb, line 12
def enable_host( ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "host.enable"}, ref)
end
get_record( ref, klass, options = {} ) click to toggle source
# File lib/fog/xenserver/requests/compute/get_record.rb, line 9
def get_record( ref, klass, options = {} )
  get_record_by_ref ref, klass, options
end
get_record_by_ref( ref, klass, options = {} ) click to toggle source
# File lib/fog/xenserver/requests/compute/get_record.rb, line 13
def get_record_by_ref( ref, klass, options = {} )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "#{klass}.get_record"}, ref).merge(:reference => ref)
end
get_records( klass, options = {} ) click to toggle source
# File lib/fog/xenserver/requests/compute/get_records.rb, line 9
def get_records( klass, options = {} )
  begin
    res = @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "#{klass}.get_all_records")
    res
  rescue Fog::XenServer::RequestFailed => e
    []
  end
end
get_vm_by_name(label) click to toggle source
# File lib/fog/xenserver/requests/compute/create_server.rb, line 6
def get_vm_by_name(label)
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.get_by_name_label' }, label)
end
insert_vbd(ref, vdi_ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/insert_vbd.rb, line 7
def insert_vbd(ref, vdi_ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VBD.insert'}, ref, vdi_ref)
end
provision_server( ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/provision_server.rb, line 6
def provision_server( ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.provision'}, ref)
end
reboot_host( ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/reboot_host.rb, line 7
def reboot_host( ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "host.reboot"}, ref)
end
reboot_server( ref, stype = 'clean' ) click to toggle source
# File lib/fog/xenserver/requests/compute/reboot_server.rb, line 7
def reboot_server( ref, stype = 'clean' )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VM.#{stype}_shutdown"}, ref)
end
reload() click to toggle source
# File lib/fog/xenserver/compute.rb, line 89
def reload
  @connection.authenticate(@username, @password)
end
scan_sr( ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/scan_sr.rb, line 7
def scan_sr( ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'SR.scan'}, ref)
end
set_affinity( host_ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/set_affinity.rb, line 9
def set_affinity( host_ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.set_affinity'}, host_ref)
end
set_attribute( klass, ref, attr_name, *value ) click to toggle source
# File lib/fog/xenserver/requests/compute/set_attribute.rb, line 9
def set_attribute( klass, ref, attr_name, *value )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "#{klass}.set_#{attr_name.gsub('-','_')}"}, ref, *value)
end
shutdown_host( ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/shutdown_host.rb, line 7
def shutdown_host( ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "host.shutdown"}, ref)
end
shutdown_server( vm_ref, stype = 'clean' ) click to toggle source
# File lib/fog/xenserver/requests/compute/shutdown_server.rb, line 7
def shutdown_server( vm_ref, stype = 'clean' )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VM.#{stype}_shutdown"}, vm_ref)
end
start_server( vm_ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/start_server.rb, line 7
def start_server( vm_ref )
  start_vm( vm_ref )
end
start_vm( vm_ref ) click to toggle source

bit.ly/8ZPyCN VM.start( session, VM_ref, start_paused, force)

# File lib/fog/xenserver/requests/compute/start_vm.rb, line 9
def start_vm( vm_ref )
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.start'}, vm_ref, false, false)
end
unplug_force_vbd(ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/unplug_vbd.rb, line 11
def unplug_force_vbd(ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VBD.unplug_force'}, ref)
end
unplug_pbd( ref ) click to toggle source
# File lib/fog/xenserver/requests/compute/unplug_pbd.rb, line 7
def unplug_pbd( ref )
  @connection.request(
    {:parser => Fog::Parsers::XenServer::Base.new, :method => 'PBD.unplug'}, 
    ref
  )
end
unplug_vbd( vbd_ref, extra_args = {}) click to toggle source
# File lib/fog/xenserver/requests/compute/unplug_vbd.rb, line 7
def unplug_vbd( vbd_ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VBD.unplug'}, vbd_ref)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.