class Fog::Compute::XenServer::Real

Attributes

host[R]
username[R]

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/compute/xen_server/real.rb, line 7
def initialize(options={})
  @host        = options[:xenserver_url]
  @username    = options[:xenserver_username]
  @password    = options[:xenserver_password]
  @defaults    = options[:xenserver_defaults] || {}
  @timeout     = options[:xenserver_timeout] || 30
  @connection  = Fog::XenServer::Connection.new(@host, @timeout)
  @connection.authenticate(@username, @password)
end

Public Instance Methods

add_ipv4_allowed_vif(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/add_ipv4_allowed_vif.rb, line 5
def add_ipv4_allowed_vif(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.add_ipv4_allowed" }, ref, value)
end
add_ipv6_allowed_vif(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/add_ipv6_allowed_vif.rb, line 5
def add_ipv6_allowed_vif(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.add_ipv6_allowed" }, ref, value)
end
add_to_vcpus_params_live_server(ref, key, value) click to toggle source
# File lib/fog/compute/xen_server/requests/add_to_vcpus_params_live_server.rb, line 5
def add_to_vcpus_params_live_server(ref, key, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.add_to_VCPUs_params_live" }, ref, key, value)
end
Also aliased as: add_to_vcpus_params_live_vm
add_to_vcpus_params_live_vm(ref, key, value)
apply_edition_host(ref, edition, force) click to toggle source
# File lib/fog/compute/xen_server/requests/apply_edition_host.rb, line 5
def apply_edition_host(ref, edition, force)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.apply_edition" }, ref, edition, force)
end
apply_edition_pool(ref, edition) click to toggle source
# File lib/fog/compute/xen_server/requests/apply_edition_pool.rb, line 5
def apply_edition_pool(ref, edition)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.apply_edition" }, ref, edition)
end
assert_agile_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_agile_server.rb, line 5
def assert_agile_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.assert_agile" }, ref)
end
Also aliased as: assert_agile_vm
assert_agile_vm(ref)
Alias for: assert_agile_server
assert_attachable_vbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_attachable_vbd.rb, line 5
def assert_attachable_vbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.assert_attachable" }, ref)
end
assert_can_be_recovered_server(ref, session_to) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_can_be_recovered_server.rb, line 5
def assert_can_be_recovered_server(ref, session_to)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.assert_can_be_recovered" }, ref, session_to)
end
Also aliased as: assert_can_be_recovered_vm
assert_can_be_recovered_vm(ref, session_to)
assert_can_boot_here_server(ref, host) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_can_boot_here_server.rb, line 5
def assert_can_boot_here_server(ref, host)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.assert_can_boot_here" }, ref, host)
end
Also aliased as: assert_can_boot_here_vm
assert_can_boot_here_vm(ref, host)
assert_can_evacuate_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_can_evacuate_host.rb, line 5
def assert_can_evacuate_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.assert_can_evacuate" }, ref)
end
assert_can_host_ha_statefile_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_can_host_ha_statefile_sr.rb, line 5
def assert_can_host_ha_statefile_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.assert_can_host_ha_statefile" }, ref)
end
assert_can_migrate_server(ref, dest, live, vdi_map, vif_map, options) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_can_migrate_server.rb, line 5
def assert_can_migrate_server(ref, dest, live, vdi_map, vif_map, options)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.assert_can_migrate" }, ref, dest, live, vdi_map, vif_map, options)
end
Also aliased as: assert_can_migrate_vm
assert_can_migrate_vm(ref, dest, live, vdi_map, vif_map, options)
assert_operation_valid_server(ref, op) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_operation_valid_server.rb, line 5
def assert_operation_valid_server(ref, op)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.assert_operation_valid" }, ref, op)
end
Also aliased as: assert_operation_valid_vm
assert_operation_valid_vm(ref, op)
assert_supports_database_replication_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/assert_supports_database_replication_sr.rb, line 5
def assert_supports_database_replication_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.assert_supports_database_replication" }, ref)
end
backup_rrds_host(ref, delay) click to toggle source
# File lib/fog/compute/xen_server/requests/backup_rrds_host.rb, line 5
def backup_rrds_host(ref, delay)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.backup_rrds" }, ref, delay)
end
bugreport_upload_host(ref, url, options) click to toggle source
# File lib/fog/compute/xen_server/requests/bugreport_upload_host.rb, line 5
def bugreport_upload_host(ref, url, options)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.bugreport_upload" }, ref, url, options)
end
builtin_templates() click to toggle source
# File lib/fog/compute/xen_server/requests/builtin_templates.rb, line 5
def builtin_templates
  data = @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "VM.get_all_records")
  data.delete_if { |vm| !vm[:is_a_template] || vm[:other_config]["default_template"].nil? }
  servers.load(data)
rescue Fog::XenServer::RequestFailed => e
  []
end
call_plugin_host(ref, plugin, fn, args) click to toggle source
# File lib/fog/compute/xen_server/requests/call_plugin_host.rb, line 5
def call_plugin_host(ref, plugin, fn, args)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.call_plugin" }, ref, plugin, fn, args)
end
certificate_install_pool(name, cert) click to toggle source
# File lib/fog/compute/xen_server/requests/certificate_install_pool.rb, line 5
def certificate_install_pool(name, cert)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.certificate_install" }, name, cert)
end
certificate_list_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/certificate_list_pool.rb, line 5
def certificate_list_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.certificate_list")
end
certificate_sync_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/certificate_sync_pool.rb, line 5
def certificate_sync_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.certificate_sync")
end
certificate_uninstall_pool(string) click to toggle source
# File lib/fog/compute/xen_server/requests/certificate_uninstall_pool.rb, line 5
def certificate_uninstall_pool(string)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.certificate_uninstall" }, string)
end
checkpoint_server(ref, new_name) click to toggle source
# File lib/fog/compute/xen_server/requests/checkpoint_server.rb, line 5
def checkpoint_server(ref, new_name)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.checkpoint" }, ref, new_name)
end
Also aliased as: checkpoint_vm
checkpoint_vm(ref, new_name)
Alias for: checkpoint_server
clean_reboot_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/clean_reboot_server.rb, line 5
def clean_reboot_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.clean_reboot" }, ref)
end
Also aliased as: clean_reboot_vm, clean_reboot_vm
clean_reboot_vm(ref)
Alias for: clean_reboot_server
clean_shutdown_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/clean_shutdown_server.rb, line 5
def clean_shutdown_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.clean_shutdown" }, ref)
end
Also aliased as: clean_shutdown_vm
clean_shutdown_vm(ref)
clone_server(ref, new_name) click to toggle source
# File lib/fog/compute/xen_server/requests/clone_server.rb, line 5
def clone_server(ref, new_name)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.clone" }, ref, new_name)
end
Also aliased as: clone_vm
clone_vdi(ref, driver_params) click to toggle source
# File lib/fog/compute/xen_server/requests/clone_vdi.rb, line 5
def clone_vdi(ref, driver_params)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.clone" }, ref, driver_params)
end
clone_vm(ref, new_name)
Alias for: clone_server
compute_free_memory_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/compute_free_memory_host.rb, line 5
def compute_free_memory_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.compute_free_memory" }, ref)
end
compute_memory_overhead_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/compute_memory_overhead_host.rb, line 5
def compute_memory_overhead_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.compute_memory_overhead" }, ref)
end
compute_memory_overhead_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/compute_memory_overhead_server.rb, line 5
def compute_memory_overhead_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.compute_memory_overhead" }, ref)
end
Also aliased as: compute_memory_overhead_vm
compute_memory_overhead_vm(ref)
connection_host() click to toggle source
# File lib/fog/compute/xen_server/real.rb, line 40
def connection_host
  hosts.find { |x| x.address == host }
end
copy_bios_strings_server(ref, host) click to toggle source
# File lib/fog/compute/xen_server/requests/copy_bios_strings_server.rb, line 5
def copy_bios_strings_server(ref, host)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.copy_bios_strings" }, ref, host)
end
Also aliased as: copy_bios_strings_vm
copy_bios_strings_vm(ref, host)
copy_server(ref, name, sr) click to toggle source
# File lib/fog/compute/xen_server/requests/copy_server.rb, line 5
def copy_server(ref, name, sr)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.copy" }, ref, name, sr)
end
Also aliased as: copy_vm
copy_vdi(ref, sr) click to toggle source
# File lib/fog/compute/xen_server/requests/copy_vdi.rb, line 5
def copy_vdi(ref, sr)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.copy" }, ref, sr)
end
copy_vm(ref, name, sr)
Alias for: copy_server
create_network(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_network.rb, line 5
def create_network(config = {}, extra_params = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "network.create" }, config)
end
create_new_blob_host(ref, name, mime_type, public) click to toggle source
# File lib/fog/compute/xen_server/requests/create_new_blob_host.rb, line 5
def create_new_blob_host(ref, name, mime_type, public)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.create_new_blob" }, ref, name, mime_type, public)
end
create_new_blob_network(ref, name, mime_type, public) click to toggle source
# File lib/fog/compute/xen_server/requests/create_new_blob_network.rb, line 5
def create_new_blob_network(ref, name, mime_type, public)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "network.create_new_blob" }, ref, name, mime_type, public)
end
create_new_blob_pool(ref, name, mime_type, public) click to toggle source
# File lib/fog/compute/xen_server/requests/create_new_blob_pool.rb, line 5
def create_new_blob_pool(ref, name, mime_type, public)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.create_new_blob" }, ref, name, mime_type, public)
end
create_new_blob_server(ref, name, mime_type, public) click to toggle source
# File lib/fog/compute/xen_server/requests/create_new_blob_server.rb, line 5
def create_new_blob_server(ref, name, mime_type, public)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.create_new_blob" }, ref, name, mime_type, public)
end
Also aliased as: create_new_blob_vm
create_new_blob_sr(ref, name, mime_type, public) click to toggle source
# File lib/fog/compute/xen_server/requests/create_new_blob_sr.rb, line 5
def create_new_blob_sr(ref, name, mime_type, public)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.create_new_blob" }, ref, name, mime_type, public)
end
create_new_blob_vm(ref, name, mime_type, public)
create_server(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_server.rb, line 5
def create_server(config = {}, extra_params = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VM.create" }, config)
end
Also aliased as: create_vm
create_sr(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_sr.rb, line 5
def create_sr(config = {}, extra_params = {})
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.create" },
                      extra_params[:host_ref], extra_params[:device_config], config[:physical_size],
                      config[:name], config[:description], config[:type], config[:content_type],
                      config[:shared], config[:sm_config])
end
create_vbd(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_vbd.rb, line 5
def create_vbd(config = {}, extra_params = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.create"}, config)
end
create_vdi(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_vdi.rb, line 5
def create_vdi(config = {}, extra_params = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.create"}, config)
end
create_vif(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_vif.rb, line 5
def create_vif(config = {}, extra_params = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.create"}, config )
end
create_vlan(config = {}, extra_params = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/create_vlan.rb, line 5
def create_vlan(config = {}, extra_params = {})
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VLAN.create" },
                      extra_params[:pif_ref], config[:tag].to_s, extra_params[:network_ref])
end
create_vlan_from_pif_pool(pif, network, vlan) click to toggle source
# File lib/fog/compute/xen_server/requests/create_vlan_from_pif_pool.rb, line 5
def create_vlan_from_pif_pool(pif, network, vlan)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.create_VLAN_from_PIF" }, pif, network, vlan)
end
create_vlan_pool(device, network, vlan) click to toggle source
# File lib/fog/compute/xen_server/requests/create_vlan_pool.rb, line 5
def create_vlan_pool(device, network, vlan)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.create_VLAN" }, device, network, vlan)
end
create_vm(config = {}, extra_params = {})
Alias for: create_server
credentials() click to toggle source
# File lib/fog/compute/xen_server/real.rb, line 36
def credentials
  @connection.credentials
end
crl_install_pool(name, cert) click to toggle source
# File lib/fog/compute/xen_server/requests/crl_install_pool.rb, line 5
def crl_install_pool(name, cert)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.crl_install" }, name, cert)
end
crl_list_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/crl_list_pool.rb, line 5
def crl_list_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.crl_list")
end
crl_uninstall_pool(name) click to toggle source
# File lib/fog/compute/xen_server/requests/crl_uninstall_pool.rb, line 5
def crl_uninstall_pool(name)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.crl_uninstall" }, name)
end
custom_templates() click to toggle source
# File lib/fog/compute/xen_server/requests/custom_templates.rb, line 5
def custom_templates
  data = @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "VM.get_all_records")
  data.keep_if { |vm| vm[:is_a_template] && vm[:other_config]["default_template"].nil? }
  servers.load(data)
rescue Fog::XenServer::RequestFailed => e
  []
end
db_forget_pif(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/db_forget_pif.rb, line 5
def db_forget_pif(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.db_forget" }, ref)
end
db_forget_vdi(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/db_forget_vdi.rb, line 5
def db_forget_vdi(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.db_forget" }, ref)
end
db_introduce_pif(device, network, host, mac, mtu, vlan, physical, ip_configuration_mode, ip, netmask, gateway, dns, bond_slave_of, vlan_master_of, management, other_config, disallow_unplug, ipv6_configuration_mode, ipv6, ipv6_gateway, primary_address_type) click to toggle source
# File lib/fog/compute/xen_server/requests/db_introduce_pif.rb, line 5
def db_introduce_pif(device, network, host, mac, mtu, vlan, physical, ip_configuration_mode, ip, netmask, gateway, dns, bond_slave_of, vlan_master_of, management, other_config, disallow_unplug, ipv6_configuration_mode, ipv6, ipv6_gateway, primary_address_type)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.db_introduce" }, device, network, host, mac, mtu, vlan, physical, ip_configuration_mode, ip, netmask, gateway, dns, bond_slave_of, vlan_master_of, management, other_config, disallow_unplug, ipv6_configuration_mode, ipv6, ipv6_gateway, primary_address_type)
end
db_introduce_vdi(uuid, name_label, name_description, sr, type, sharable, read_only, other_config, location, xenstore_data, sm_config, managed, virtual_size, physical_utilisation, metadata_of_pool, is_a_snapshot, snapshot_time, snapshot_of) click to toggle source
# File lib/fog/compute/xen_server/requests/db_introduce_vdi.rb, line 5
def db_introduce_vdi(uuid, name_label, name_description, sr, type, sharable, read_only, other_config, location, xenstore_data, sm_config, managed, virtual_size, physical_utilisation, metadata_of_pool, is_a_snapshot, snapshot_time, snapshot_of)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.db_introduce" }, uuid, name_label, name_description, sr, type, sharable, read_only, other_config, location, xenstore_data, sm_config, managed, virtual_size, physical_utilisation, metadata_of_pool, is_a_snapshot, snapshot_time, snapshot_of)
end
declare_dead_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/declare_dead_host.rb, line 5
def declare_dead_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.declare_dead" }, ref)
end
default_network() click to toggle source
# File lib/fog/compute/xen_server/real.rb, line 32
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/compute/xen_server/real.rb, line 25
def default_template
  return nil if @defaults[:template].nil?
  (custom_templates + 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/compute/xen_server/real.rb, line 21
def default_template=(name)
  @defaults[:template] = name
end
designate_new_master_pool(host) click to toggle source
# File lib/fog/compute/xen_server/requests/designate_new_master_pool.rb, line 5
def designate_new_master_pool(host)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.designate_new_master" }, host)
end
destroy_record(ref, provider_class) click to toggle source
# File lib/fog/compute/xen_server/requests/destroy_record.rb, line 5
def destroy_record(ref, provider_class)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "#{provider_class}.destroy" }, ref)
end
detect_nonhomogeneous_external_auth_pool(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/detect_nonhomogeneous_external_auth_pool.rb, line 5
def detect_nonhomogeneous_external_auth_pool(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.detect_nonhomogeneous_external_auth" }, ref)
end
disable_database_replication_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/disable_database_replication_sr.rb, line 5
def disable_database_replication_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.disable_database_replication" }, ref)
end
disable_external_auth_host(ref, config) click to toggle source
# File lib/fog/compute/xen_server/requests/disable_external_auth_host.rb, line 5
def disable_external_auth_host(ref, config)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.disable_external_auth" }, ref, config)
end
disable_external_auth_pool(ref, config) click to toggle source
# File lib/fog/compute/xen_server/requests/disable_external_auth_pool.rb, line 5
def disable_external_auth_pool(ref, config)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.disable_external_auth" }, ref, config)
end
disable_ha_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/disable_ha_pool.rb, line 5
def disable_ha_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.disable_ha")
end
disable_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/disable_host.rb, line 5
def disable_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.disable" }, ref)
end
disable_local_storage_caching_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/disable_local_storage_caching_host.rb, line 5
def disable_local_storage_caching_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.disable_local_storage_caching" }, ref)
end
disable_local_storage_caching_pool(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/disable_local_storage_caching_pool.rb, line 5
def disable_local_storage_caching_pool(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.disable_local_storage_caching" }, ref)
end
disable_redo_log_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/disable_redo_log_pool.rb, line 5
def disable_redo_log_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.disable_redo_log")
end
dmesg_clear_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/dmesg_clear_host.rb, line 5
def dmesg_clear_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.dmesg_clear" }, ref)
end
dmesg_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/dmesg_host.rb, line 5
def dmesg_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.dmesg" }, ref)
end
eject_pool(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/eject_pool.rb, line 5
def eject_pool(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.eject" }, ref)
end
eject_vbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/eject_vbd.rb, line 5
def eject_vbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.eject" }, ref)
end
emergency_ha_disable_host() click to toggle source
# File lib/fog/compute/xen_server/requests/emergency_ha_disable_host.rb, line 5
def emergency_ha_disable_host
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "host.emergency_ha_disable")
end
emergency_reset_master_pool(master_address) click to toggle source
# File lib/fog/compute/xen_server/requests/emergency_reset_master_pool.rb, line 5
def emergency_reset_master_pool(master_address)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.emergency_reset_master" }, master_address)
end
emergency_transition_to_master_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/emergency_transition_to_master_pool.rb, line 5
def emergency_transition_to_master_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.emergency_transition_to_master")
end
enable_database_replication_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_database_replication_sr.rb, line 5
def enable_database_replication_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.enable_database_replication" }, ref)
end
enable_external_auth_host(ref, config, name, auth_type) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_external_auth_host.rb, line 5
def enable_external_auth_host(ref, config, name, auth_type)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.enable_external_auth" }, ref, config, name, auth_type)
end
enable_external_auth_pool(ref, config, service_name, auth_type) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_external_auth_pool.rb, line 5
def enable_external_auth_pool(ref, config, service_name, auth_type)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.enable_external_auth" }, ref, config, service_name, auth_type)
end
enable_ha_pool(heartbeat_srs, configuration) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_ha_pool.rb, line 5
def enable_ha_pool(heartbeat_srs, configuration)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.enable_ha" }, heartbeat_srs, configuration)
end
enable_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_host.rb, line 5
def enable_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.enable" }, ref)
end
enable_local_storage_caching_host(ref, sr) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_local_storage_caching_host.rb, line 5
def enable_local_storage_caching_host(ref, sr)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.enable_local_storage_caching" }, ref, sr)
end
enable_local_storage_caching_pool(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_local_storage_caching_pool.rb, line 5
def enable_local_storage_caching_pool(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.enable_local_storage_caching" }, ref)
end
enable_redo_log_pool(sr) click to toggle source
# File lib/fog/compute/xen_server/requests/enable_redo_log_pool.rb, line 5
def enable_redo_log_pool(sr)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.enable_redo_log" }, sr)
end
evacuate_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/evacuate_host.rb, line 5
def evacuate_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.evacuate" }, ref)
end
forget_data_source_archives_host(ref, data_source) click to toggle source
# File lib/fog/compute/xen_server/requests/forget_data_source_archives_host.rb, line 5
def forget_data_source_archives_host(ref, data_source)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.forget_data_source_archives" }, ref, data_source)
end
forget_data_source_archives_server(ref, data_source) click to toggle source
# File lib/fog/compute/xen_server/requests/forget_data_source_archives_server.rb, line 5
def forget_data_source_archives_server(ref, data_source)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.forget_data_source_archives" }, ref, data_source)
end
forget_data_source_archives_vm(ref, data_source)
forget_pif(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/forget_pif.rb, line 5
def forget_pif(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.forget" }, ref)
end
forget_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/forget_sr.rb, line 5
def forget_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.forget" }, ref)
end
forget_vdi(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/forget_vdi.rb, line 5
def forget_vdi(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.forget" }, ref)
end
get_allowed_vbd_devices_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_allowed_vbd_devices_server.rb, line 5
def get_allowed_vbd_devices_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.get_allowed_VBD_devices" }, ref)
end
Also aliased as: get_allowed_vbd_devices_vm
get_allowed_vbd_devices_vm(ref)
get_allowed_vif_devices_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_allowed_vif_devices_server.rb, line 5
def get_allowed_vif_devices_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.get_allowed_VIF_devices" }, ref)
end
Also aliased as: get_allowed_vif_devices_vm
get_allowed_vif_devices_vm(ref)
get_boot_record_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_boot_record_server.rb, line 5
def get_boot_record_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.get_boot_record" }, ref)
end
Also aliased as: get_boot_record_vm
get_boot_record_vm(ref)
get_by_name(name, provider_class) click to toggle source
# File lib/fog/compute/xen_server/requests/get_record.rb, line 13
def get_by_name(name, provider_class)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "#{provider_class}.get_by_name_label" }, name)
end
get_by_uuid(uuid, provider_class) click to toggle source
# File lib/fog/compute/xen_server/requests/get_record.rb, line 17
def get_by_uuid(uuid, provider_class)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "#{provider_class}.get_by_uuid" }, uuid)
end
get_data_sources_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_data_sources_host.rb, line 5
def get_data_sources_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_data_sources" }, ref)
end
get_data_sources_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_data_sources_server.rb, line 5
def get_data_sources_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.get_data_sources" }, ref)
end
Also aliased as: get_data_sources_vm
get_data_sources_vm(ref)
get_license_state_pool(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_license_state_pool.rb, line 5
def get_license_state_pool(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.get_license_state" }, ref)
end
get_log_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_log_host.rb, line 5
def get_log_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_log" }, ref)
end
get_management_interface_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_management_interface_host.rb, line 5
def get_management_interface_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_management_interface" }, ref)
end
get_possible_hosts_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_possible_hosts_server.rb, line 5
def get_possible_hosts_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.get_possible_hosts" }, ref)
end
Also aliased as: get_possible_hosts_vm
get_possible_hosts_vm(ref)
get_record(ref, provider_class, options = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/get_record.rb, line 5
def get_record(ref, provider_class, options = {})
  get_record_by_ref(ref, provider_class, options)
end
get_record_by_ref(ref, provider_class, options = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/get_record.rb, line 9
def get_record_by_ref(ref, provider_class, options = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "#{provider_class}.get_record"}, ref).merge(:reference => ref)
end
get_records(klass, options = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/get_records.rb, line 5
def get_records(klass, options = {})
  @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "#{klass}.get_all_records")
rescue Fog::XenServer::RequestFailed => e
  []
end
get_server_certificate_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_server_certificate_host.rb, line 5
def get_server_certificate_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_server_certificate" }, ref)
end
get_server_localtime_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_server_localtime_host.rb, line 5
def get_server_localtime_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_server_localtime" }, ref)
end
get_servertime_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_servertime_host.rb, line 5
def get_servertime_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_servertime" }, ref)
end
get_supported_types_sr() click to toggle source
# File lib/fog/compute/xen_server/requests/get_supported_types_sr.rb, line 5
def get_supported_types_sr
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "SR.get_supported_types")
end
get_system_status_capabilities_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_system_status_capabilities_host.rb, line 5
def get_system_status_capabilities_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_system_status_capabilities" }, ref)
end
get_vms_which_prevent_evacuation_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/get_vms_which_prevent_evacuation_host.rb, line 5
def get_vms_which_prevent_evacuation_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.get_vms_which_prevent_evacuation" }, ref)
end
ha_compute_hypothetical_max_host_failures_to_tolerate_pool(configuration) click to toggle source
# File lib/fog/compute/xen_server/requests/ha_compute_hypothetical_max_host_failures_to_tolerate_pool.rb, line 5
def ha_compute_hypothetical_max_host_failures_to_tolerate_pool(configuration)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.ha_compute_hypothetical_max_host_failures_to_tolerate" }, configuration)
end
ha_compute_max_host_failures_to_tolerate_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/ha_compute_max_host_failures_to_tolerate_pool.rb, line 5
def ha_compute_max_host_failures_to_tolerate_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.ha_compute_max_host_failures_to_tolerate")
end
ha_compute_vm_failover_plan_pool(failed_hosts, failed_vms) click to toggle source
# File lib/fog/compute/xen_server/requests/ha_compute_vm_failover_plan_pool.rb, line 5
def ha_compute_vm_failover_plan_pool(failed_hosts, failed_vms)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.ha_compute_vm_failover_plan" }, failed_hosts, failed_vms)
end
ha_failover_plan_exists_pool(n) click to toggle source
# File lib/fog/compute/xen_server/requests/ha_failover_plan_exists_pool.rb, line 5
def ha_failover_plan_exists_pool(n)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.ha_failover_plan_exists" }, n)
end
ha_prevent_restarts_for_pool(seconds) click to toggle source
# File lib/fog/compute/xen_server/requests/ha_prevent_restarts_for_pool.rb, line 5
def ha_prevent_restarts_for_pool(seconds)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.ha_prevent_restarts_for" }, seconds)
end
hard_reboot_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/hard_reboot_server.rb, line 5
def hard_reboot_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.hard_reboot" }, ref)
end
Also aliased as: hard_reboot_vm, hard_reboot_vm
hard_reboot_vm(ref)
Alias for: hard_reboot_server
hard_shutdown_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/hard_shutdown_server.rb, line 5
def hard_shutdown_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.hard_shutdown" }, ref)
end
Also aliased as: hard_shutdown_vm
hard_shutdown_vm(ref)
import_convert_server(type, username, password, sr, remote_config) click to toggle source
# File lib/fog/compute/xen_server/requests/import_convert_server.rb, line 5
def import_convert_server(type, username, password, sr, remote_config)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.import_convert" }, type, username, password, sr, remote_config)
end
Also aliased as: import_convert_vm
import_convert_vm(type, username, password, sr, remote_config)
insert_vbd(ref, vdi) click to toggle source
# File lib/fog/compute/xen_server/requests/insert_vbd.rb, line 5
def insert_vbd(ref, vdi)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.insert" }, ref, vdi)
end
introduce_pif(host, mac, device) click to toggle source
# File lib/fog/compute/xen_server/requests/introduce_pif.rb, line 5
def introduce_pif(host, mac, device)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.introduce" }, host, mac, device)
end
introduce_sr(uuid, name_label, name_description, typecontent, sahred, sm_config) click to toggle source
# File lib/fog/compute/xen_server/requests/introduce_sr.rb, line 5
def introduce_sr(uuid, name_label, name_description, typecontent, sahred, sm_config)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.introduce" }, uuid, name_label, name_description, typecontent, sahred, sm_config)
end
introduce_vdi(uuid, name_label, name_description, sr, type, sharable, read_only, other_config, location, xenstore_data, sm_config, managed, virtual_size, physical_utilisation, metadata_of_pool, is_a_snapshot, snapshot_time, snapshot_of) click to toggle source
# File lib/fog/compute/xen_server/requests/introduce_vdi.rb, line 5
def introduce_vdi(uuid, name_label, name_description, sr, type, sharable, read_only, other_config, location, xenstore_data, sm_config, managed, virtual_size, physical_utilisation, metadata_of_pool, is_a_snapshot, snapshot_time, snapshot_of)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.introduce" }, uuid, name_label, name_description, sr, type, sharable, read_only, other_config, location, xenstore_data, sm_config, managed, virtual_size, physical_utilisation, metadata_of_pool, is_a_snapshot, snapshot_time, snapshot_of)
end
join_force_pool(master_address, master_username, master_password) click to toggle source
# File lib/fog/compute/xen_server/requests/join_force_pool.rb, line 5
def join_force_pool(master_address, master_username, master_password)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.join_force" }, master_address, master_username, master_password)
end
join_pool(master_address, master_username, master_password) click to toggle source
# File lib/fog/compute/xen_server/requests/join_pool.rb, line 5
def join_pool(master_address, master_username, master_password)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.join" }, master_address, master_username, master_password)
end
list_methods_host() click to toggle source
# File lib/fog/compute/xen_server/requests/list_methods_host.rb, line 5
def list_methods_host
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "host.list_methods")
end
local_management_reconfigure_host(interface) click to toggle source
# File lib/fog/compute/xen_server/requests/local_management_reconfigure_host.rb, line 5
def local_management_reconfigure_host(interface)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.local_management_reconfigure" }, interface)
end
management_disable_host() click to toggle source
# File lib/fog/compute/xen_server/requests/management_disable_host.rb, line 5
def management_disable_host
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "host.management_disable")
end
management_reconfigure_host(pif) click to toggle source
# File lib/fog/compute/xen_server/requests/management_reconfigure_host.rb, line 5
def management_reconfigure_host(pif)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.management_reconfigure" }, pif)
end
maximise_memory_server(ref, total, approximate) click to toggle source
# File lib/fog/compute/xen_server/requests/maximise_memory_server.rb, line 5
def maximise_memory_server(ref, total, approximate)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.maximise_memory" }, ref, total, approximate)
end
Also aliased as: maximise_memory_vm
maximise_memory_vm(ref, total, approximate)
migrate_receive_host(ref, network, options) click to toggle source
# File lib/fog/compute/xen_server/requests/migrate_receive_host.rb, line 5
def migrate_receive_host(ref, network, options)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.migrate_receive" }, ref, network, options)
end
migrate_send_server(ref, dest, live, vdi_map, vif_map, options) click to toggle source
# File lib/fog/compute/xen_server/requests/migrate_send_server.rb, line 5
def migrate_send_server(ref, dest, live, vdi_map, vif_map, options)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.migrate_send" }, ref, dest, live, vdi_map, vif_map, options)
end
Also aliased as: migrate_send_vm
migrate_send_vm(ref, dest, live, vdi_map, vif_map, options)
Alias for: migrate_send_server
open_database_vdi(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/open_database_vdi.rb, line 5
def open_database_vdi(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.open_database" }, ref)
end
pause_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/pause_server.rb, line 5
def pause_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.pause" }, ref)
end
Also aliased as: pause_vm
pause_vm(ref)
Alias for: pause_server
plug_pbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/plug_pbd.rb, line 5
def plug_pbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PBD.plug" }, ref)
end
plug_pif(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/plug_pif.rb, line 5
def plug_pif(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.plug" }, ref)
end
plug_vbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/plug_vbd.rb, line 5
def plug_vbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.plug" }, ref)
end
plug_vif(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/plug_vif.rb, line 5
def plug_vif(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.plug" }, ref)
end
pool_migrate_server(ref, host, option) click to toggle source
# File lib/fog/compute/xen_server/requests/pool_migrate_server.rb, line 5
def pool_migrate_server(ref, host, option)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.pool_migrate" }, ref, host, option)
end
Also aliased as: pool_migrate_vm
pool_migrate_vdi(ref, sr, options) click to toggle source
# File lib/fog/compute/xen_server/requests/pool_migrate_vdi.rb, line 5
def pool_migrate_vdi(ref, sr, options)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.pool_migrate" }, ref, sr, options)
end
pool_migrate_vm(ref, host, option)
Alias for: pool_migrate_server
power_on_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/power_on_host.rb, line 5
def power_on_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.power_on" }, ref)
end
power_state_reset_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/power_state_reset_server.rb, line 5
def power_state_reset_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.power_state_reset" }, ref)
end
Also aliased as: power_state_reset_vm
power_state_reset_vm(ref)
probe_sr(host, device_config, type, sm_config) click to toggle source
# File lib/fog/compute/xen_server/requests/probe_sr.rb, line 5
def probe_sr(host, device_config, type, sm_config)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.probe" }, host, device_config, type, sm_config)
end
provision_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/provision_server.rb, line 5
def provision_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.provision" }, ref)
end
Also aliased as: provision_vm
provision_vm(ref)
Alias for: provision_server
query_data_source_host(ref, data_source) click to toggle source
# File lib/fog/compute/xen_server/requests/query_data_source_host.rb, line 5
def query_data_source_host(ref, data_source)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.query_data_source" }, ref, data_source)
end
query_data_source_server(ref, data_source) click to toggle source
# File lib/fog/compute/xen_server/requests/query_data_source_server.rb, line 5
def query_data_source_server(ref, data_source)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.query_data_source" }, ref, data_source)
end
Also aliased as: query_data_source_vm
query_data_source_vm(ref, data_source)
query_services_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/query_services_server.rb, line 5
def query_services_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.query_services" }, ref)
end
Also aliased as: query_services_vm
query_services_vm(ref)
read_database_pool_uuid_vdi(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/read_database_pool_uuid_vdi.rb, line 5
def read_database_pool_uuid_vdi(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.read_database_pool_uuid" }, ref)
end
reboot_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/reboot_host.rb, line 5
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/compute/xen_server/requests/reboot_server.rb, line 5
def reboot_server(ref, stype = "clean")
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VM.#{stype}_reboot"}, ref)
end
Also aliased as: reboot_vm
reboot_vm(ref, stype = "clean")
Alias for: reboot_server
reconfigure_ip_pif(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/reconfigure_ip_pif.rb, line 5
def reconfigure_ip_pif(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.reconfigure_ip" }, ref)
end
reconfigure_ipv6_pif(ref, ipv6_configuration_mode, ipv6, gateway, dns) click to toggle source
# File lib/fog/compute/xen_server/requests/reconfigure_ipv6_pif.rb, line 5
def reconfigure_ipv6_pif(ref, ipv6_configuration_mode, ipv6, gateway, dns)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.reconfigure_ipv6" }, ref, ipv6_configuration_mode, ipv6, gateway, dns)
end
record_data_source_host(ref, data_source) click to toggle source
# File lib/fog/compute/xen_server/requests/record_data_source_host.rb, line 5
def record_data_source_host(ref, data_source)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.record_data_source" }, ref, data_source)
end
record_data_source_server(ref, data_source) click to toggle source
# File lib/fog/compute/xen_server/requests/record_data_source_server.rb, line 5
def record_data_source_server(ref, data_source)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.record_data_source" }, ref, data_source)
end
Also aliased as: record_data_source_vm
record_data_source_vm(ref, data_source)
recover_server(ref, session_to, force) click to toggle source
# File lib/fog/compute/xen_server/requests/recover_server.rb, line 5
def recover_server(ref, session_to, force)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.recover" }, ref, session_to, force)
end
Also aliased as: recover_vm
recover_slaves_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/recover_slaves_pool.rb, line 5
def recover_slaves_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.recover_slaves")
end
recover_vm(ref, session_to, force)
Alias for: recover_server
refresh_pack_info_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/refresh_pack_info_host.rb, line 5
def refresh_pack_info_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.refresh_pack_info" }, ref)
end
reload() click to toggle source
# File lib/fog/compute/xen_server/real.rb, line 17
def reload
  @connection.authenticate(@username, @password)
end
remove_ipv4_allowed_vif(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/remove_ipv4_allowed_vif.rb, line 5
def remove_ipv4_allowed_vif(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.remove_ipv4_allowed" }, ref, value)
end
remove_ipv6_allowed_vif(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/remove_ipv6_allowed_vif.rb, line 5
def remove_ipv6_allowed_vif(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.remove_ipv6_allowed" }, ref, value)
end
reset_cpu_features_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/reset_cpu_features_host.rb, line 5
def reset_cpu_features_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.reset_cpu_features" }, ref)
end
resize_online_vdi(ref, size) click to toggle source
# File lib/fog/compute/xen_server/requests/resize_online_vdi.rb, line 5
def resize_online_vdi(ref, size)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.resize_online" }, ref, size)
end
resize_vdi(ref, size) click to toggle source
# File lib/fog/compute/xen_server/requests/resize_vdi.rb, line 5
def resize_vdi(ref, size)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.resize" }, ref, size)
end
restart_agent_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/restart_agent_host.rb, line 5
def restart_agent_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.restart_agent" }, ref)
end
resume_on_server(ref, host, start_paused, force) click to toggle source
# File lib/fog/compute/xen_server/requests/resume_on_server.rb, line 5
def resume_on_server(ref, host, start_paused, force)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.resume_on" }, ref, host, start_paused, force)
end
Also aliased as: resume_on_vm
resume_on_vm(ref, host, start_paused, force)
Alias for: resume_on_server
resume_server(ref, start_paused, force) click to toggle source
# File lib/fog/compute/xen_server/requests/resume_server.rb, line 5
def resume_server(ref, start_paused, force)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.resume" }, ref, start_paused, force)
end
Also aliased as: resume_vm
resume_vm(ref, start_paused, force)
Alias for: resume_server
revert_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/revert_server.rb, line 5
def revert_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.revert" }, ref)
end
Also aliased as: revert_vm
revert_to_server(snapshot_ref, extra_args = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/revert_to_server.rb, line 5
def revert_to_server(snapshot_ref, extra_args = {})
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VM.revert"}, snapshot_ref)
end
Also aliased as: revert_to_vm
revert_to_vm(snapshot_ref, extra_args = {})
Alias for: revert_to_server
revert_vm(ref)
Alias for: revert_server
scan_pif(host) click to toggle source
# File lib/fog/compute/xen_server/requests/scan_pif.rb, line 5
def scan_pif(host)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.scan" }, host)
end
scan_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/scan_sr.rb, line 5
def scan_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.scan" }, ref)
end
send_debug_keys_host(ref, keys) click to toggle source
# File lib/fog/compute/xen_server/requests/send_debug_keys_host.rb, line 5
def send_debug_keys_host(ref, keys)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.send_debug_keys" }, ref, keys)
end
send_sysrq_server(ref, key) click to toggle source
# File lib/fog/compute/xen_server/requests/send_sysrq_server.rb, line 5
def send_sysrq_server(ref, key)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.send_sysrq" }, ref, key)
end
Also aliased as: send_sysrq_vm
send_sysrq_vm(ref, key)
Alias for: send_sysrq_server
send_test_post_pool(host, port, body) click to toggle source
# File lib/fog/compute/xen_server/requests/send_test_post_pool.rb, line 5
def send_test_post_pool(host, port, body)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.send_test_post" }, host, port, body)
end
send_trigger_server(ref, trigger) click to toggle source
# File lib/fog/compute/xen_server/requests/send_trigger_server.rb, line 5
def send_trigger_server(ref, trigger)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.send_trigger" }, ref, trigger)
end
Also aliased as: send_trigger_vm
send_trigger_vm(ref, trigger)
Alias for: send_trigger_server
set_affinity_server(host_ref) click to toggle source
# File lib/fog/compute/xen_server/requests/set_affinity_server.rb, line 5
def set_affinity_server(host_ref)
  @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_affinity"}, host_ref)
end
Also aliased as: set_affinity_vm
set_affinity_vm(host_ref)
Alias for: set_affinity_server
set_allow_caching_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_allow_caching_vdi.rb, line 5
def set_allow_caching_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_allow_caching" }, ref, value)
end
set_appliance_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_appliance_server.rb, line 5
def set_appliance_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_appliance" }, ref, value)
end
Also aliased as: set_appliance_vm
set_appliance_vm(ref, value)
set_attribute(klass, ref, attr_name, *value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_attribute.rb, line 5
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
set_cpu_features_host(ref, features) click to toggle source
# File lib/fog/compute/xen_server/requests/set_cpu_features_host.rb, line 5
def set_cpu_features_host(ref, features)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.set_cpu_features" }, ref, features)
end
set_default_locking_mode_network(ref, network_default_locking_mode) click to toggle source
# File lib/fog/compute/xen_server/requests/set_default_locking_mode_network.rb, line 5
def set_default_locking_mode_network(ref, network_default_locking_mode)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "network.set_default_locking_mode" }, ref, network_default_locking_mode)
end
set_device_config_pbd(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_device_config_pbd.rb, line 5
def set_device_config_pbd(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PBD.set_device_config" }, ref, value)
end
set_ha_host_failures_to_tolerate_pool(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_ha_host_failures_to_tolerate_pool.rb, line 5
def set_ha_host_failures_to_tolerate_pool(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.set_ha_host_failures_to_tolerate" }, ref, value)
end
set_ha_restart_priority_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_ha_restart_priority_server.rb, line 5
def set_ha_restart_priority_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_ha_restart_priority" }, ref, value)
end
Also aliased as: set_ha_restart_priority_vm
set_ha_restart_priority_vm(ref, value)
set_hostname_live_host(ref, hostname) click to toggle source
# File lib/fog/compute/xen_server/requests/set_hostname_live_host.rb, line 5
def set_hostname_live_host(ref, hostname)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.set_hostname_live" }, ref, hostname)
end
set_hvm_shadow_multiplier_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_hvm_shadow_multiplier_server.rb, line 5
def set_hvm_shadow_multiplier_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_HVM_shadow_multiplier" }, ref, value)
end
Also aliased as: set_hvm_shadow_multiplier_vm
set_hvm_shadow_multiplier_vm(ref, value)
set_ipv4_allowed_vif(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_ipv4_allowed_vif.rb, line 5
def set_ipv4_allowed_vif(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.set_ipv4_allowed" }, ref, value)
end
set_ipv6_allowed_vif(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_ipv6_allowed_vif.rb, line 5
def set_ipv6_allowed_vif(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.set_ipv6_allowed" }, ref, value)
end
set_is_a_snapshot_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_is_a_snapshot_vdi.rb, line 5
def set_is_a_snapshot_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_is_a_snapshot" }, ref, value)
end
set_locking_mode_vif(ref, vif_locking_mode) click to toggle source
# File lib/fog/compute/xen_server/requests/set_locking_mode_vif.rb, line 5
def set_locking_mode_vif(ref, vif_locking_mode)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.set_locking_mode" }, ref, vif_locking_mode)
end
set_managed_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_managed_vdi.rb, line 5
def set_managed_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_managed" }, ref, value)
end
set_memory_dynamic_max_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_dynamic_max_server.rb, line 5
def set_memory_dynamic_max_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_dynamic_max" }, ref, value)
end
Also aliased as: set_memory_dynamic_max_vm
set_memory_dynamic_max_vm(ref, value)
set_memory_dynamic_min_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_dynamic_min_server.rb, line 5
def set_memory_dynamic_min_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_dynamic_min" }, ref, value)
end
Also aliased as: set_memory_dynamic_min_vm
set_memory_dynamic_min_vm(ref, value)
set_memory_dynamic_range_server(ref, min, max) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_dynamic_range_server.rb, line 5
def set_memory_dynamic_range_server(ref, min, max)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_dynamic_range" }, ref, min, max)
end
Also aliased as: set_memory_dynamic_range_vm
set_memory_dynamic_range_vm(ref, min, max)
set_memory_limits_server(ref, static_min, static_max, dynamic_min, dynamic_max) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_limits_server.rb, line 5
def set_memory_limits_server(ref, static_min, static_max, dynamic_min, dynamic_max)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_limits" }, ref, static_min, static_max, dynamic_min, dynamic_max)
end
Also aliased as: set_memory_limits_vm
set_memory_limits_vm(ref, static_min, static_max, dynamic_min, dynamic_max)
set_memory_static_max_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_static_max_server.rb, line 5
def set_memory_static_max_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_static_max" }, ref, value)
end
Also aliased as: set_memory_static_max_vm
set_memory_static_max_vm(ref, value)
set_memory_static_min_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_static_min_server.rb, line 5
def set_memory_static_min_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_static_min" }, ref, value)
end
Also aliased as: set_memory_static_min_vm
set_memory_static_min_vm(ref, value)
set_memory_static_range_server(ref, min, max) click to toggle source
# File lib/fog/compute/xen_server/requests/set_memory_static_range_server.rb, line 5
def set_memory_static_range_server(ref, min, max)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_memory_static_range" }, ref, min, max)
end
Also aliased as: set_memory_static_range_vm
set_memory_static_range_vm(ref, min, max)
set_metadata_of_pool_vdi(ref, pool) click to toggle source
# File lib/fog/compute/xen_server/requests/set_metadata_of_pool_vdi.rb, line 5
def set_metadata_of_pool_vdi(ref, pool)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_metadata_of_pool" }, ref, pool)
end
set_missing_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_missing_vdi.rb, line 5
def set_missing_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_missing" }, ref, value)
end
set_name_description_sr(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_name_description_sr.rb, line 5
def set_name_description_sr(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.set_name_description" }, ref, value)
end
set_name_description_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_name_description_vdi.rb, line 5
def set_name_description_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_name_description" }, ref, value)
end
set_name_label_sr(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_name_label_sr.rb, line 5
def set_name_label_sr(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.set_name_label" }, ref, value)
end
set_name_label_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_name_label_vdi.rb, line 5
def set_name_label_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_name_label" }, ref, value)
end
set_on_boot_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_on_boot_vdi.rb, line 5
def set_on_boot_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_on_boot" }, ref, value)
end
set_order_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_order_server.rb, line 5
def set_order_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_order" }, ref, value)
end
Also aliased as: set_order_vm
set_order_vm(ref, value)
Alias for: set_order_server
set_physical_size_sr(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_physical_size_sr.rb, line 5
def set_physical_size_sr(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.set_physical_size" }, ref, value)
end
set_physical_utilisation_sr(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_physical_utilisation_sr.rb, line 5
def set_physical_utilisation_sr(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.set_physical_utilisation" }, ref, value)
end
set_physical_utilisation_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_physical_utilisation_vdi.rb, line 5
def set_physical_utilisation_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_physical_utilisation" }, ref, value)
end
set_power_on_mode_host(ref, power_on_mode, power_on_config) click to toggle source
# File lib/fog/compute/xen_server/requests/set_power_on_mode_host.rb, line 5
def set_power_on_mode_host(ref, power_on_mode, power_on_config)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.set_power_on_mode" }, ref, power_on_mode, power_on_config)
end
set_primary_address_type_pif(ref, primary_address_type) click to toggle source
# File lib/fog/compute/xen_server/requests/set_primary_address_type_pif.rb, line 5
def set_primary_address_type_pif(ref, primary_address_type)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PIF.set_primary_address_type" }, ref, primary_address_type)
end
set_protection_policy_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_protection_policy_server.rb, line 5
def set_protection_policy_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_protection_policy" }, ref, value)
end
Also aliased as: set_protection_policy_vm
set_protection_policy_vm(ref, value)
set_read_only_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_read_only_vdi.rb, line 5
def set_read_only_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_read_only" }, ref, value)
end
set_shadow_multiplier_live_server(ref, multiplier) click to toggle source
# File lib/fog/compute/xen_server/requests/set_shadow_multiplier_live_server.rb, line 5
def set_shadow_multiplier_live_server(ref, multiplier)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_shadow_multiplier_live" }, ref, multiplier)
end
set_shadow_multiplier_live_vm(ref, multiplier)
set_sharable_vdi(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_sharable_vdi.rb, line 5
def set_sharable_vdi(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_sharable" }, ref, value)
end
set_shared_sr(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_shared_sr.rb, line 5
def set_shared_sr(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.set_shared" }, ref, value)
end
set_shutdown_delay_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_shutdown_delay_server.rb, line 5
def set_shutdown_delay_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_shutdown_delay" }, ref, value)
end
Also aliased as: set_shutdown_delay_vm
set_shutdown_delay_vm(ref, value)
set_snapshot_of_vdi(ref, vdi) click to toggle source
# File lib/fog/compute/xen_server/requests/set_snapshot_of_vdi.rb, line 5
def set_snapshot_of_vdi(ref, vdi)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_snapshot_of" }, ref, vdi)
end
set_snapshot_time_vdi(ref, datetime) click to toggle source
# File lib/fog/compute/xen_server/requests/set_snapshot_time_vdi.rb, line 5
def set_snapshot_time_vdi(ref, datetime)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_snapshot_time" }, ref, datetime)
end
set_start_delay_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_start_delay_server.rb, line 5
def set_start_delay_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_start_delay" }, ref, value)
end
Also aliased as: set_start_delay_vm
set_start_delay_vm(ref, value)
set_suspend_vdi_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_suspend_vdi_server.rb, line 5
def set_suspend_vdi_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_suspend_VDI" }, ref, value)
end
Also aliased as: set_suspend_vdi_vm
set_suspend_vdi_vm(ref, value)
set_vcpus_at_startup_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_vcpus_at_startup_server.rb, line 5
def set_vcpus_at_startup_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_VCPUs_at_startup" }, ref, value)
end
Also aliased as: set_vcpus_at_startup_vm
set_vcpus_at_startup_vm(ref, value)
set_vcpus_max_server(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_vcpus_max_server.rb, line 5
def set_vcpus_max_server(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_VCPUs_max" }, ref, value)
end
Also aliased as: set_vcpus_max_vm
set_vcpus_max_vm(ref, value)
set_vcpus_number_live_server(ref, nvcpu) click to toggle source
# File lib/fog/compute/xen_server/requests/set_vcpus_number_live_server.rb, line 5
def set_vcpus_number_live_server(ref, nvcpu)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.set_VCPUs_number_live" }, ref, nvcpu)
end
Also aliased as: set_vcpus_number_live_vm
set_vcpus_number_live_vm(ref, nvcpu)
set_virtual_allocation_sr(ref, value) click to toggle source
# File lib/fog/compute/xen_server/requests/set_virtual_allocation_sr.rb, line 5
def set_virtual_allocation_sr(ref, value)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.set_virtual_allocation" }, ref, value)
end
set_virtual_size_vdi(ref, int) click to toggle source
# File lib/fog/compute/xen_server/requests/set_virtual_size_vdi.rb, line 5
def set_virtual_size_vdi(ref, int)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.set_virtual_size" }, ref, int)
end
set_vswitch_controller_pool(address) click to toggle source
# File lib/fog/compute/xen_server/requests/set_vswitch_controller_pool.rb, line 5
def set_vswitch_controller_pool(address)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "pool.set_vswitch_controller" }, address)
end
shutdown_agent_host() click to toggle source
# File lib/fog/compute/xen_server/requests/shutdown_agent_host.rb, line 5
def shutdown_agent_host
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "host.shutdown_agent")
end
shutdown_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/shutdown_host.rb, line 5
def shutdown_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.shutdown" }, ref)
end
shutdown_server(ref, stype = false) click to toggle source
# File lib/fog/compute/xen_server/requests/shutdown_server.rb, line 5
def shutdown_server(ref, stype = false)
  Fog::Logger.deprecation "Use shutdown_clean and shutdown_hard for specific shutdown." unless stype == false
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.shutdown" }, ref)
end
Also aliased as: shutdown_vm
shutdown_vm(ref, stype = false)
Alias for: shutdown_server
snapshot_server(snapshot_ref, extra_args = {}) click to toggle source
# File lib/fog/compute/xen_server/requests/revert_to_server.rb, line 11
def snapshot_server(snapshot_ref, extra_args = {})
  Fog::Logger.deprecation "This method is DEPRECATED. Use #revert_to_server instead."
  revert_to_server(snapshot_ref, extra_args)
end
Also aliased as: snapshot_vm
snapshot_vdi(ref, driver_params) click to toggle source
# File lib/fog/compute/xen_server/requests/snapshot_vdi.rb, line 5
def snapshot_vdi(ref, driver_params)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.snapshot" }, ref, driver_params)
end
snapshot_vm(snapshot_ref, extra_args = {})
Alias for: snapshot_server
snapshot_with_quiesce_server(ref, new_name) click to toggle source
# File lib/fog/compute/xen_server/requests/snapshot_with_quiesce_server.rb, line 5
def snapshot_with_quiesce_server(ref, new_name)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.snapshot_with_quiesce" }, ref, new_name)
end
Also aliased as: snapshot_with_quiesce_vm
snapshot_with_quiesce_vm(ref, new_name)
snapshots() click to toggle source
# File lib/fog/compute/xen_server/requests/snapshots.rb, line 5
def snapshots
  data = @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "VM.get_all_records")
  data.keep_if { |vm| vm[:is_a_snapshot] }
  servers.load(data)
rescue Fog::XenServer::RequestFailed => e
  []
end
start_on_server(ref, host, start_paused, force) click to toggle source
# File lib/fog/compute/xen_server/requests/start_on_server.rb, line 5
def start_on_server(ref, host, start_paused, force)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.start_on" }, ref, host, start_paused, force)
end
Also aliased as: start_on_vm
start_on_vm(ref, host, start_paused, force)
Alias for: start_on_server
start_server(ref, start_paused = false, force = false) click to toggle source
# File lib/fog/compute/xen_server/requests/start_server.rb, line 5
def start_server(ref, start_paused = false, force = false)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.start" }, ref, start_paused, force)
end
Also aliased as: start_vm
start_vm(ref, start_paused = false, force = false)
Alias for: start_server
suspend_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/suspend_server.rb, line 5
def suspend_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.suspend" }, ref)
end
Also aliased as: suspend_vm
suspend_vm(ref)
Alias for: suspend_server
sync_data_host(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/sync_data_host.rb, line 5
def sync_data_host(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "host.sync_data" }, ref)
end
sync_database_pool() click to toggle source
# File lib/fog/compute/xen_server/requests/sync_database_pool.rb, line 5
def sync_database_pool
  @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => "pool.sync_database")
end
templates() click to toggle source
# File lib/fog/compute/xen_server/requests/templates.rb, line 5
def templates
  data = @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "VM.get_all_records")
  data.keep_if { |vm| vm[:is_a_template] }
  servers.load(data)
rescue Fog::XenServer::RequestFailed => e
  []
end
unpause_server(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/unpause_server.rb, line 5
def unpause_server(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VM.unpause" }, ref)
end
Also aliased as: unpause_vm
unpause_vm(ref)
Alias for: unpause_server
unplug_force_vbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/unplug_force_vbd.rb, line 5
def unplug_force_vbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.unplug_force" }, ref)
end
unplug_pbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/unplug_pbd.rb, line 5
def unplug_pbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "PBD.unplug" }, ref)
end
unplug_vbd(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/unplug_vbd.rb, line 5
def unplug_vbd(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VBD.unplug" }, ref)
end
unplug_vif(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/unplug_vif.rb, line 5
def unplug_vif(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VIF.unplug" }, ref)
end
update_sr(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/update_sr.rb, line 5
def update_sr(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "SR.update" }, ref)
end
update_vdi(ref) click to toggle source
# File lib/fog/compute/xen_server/requests/update_vdi.rb, line 5
def update_vdi(ref)
  @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => "VDI.update" }, ref)
end