class Fog::OpenStack::Compute::Real

developer.openstack.org/api-ref-compute-v2.1.html#showlimits

Public Class Methods

new(options = {}) click to toggle source
Calls superclass method Fog::OpenStack::Core::new
# File lib/fog/openstack/compute.rb, line 384
def initialize(options = {})
  @supported_versions = SUPPORTED_VERSIONS
  @supported_microversion = SUPPORTED_MICROVERSION
  @microversion_key = 'X-OpenStack-Nova-API-Version'
  super
end
not_found_class() click to toggle source
# File lib/fog/openstack/compute.rb, line 376
def self.not_found_class
  Fog::OpenStack::Compute::NotFound
end

Public Instance Methods

add_aggregate_host(uuid, host_uuid) click to toggle source
# File lib/fog/openstack/compute/requests/add_aggregate_host.rb, line 5
def add_aggregate_host(uuid, host_uuid)
  data = {'add_host' => {'host' => host_uuid}}
  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200],
    :method  => 'POST',
    :path    => "os-aggregates/#{uuid}/action"
  )
end
add_fixed_ip(server_id, network_id) click to toggle source

Add an IP address on a network.

Parameters

  • server_id <~String> - The ID of the server in which to add an IP to.

  • network_id <~String> - The ID of the network the IP should be on.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/add_fixed_ip.rb, line 12
def add_fixed_ip(server_id, network_id)
  body = {
    'addFixedIp' => {
      'networkId' => network_id
    }
  }
  server_action(server_id, body).status == 202
end
add_flavor_access(flavor_ref, tenant_id) click to toggle source
# File lib/fog/openstack/compute/requests/add_flavor_access.rb, line 5
def add_flavor_access(flavor_ref, tenant_id)
  request(
    :body    => Fog::JSON.encode("addTenantAccess" => {
                                   "tenant" => tenant_id
                                 }),
    :expects => [200, 203],
    :method  => 'POST',
    :path    => "flavors/#{flavor_ref}/action"
  )
end
add_security_group(server_id, group_name) click to toggle source
# File lib/fog/openstack/compute/requests/add_security_group.rb, line 5
def add_security_group(server_id, group_name)
  body = {'addSecurityGroup' => {"name" => group_name}}
  server_action(server_id, body)
end
allocate_address(pool = nil) click to toggle source
# File lib/fog/openstack/compute/requests/allocate_address.rb, line 5
def allocate_address(pool = nil)
  request(
    :body    => Fog::JSON.encode('pool' => pool),
    :expects => [200, 202],
    :method  => 'POST',
    :path    => 'os-floating-ips'
  )
end
associate_address(server_id, ip_address) click to toggle source
# File lib/fog/openstack/compute/requests/associate_address.rb, line 5
def associate_address(server_id, ip_address)
  body = {"addFloatingIp" => {"address" => ip_address}}
  server_action(server_id, body)
end
attach_volume(volume_id, server_id, device) click to toggle source
# File lib/fog/openstack/compute/requests/attach_volume.rb, line 5
def attach_volume(volume_id, server_id, device)
  data = {
    'volumeAttachment' => {
      'volumeId' => volume_id.to_s,
      'device'   => device
    }
  }
  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200, 202],
    :method  => 'POST',
    :path    => "servers/%s/os-volume_attachments" % [server_id]
  )
end
boot_from_snapshot(name, image_ref, flavor_ref, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/boot_from_snapshot.rb, line 5
def boot_from_snapshot(name, image_ref, flavor_ref, options = {})
  data = {
    'server' => {
      'flavorRef' => flavor_ref,
      'imageRef'  => image_ref,
      'name'      => name
    }
  }

  vanilla_options = ['metadata', 'accessIPv4', 'accessIPv6',
                     'availability_zone', 'user_data', 'block_device_mapping',
                     'key_name', 'security_groups']
  vanilla_options.select { |o| options[o] }.each do |key|
    data['server'][key] = options[key]
  end

  if options['personality']
    data['server']['personality'] = []
    options['personality'].each do |file|
      data['server']['personality'] << {
        'contents' => Base64.encode64(file['contents']),
        'path'     => file['path']
      }
    end
  end

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200, 202],
    :method  => 'POST',
    :path    => '/os-volumes_boot'
  )
end
change_server_password(server_id, admin_password) click to toggle source
# File lib/fog/openstack/compute/requests/change_server_password.rb, line 5
def change_server_password(server_id, admin_password)
  body = {'changePassword' => {'adminPass' => admin_password}}
  server_action(server_id, body)
end
confirm_resize_server(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/confirm_resize_server.rb, line 5
def confirm_resize_server(server_id)
  body = {'confirmResize' => nil}
  server_action(server_id, body, 204)
end
create_aggregate(name, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/create_aggregate.rb, line 5
def create_aggregate(name, options = {})
  data = {
    'aggregate' => {
      'name' => name
    }
  }

  vanilla_options = [:availability_zone]

  vanilla_options.select { |o| options[o] }.each do |key|
    data['aggregate'][key] = options[key]
  end

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200],
    :method  => 'POST',
    :path    => "os-aggregates"
  )
end
create_flavor(attributes) click to toggle source

PARAMETERS # name = Name of flavor ram = Memory in MB vcpus = Number of VCPUs disk = Size of local disk in GB swap = Swap space in MB rxtx_factor = RX/TX factor

# File lib/fog/openstack/compute/requests/create_flavor.rb, line 12
def create_flavor(attributes)
  data = {
    'flavor' => {
      'name'                       => attributes[:name],
      'ram'                        => attributes[:ram],
      'vcpus'                      => attributes[:vcpus],
      'disk'                       => attributes[:disk],
      'id'                         => attributes[:flavor_id],
      'swap'                       => attributes[:swap],
      'OS-FLV-EXT-DATA:ephemeral'  => attributes[:ephemeral],
      'os-flavor-access:is_public' => attributes[:is_public],
      'rxtx_factor'                => attributes[:rxtx_factor]
    }
  }

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'POST',
    :path    => 'flavors'
  )
end
create_flavor_metadata(flavor_ref, metadata) click to toggle source
# File lib/fog/openstack/compute/requests/create_flavor_metadata.rb, line 5
def create_flavor_metadata(flavor_ref, metadata)
  data = {
    'extra_specs' => metadata
  }

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'POST',
    :path    => "flavors/#{flavor_ref}/os-extra_specs"
  )
end
create_image(server_id, name, metadata = {}) click to toggle source
# File lib/fog/openstack/compute/requests/create_image.rb, line 5
def create_image(server_id, name, metadata = {})
  body = {'createImage' => {
    'name'     => name,
    'metadata' => metadata
  }}
  data = server_action(server_id, body)
  image_id = data.headers["Location"].scan(%r{.*/(.*)}).flatten[0]
  get_image_details(image_id)
end
create_key_pair(key_name, public_key = nil, user_id = nil) click to toggle source
# File lib/fog/openstack/compute/requests/create_key_pair.rb, line 5
def create_key_pair(key_name, public_key = nil, user_id = nil)
  data = {
    'keypair' => {
      'name' => key_name
    }
  }

  data['keypair']['public_key'] = public_key unless public_key.nil?
  data['keypair']['user_id'] = user_id unless user_id.nil?

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200, 201],
    :method  => 'POST',
    :path    => 'os-keypairs'
  )
end
create_os_interface(server_id, options={}) click to toggle source

Parameters

  • server_id <~String>

  • options <~Hash>

# File lib/fog/openstack/compute/requests/create_os_interface.rb, line 8
def create_os_interface(server_id, options={})
  body = {
    'interfaceAttachment' => {}
  }

  if options[:port_id]
    body['interfaceAttachment']['port_id'] = options[:port_id]
  elsif options[:net_id]
    body['interfaceAttachment']['net_id'] = options[:net_id]
  end

  if options[:ip_address]
    body['interfaceAttachment']['fixed_ips'] = {ip_address: options[:ip_address]}
  end

  request(
    :body    => Fog::JSON.encode(body),
    :expects => [200, 201, 202, 204],
    :method  => 'POST',
    :path    => "servers/#{server_id}/os-interface"
  )
end
create_security_group(name, description) click to toggle source
# File lib/fog/openstack/compute/requests/create_security_group.rb, line 5
def create_security_group(name, description)
  data = {
    'security_group' => {
      'name'        => name,
      'description' => description
    }
  }

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'POST',
    :path    => 'os-security-groups'
  )
end
create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group_id = nil) click to toggle source
# File lib/fog/openstack/compute/requests/create_security_group_rule.rb, line 5
def create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group_id = nil)
  data = {
    'security_group_rule' => {
      'parent_group_id' => parent_group_id,
      'ip_protocol'     => ip_protocol,
      'from_port'       => from_port,
      'to_port'         => to_port,
      'cidr'            => cidr,
      'group_id'        => group_id
    }
  }

  request(
    :expects => 200,
    :method  => 'POST',
    :body    => Fog::JSON.encode(data),
    :path    => 'os-security-group-rules'
  )
end
create_server(name, image_ref, flavor_ref, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/create_server.rb, line 5
def create_server(name, image_ref, flavor_ref, options = {})
  data = {
    'server' => {
      'flavorRef' => flavor_ref,
      'name'      => name
    }
  }
  data['server']['imageRef'] = image_ref if image_ref

  vanilla_options = ['metadata', 'accessIPv4', 'accessIPv6',
                     'availability_zone', 'user_data', 'key_name',
                     'adminPass', 'config_drive', 'min_count', 'max_count',
                     'return_reservation_id']
  vanilla_options.select { |o| options[o] }.each do |key|
    data['server'][key] = options[key]
  end

  if options['security_groups']
    # security names requires a hash with a name prefix
    data['server']['security_groups'] =
      Array(options['security_groups']).map do |sg|
        name = if sg.kind_of?(Fog::OpenStack::Compute::SecurityGroup)
                 sg.name
               else
                 sg
               end
        {:name => name}
      end
  end

  if options['personality']
    data['server']['personality'] = []
    options['personality'].each do |file|
      data['server']['personality'] << {
        'contents' => Base64.encode64(file['contents'] || file[:contents]),
        'path'     => file['path'] || file[:path]
      }
    end
  end

  if options['nics']
    data['server']['networks'] =
      Array(options['nics']).map do |nic|
        neti = {}
        neti['uuid'] = (nic['net_id'] || nic[:net_id]) unless (nic['net_id'] || nic[:net_id]).nil?
        neti['fixed_ip'] = (nic['v4_fixed_ip'] || nic[:v4_fixed_ip]) unless (nic['v4_fixed_ip'] || nic[:v4_fixed_ip]).nil?
        neti['port'] = (nic['port_id'] || nic[:port_id]) unless (nic['port_id'] || nic[:port_id]).nil?
        neti
      end
  end

  if options['os:scheduler_hints']
    data['os:scheduler_hints'] = options['os:scheduler_hints']
  end

  if (block_device_mapping = options['block_device_mapping_v2'])
    data['server']['block_device_mapping_v2'] = [block_device_mapping].flatten.collect do |mapping|
      entered_block_device_mapping = {}
      [:boot_index, :delete_on_termination, :destination_type, :device_name, :device_type, :disk_bus,
       :guest_format, :source_type, :uuid, :volume_size].each do |index|
        entered_block_device_mapping[index.to_s] = mapping[index] if mapping.key?(index)
      end
      entered_block_device_mapping
    end
  elsif (block_device_mapping = options['block_device_mapping'])
    data['server']['block_device_mapping'] = [block_device_mapping].flatten.collect do |mapping|
      {
        'delete_on_termination' => mapping[:delete_on_termination],
        'device_name'           => mapping[:device_name],
        'volume_id'             => mapping[:volume_id],
        'volume_size'           => mapping[:volume_size],
      }
    end
  end

  path = options['block_device_mapping'] ? 'os-volumes_boot' : 'servers'

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200, 202],
    :method  => 'POST',
    :path    => path
  )
end
create_server_group(name, policy) click to toggle source
# File lib/fog/openstack/compute/requests/create_server_group.rb, line 5
def create_server_group(name, policy)
  Fog::OpenStack::Compute::ServerGroup.validate_server_group_policy policy

  body = {'server_group' => {
    'name'     => name,
    'policies' => [policy]
  }}
  request(
    :body    => Fog::JSON.encode(body),
    :expects => 200,
    :method  => 'POST',
    :path    => 'os-server-groups'
  )
end
create_snapshot(volume_id, name, description, force = false) click to toggle source
# File lib/fog/openstack/compute/requests/create_snapshot.rb, line 5
def create_snapshot(volume_id, name, description, force = false)
  data = {
    'snapshot' => {
      'volume_id'           => volume_id,
      'display_name'        => name,
      'display_description' => description,
      'force'               => force
    }
  }

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200, 202],
    :method  => 'POST',
    :path    => "os-snapshots"
  )
end
create_volume(name, description, size, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/create_volume.rb, line 7
def create_volume(name, description, size, options = {})
  data = {
    'volume' => {
      'display_name'        => name,
      'display_description' => description,
      'size'                => size
    }
  }

  vanilla_options = [
    :snapshot_id,
    :availability_zone,
    :volume_type,
    :metadata
  ]

  vanilla_options.select { |o| options[o] }.each do |key|
    data['volume'][key] = options[key]
  end

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200, 202],
    :method  => 'POST',
    :path    => 'os-volumes'
  )
end
default_service_type() click to toggle source
# File lib/fog/openstack/compute.rb, line 380
def default_service_type
  %w[compute]
end
delete_aggregate(uuid) click to toggle source
# File lib/fog/openstack/compute/requests/delete_aggregate.rb, line 5
def delete_aggregate(uuid)
  request(
    :expects => [200, 202, 204],
    :method  => 'DELETE',
    :path    => "os-aggregates/#{uuid}"
  )
end
delete_flavor(flavor_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_flavor.rb, line 5
def delete_flavor(flavor_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "flavors/#{flavor_id}"
  )
end
delete_flavor_metadata(flavor_ref, key) click to toggle source
# File lib/fog/openstack/compute/requests/delete_flavor_metadata.rb, line 5
def delete_flavor_metadata(flavor_ref, key)
  request(
    :expects => 200,
    :method  => 'DELETE',
    :path    => "flavors/#{flavor_ref}/os-extra_specs/#{key}"
  )
end
delete_image(image_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_image.rb, line 5
def delete_image(image_id)
  request(
    :expects => 204,
    :method  => 'DELETE',
    :path    => "images/#{image_id}"
  )
end
delete_key_pair(key_name, user_id = nil) click to toggle source
# File lib/fog/openstack/compute/requests/delete_key_pair.rb, line 5
def delete_key_pair(key_name, user_id = nil)
  options = {}
  options[:user_id] = user_id unless user_id.nil?
  request(
    :expects => [202, 204],
    :method  => 'DELETE',
    :path    => "os-keypairs/#{Fog::OpenStack.escape(key_name)}"
  )
end
delete_meta(collection_name, parent_id, key) click to toggle source
# File lib/fog/openstack/compute/requests/delete_meta.rb, line 5
def delete_meta(collection_name, parent_id, key)
  request(
    :expects => 204,
    :method  => 'DELETE',
    :path    => "#{collection_name}/#{parent_id}/metadata/#{key}"
  )
end
delete_metadata(collection_name, parent_id, key) click to toggle source
# File lib/fog/openstack/compute/requests/delete_metadata.rb, line 5
def delete_metadata(collection_name, parent_id, key)
  request(
    :expects => 204,
    :method  => 'DELETE',
    :path    => "#{collection_name}/#{parent_id}/metadata/#{key}"
  )
end
delete_os_interface(server_id, port_id) click to toggle source

Parameters

  • server_id <~String>

  • port_id <~String>

# File lib/fog/openstack/compute/requests/delete_os_interface.rb, line 8
def delete_os_interface(server_id, port_id)
  request(
    :expects => [200, 202,204],
    :method  => 'DELETE',
    :path    => "servers/#{server_id}/os-interface/#{port_id}"
  )
end
delete_security_group(security_group_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_security_group.rb, line 5
def delete_security_group(security_group_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "os-security-groups/#{security_group_id}"
  )
end
delete_security_group_rule(security_group_rule_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_security_group_rule.rb, line 5
def delete_security_group_rule(security_group_rule_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "os-security-group-rules/#{security_group_rule_id}"
  )
end
delete_server(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_server.rb, line 5
def delete_server(server_id)
  request(
    :expects => 204,
    :method  => 'DELETE',
    :path    => "servers/#{server_id}"
  )
end
delete_server_group(group_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_server_group.rb, line 5
def delete_server_group(group_id)
  request(
    :expects => 204,
    :method  => 'DELETE',
    :path    => "os-server-groups/#{group_id}"
  )
end
delete_service(uuid, optional_params = nil) click to toggle source
# File lib/fog/openstack/compute/requests/delete_service.rb, line 5
def delete_service(uuid, optional_params = nil)
  # Encode all params
  optional_params = optional_params.each { |k, v| optional_params[k] = URI.encode(v) } if optional_params

  request(
    :expects => [202, 204],
    :method  => 'DELETE',
    :path    => "os-services/#{uuid}",
    :query   => optional_params
  )
end
delete_snapshot(snapshot_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_snapshot.rb, line 5
def delete_snapshot(snapshot_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "os-snapshots/#{snapshot_id}"
  )
end
delete_volume(volume_id) click to toggle source
# File lib/fog/openstack/compute/requests/delete_volume.rb, line 5
def delete_volume(volume_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "os-volumes/#{volume_id}"
  )
end
detach_volume(server_id, attachment_id) click to toggle source
# File lib/fog/openstack/compute/requests/detach_volume.rb, line 5
def detach_volume(server_id, attachment_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "servers/%s/os-volume_attachments/%s" % [server_id, attachment_id]
  )
end
disable_service(host, binary, optional_params = nil) click to toggle source
# File lib/fog/openstack/compute/requests/disable_service.rb, line 5
def disable_service(host, binary, optional_params = nil)
  data = {"host" => host, "binary" => binary}

  # Encode all params
  optional_params = optional_params.each { |k, v| optional_params[k] = URI.encode(v) } if optional_params

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'PUT',
    :path    => "os-services/disable",
    :query   => optional_params
  )
end
disable_service_log_reason(host, binary, disabled_reason, optional_params = nil) click to toggle source
# File lib/fog/openstack/compute/requests/disable_service_log_reason.rb, line 5
def disable_service_log_reason(host, binary, disabled_reason, optional_params = nil)
  data = {"host" => host, "binary" => binary, "disabled_reason" => disabled_reason}

  # Encode all params
  optional_params = optional_params.each { |k, v| optional_params[k] = URI.encode(v) } if optional_params

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'PUT',
    :path    => "os-services/disable-log-reason",
    :query   => optional_params
  )
end
disassociate_address(server_id, ip_address) click to toggle source
# File lib/fog/openstack/compute/requests/disassociate_address.rb, line 5
def disassociate_address(server_id, ip_address)
  body = {"removeFloatingIp" => {"address" => ip_address}}
  server_action(server_id, body)
end
enable_service(host, binary, optional_params = nil) click to toggle source
# File lib/fog/openstack/compute/requests/enable_service.rb, line 5
def enable_service(host, binary, optional_params = nil)
  data = {"host" => host, "binary" => binary}

  # Encode all params
  optional_params = optional_params.each { |k, v| optional_params[k] = URI.encode(v) } if optional_params

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'PUT',
    :path    => "os-services/enable",
    :query   => optional_params
  )
end
evacuate_server(server_id, host = nil, on_shared_storage = nil, admin_password = nil) click to toggle source
# File lib/fog/openstack/compute/requests/evacuate_server.rb, line 5
def evacuate_server(server_id, host = nil, on_shared_storage = nil, admin_password = nil)
  evacuate                    = {}
  evacuate['host']            = host if host

  if !microversion_newer_than?('2.13') && on_shared_storage
    evacuate['onSharedStorage'] = on_shared_storage
  end

  evacuate['adminPass']       = admin_password if admin_password
  body                        = {
    'evacuate' => evacuate
  }
  server_action(server_id, body)
end
get_address(address_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_address.rb, line 5
def get_address(address_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "os-floating-ips/#{address_id}"
  )
end
get_aggregate(uuid) click to toggle source
# File lib/fog/openstack/compute/requests/get_aggregate.rb, line 5
def get_aggregate(uuid)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "os-aggregates/#{uuid}"
  )
end
get_console_output(server_id, log_length) click to toggle source
# File lib/fog/openstack/compute/requests/get_console_output.rb, line 5
def get_console_output(server_id, log_length)
  body = {
    'os-getConsoleOutput' => {
      'length' => log_length
    }
  }
  server_action(server_id, body)
end
get_flavor_details(flavor_ref) click to toggle source
# File lib/fog/openstack/compute/requests/get_flavor_details.rb, line 5
def get_flavor_details(flavor_ref)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "flavors/#{flavor_ref}"
  )
end
get_flavor_metadata(flavor_ref) click to toggle source
# File lib/fog/openstack/compute/requests/get_flavor_metadata.rb, line 5
def get_flavor_metadata(flavor_ref)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "flavors/#{flavor_ref}/os-extra_specs"
  )
end
get_host_details(host) click to toggle source
# File lib/fog/openstack/compute/requests/get_host_details.rb, line 5
def get_host_details(host)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "os-hosts/#{host}"
  )
end
get_hypervisor(hypervisor_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_hypervisor.rb, line 5
def get_hypervisor(hypervisor_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "os-hypervisors/#{hypervisor_id}"
  )
end
get_hypervisor_statistics(_tenant_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_hypervisor_statistics.rb, line 5
def get_hypervisor_statistics(_tenant_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "os-hypervisors/statistics"
  )
end
get_image_details(image_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_image_details.rb, line 5
def get_image_details(image_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "images/#{image_id}"
  )
end
get_key_pair(key_name) click to toggle source
# File lib/fog/openstack/compute/requests/get_key_pair.rb, line 5
def get_key_pair(key_name)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "os-keypairs/#{Fog::OpenStack.escape(key_name)}"
  )
end
get_limits(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/get_limits.rb, line 7
def get_limits(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => '/limits',
    :query   => options
  )
end
get_metadata(collection_name, parent_id, key) click to toggle source
# File lib/fog/openstack/compute/requests/get_metadata.rb, line 5
def get_metadata(collection_name, parent_id, key)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "#{collection_name}/#{parent_id}/metadata/#{key}"
  )
end
get_os_interface(server_id,port_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_os_interface.rb, line 5
def get_os_interface(server_id,port_id)
  request(
    :expects => [200, 202, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}/os-interface/#{port_id}"
  )
end
get_quota(tenant_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_quota.rb, line 5
def get_quota(tenant_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "/os-quota-sets/#{tenant_id}"
  )
end
get_quota_defaults(tenant_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_quota_defaults.rb, line 5
def get_quota_defaults(tenant_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "/os-quota-sets/#{tenant_id}/defaults"
  )
end
get_security_group(security_group_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_security_group.rb, line 5
def get_security_group(security_group_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "os-security-groups/#{security_group_id}"
  )
end
get_security_group_rule(security_group_rule_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_security_group_rule.rb, line 5
def get_security_group_rule(security_group_rule_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "os-security-group-rules/#{security_group_rule_id}"
  )
end
get_server_details(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_server_details.rb, line 5
def get_server_details(server_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}"
  )
end
get_server_group(group_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_server_group.rb, line 5
def get_server_group(group_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "/os-server-groups/#{group_id}"
  )
end
get_server_password(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_server_password.rb, line 5
def get_server_password(server_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}/os-server-password"
  )
end
get_server_volumes(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_server_volumes.rb, line 5
def get_server_volumes(server_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "servers/#{server_id}/os-volume_attachments"
  )
end
get_snapshot_details(snapshot_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_snapshot_details.rb, line 5
def get_snapshot_details(snapshot_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "os-snapshots/#{snapshot_id}"
  )
end
get_usage(tenant_id, date_start, date_end) click to toggle source
# File lib/fog/openstack/compute/requests/get_usage.rb, line 5
def get_usage(tenant_id, date_start, date_end)
  params = {}
  params[:start] = date_start.utc.iso8601.chop!
  params[:end]   = date_end.utc.iso8601.chop!
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "os-simple-tenant-usage/#{tenant_id}",
    :query   => params
  )
end
get_vnc_console(server_id, console_type) click to toggle source

Get a vnc console for an instance. For microversion < 2.6 as it has been replaced with remote-consoles

Parameters

  • server_id <~String> - The ID of the server.

  • console_type <~String> - Type of vnc console to get ('novnc' or 'xvpvnc').

Returns

  • response <~Excon::Response>:

    • body <~Hash>:

      • url <~String>

      • type <~String>

# File lib/fog/openstack/compute/requests/get_vnc_console.rb, line 16
def get_vnc_console(server_id, console_type)
  fixed_microversion = nil
  if microversion_newer_than?('2.5')
    fixed_microversion = @microversion
    @microversion = '2.5'
  end

  body = {
    'os-getVNCConsole' => {
      'type' => console_type
    }
  }
  result = server_action(server_id, body)
  @microversion = fixed_microversion if fixed_microversion
  result
end
get_volume_details(volume_id) click to toggle source
# File lib/fog/openstack/compute/requests/get_volume_details.rb, line 5
def get_volume_details(volume_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "os-volumes/#{volume_id}"
  )
end
list_address_pools() click to toggle source
# File lib/fog/openstack/compute/requests/list_address_pools.rb, line 5
def list_address_pools
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "os-floating-ip-pools"
  )
end
list_addresses(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/list_addresses.rb, line 5
def list_addresses(server_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}/ips"
  )
end
list_aggregates(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_aggregates.rb, line 5
def list_aggregates(options = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'os-aggregates',
    :query   => options
  )
end
list_all_addresses(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_all_addresses.rb, line 5
def list_all_addresses(options = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "os-floating-ips",
    :query   => options
  )
end
list_availability_zones(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_availability_zones.rb, line 5
def list_availability_zones(options = {})
  params = options

  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "os-availability-zone",
    :query   => params
  )
end
list_flavors(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_flavors.rb, line 5
def list_flavors(options = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'flavors',
    :query   => options
  )
end
list_flavors_detail(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_flavors_detail.rb, line 5
def list_flavors_detail(options = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'flavors/detail',
    :query   => options
  )
end
list_hosts(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_hosts.rb, line 5
def list_hosts(options = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'os-hosts',
    :query   => options
  )
end
list_hypervisor_servers(hypervisor_id, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_hypervisor_servers.rb, line 5
def list_hypervisor_servers(hypervisor_id, options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "os-hypervisors/#{hypervisor_id}/servers",
    :query   => options
  )
end
list_hypervisors(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_hypervisors.rb, line 5
def list_hypervisors(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-hypervisors',
    :query   => options
  )
end
list_hypervisors_detail(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_hypervisors_detail.rb, line 5
def list_hypervisors_detail(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-hypervisors/detail',
    :query   => options
  )
end
list_images() click to toggle source
# File lib/fog/openstack/compute/requests/list_images.rb, line 5
def list_images
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'images'
  )
end
list_images_detail(filters = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_images_detail.rb, line 5
def list_images_detail(filters = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'images/detail',
    :query   => filters
  )
end
list_key_pairs(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_key_pairs.rb, line 5
def list_key_pairs(options = {})
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'os-keypairs',
    :query   => options
  )
end
list_metadata(collection_name, parent_id) click to toggle source
# File lib/fog/openstack/compute/requests/list_metadata.rb, line 5
def list_metadata(collection_name, parent_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "/#{collection_name}/#{parent_id}/metadata"
  )
end
list_os_interfaces(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/list_os_interfaces.rb, line 5
def list_os_interfaces(server_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}/os-interface"
  )
end
list_private_addresses(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/list_private_addresses.rb, line 5
def list_private_addresses(server_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}/ips/private"
  )
end
list_public_addresses(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/list_public_addresses.rb, line 5
def list_public_addresses(server_id)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "servers/#{server_id}/ips/public"
  )
end
list_security_groups(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_security_groups.rb, line 5
def list_security_groups(options = {})
  path = "os-security-groups"

  if options.kind_of?(Hash)
    server_id = options.delete(:server_id)
    query = options
  else
    # Backwards compatibility layer, only server_id was passed as first parameter previously
    Fog::Logger.deprecation('Calling OpenStack[:compute].list_security_groups(server_id) is deprecated, use .list_security_groups(:server_id => value) instead')
    server_id = options
    query = {}
  end

  if server_id
    path = "servers/#{server_id}/#{path}"
  end

  request(
    :expects => [200],
    :method  => 'GET',
    :path    => path,
    :query   => query
  )
end
list_server_groups(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_server_groups.rb, line 5
def list_server_groups(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-server-groups',
    :query   => options
  )
end
list_servers(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_servers.rb, line 5
def list_servers(options = {})
  params = options.dup
  if params[:all_tenants]
    params['all_tenants'] = 'True'
    params.delete(:all_tenants)
  end

  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'servers',
    :query   => params
  )
end
list_servers_detail(options = {}) click to toggle source

Available filters: name, status, image, flavor, changes_since, reservation_id

# File lib/fog/openstack/compute/requests/list_servers_detail.rb, line 6
def list_servers_detail(options = {})
  params = options.dup
  if params[:all_tenants]
    params['all_tenants'] = 'True'
    params.delete(:all_tenants)
  end

  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'servers/detail',
    :query   => params
  )
end
list_services(parameters = nil) click to toggle source
# File lib/fog/openstack/compute/requests/list_services.rb, line 5
def list_services(parameters = nil)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'os-services',
    :query   => parameters
  )
end
list_snapshots(options = true) click to toggle source
# File lib/fog/openstack/compute/requests/list_snapshots.rb, line 5
def list_snapshots(options = true)
  if options.kind_of?(Hash)
    path = 'os-snapshots'
    query = options
  else
    # Backwards compatibility layer, when 'detailed' boolean was sent as first param
    if options
      Fog::Logger.deprecation('Calling OpenStack[:compute].list_snapshots(true) is deprecated, use .list_snapshots_detail instead')
    else
      Fog::Logger.deprecation('Calling OpenStack[:compute].list_snapshots(false) is deprecated, use .list_snapshots({}) instead')
    end
    path = options ? 'os-snapshots/detail' : 'os-snapshots'
    query = {}
  end

  request(
    :expects => 200,
    :method  => 'GET',
    :path    => path,
    :query   => query
  )
end
list_snapshots_detail(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_snapshots_detail.rb, line 5
def list_snapshots_detail(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-snapshots/detail',
    :query   => options
  )
end
list_tenants_with_flavor_access(flavor_ref) click to toggle source
# File lib/fog/openstack/compute/requests/list_tenants_with_flavor_access.rb, line 5
def list_tenants_with_flavor_access(flavor_ref)
  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => "flavors/#{flavor_ref}/os-flavor-access"
  )
end
list_usages(date_start = nil, date_end = nil, detailed = false) click to toggle source
# File lib/fog/openstack/compute/requests/list_usages.rb, line 5
def list_usages(date_start = nil, date_end = nil, detailed = false)
  params = {}
  params[:start] = date_start.iso8601.gsub(/\+.*/, '') if date_start
  params[:end]   = date_end.iso8601.gsub(/\+.*/, '')   if date_end
  params[:detailed] = (detailed ? '1' : '0')           if detailed

  request(
    :expects => [200, 203],
    :method  => 'GET',
    :path    => 'os-simple-tenant-usage',
    :query   => params
  )
end
list_volume_attachments(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/list_volume_attachments.rb, line 5
def list_volume_attachments(server_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => format('servers/%s/os-volume_attachments', server_id)
  )
end
list_volumes(options = true) click to toggle source
# File lib/fog/openstack/compute/requests/list_volumes.rb, line 5
def list_volumes(options = true)
  if options.kind_of?(Hash)
    path = 'os-volumes'
    query = options
  else
    # Backwards compatibility layer, when 'detailed' boolean was sent as first param
    if options
      Fog::Logger.deprecation('Calling OpenStack[:compute].list_volumes(true) is deprecated, use .list_volumes_detail instead')
    else
      Fog::Logger.deprecation('Calling OpenStack[:compute].list_volumes(false) is deprecated, use .list_volumes({}) instead')
    end
    path = options ? 'os-volumes/detail' : 'os-volumes'
    query = {}
  end

  request(
    :expects => 200,
    :method  => 'GET',
    :path    => path,
    :query   => query
  )
end
list_volumes_detail(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_volumes_detail.rb, line 5
def list_volumes_detail(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-volumes/detail',
    :query   => options
  )
end
list_zones(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_zones.rb, line 5
def list_zones(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-availability-zone',
    :query   => options
  )
end
list_zones_detailed(options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/list_zones_detailed.rb, line 5
def list_zones_detailed(options = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'os-availability-zone/detail',
    :query   => options
  )
end
live_migrate_server(server_id, host, block_migration, disk_over_commit) click to toggle source
# File lib/fog/openstack/compute/requests/live_migrate_server.rb, line 5
def live_migrate_server(server_id, host, block_migration, disk_over_commit)
  body = {
    'os-migrateLive' => {
      'host'             => host,
      'block_migration'  => block_migration,
      'disk_over_commit' => disk_over_commit,
    }
  }
  server_action(server_id, body)
end
migrate_server(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/migrate_server.rb, line 5
def migrate_server(server_id)
  body = {'migrate' => nil}
  server_action(server_id, body)
end
pause_server(server_id) click to toggle source

Pause the server.

Parameters

  • server_id <~String> - The ID of the server to pause.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/pause_server.rb, line 11
def pause_server(server_id)
  body = {'pause' => nil}
  server_action(server_id, body).status == 202
end
reboot_server(server_id, type = 'SOFT') click to toggle source
# File lib/fog/openstack/compute/requests/reboot_server.rb, line 5
def reboot_server(server_id, type = 'SOFT')
  body = {'reboot' => {'type' => type}}
  server_action(server_id, body)
end
rebuild_server(server_id, image_ref, name, admin_pass = nil, metadata = nil, personality = nil) click to toggle source
# File lib/fog/openstack/compute/requests/rebuild_server.rb, line 5
def rebuild_server(server_id, image_ref, name, admin_pass = nil, metadata = nil, personality = nil)
  body = {'rebuild' => {
    'imageRef' => image_ref,
    'name'     => name
  }}
  body['rebuild']['adminPass'] = admin_pass if admin_pass
  body['rebuild']['metadata'] = metadata if metadata
  if personality
    body['rebuild']['personality'] = []
    personality.each do |file|
      body['rebuild']['personality'] << {
        'contents' => Base64.encode64(file['contents']),
        'path'     => file['path']
      }
    end
  end
  server_action(server_id, body, 202)
end
release_address(address_id) click to toggle source
# File lib/fog/openstack/compute/requests/release_address.rb, line 5
def release_address(address_id)
  request(
    :expects => [200, 202],
    :method  => 'DELETE',
    :path    => "os-floating-ips/#{address_id}"
  )
end
remote_consoles(server_id, protocol, type) click to toggle source

Get a vnc console for an instance. For microversion >= 2.6

Parameters

  • server_id <~String> - The ID of the server.

  • protocol <~String> - The protocol of remote console. The valid values are vnc, spice, rdp, serial and mks. The protocol mks is added since Microversion 2.8.

  • type <~String> - The type of remote console. The valid values are novnc, xvpvnc, rdp-html5, spice-html5, serial, and webmks. The type webmks is added since Microversion 2.8.

Returns

  • response <~Excon::Response>:

    • body <~Hash>:

      • url <~String>

      • type <~String>

      • protocol <~String>

# File lib/fog/openstack/compute/requests/remote_consoles.rb, line 20
def remote_consoles(server_id, protocol, type)
  if microversion_newer_than?('2.6')
    body = {
      'remote_console' => {
        'protocol' => protocol, 'type' => type
      }
    }

    request(
      :body    => Fog::JSON.encode(body),
      :expects => 200,
      :method  => 'POST',
      :path    => "servers/#{server_id}/remote-consoles"
    )
  end
end
remove_aggregate_host(uuid, host_uuid) click to toggle source
# File lib/fog/openstack/compute/requests/remove_aggregate_host.rb, line 5
def remove_aggregate_host(uuid, host_uuid)
  data = {'remove_host' => {'host' => host_uuid}}
  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200],
    :method  => 'POST',
    :path    => "os-aggregates/#{uuid}/action"
  )
end
remove_fixed_ip(server_id, address) click to toggle source

Remove an IP address.

Parameters

  • server_id <~String> - The ID of the server in which to remove an IP from.

  • address <~String> - The IP address to be removed.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/remove_fixed_ip.rb, line 12
def remove_fixed_ip(server_id, address)
  body = {
    'removeFixedIp' => {
      'address' => address
    }
  }
  server_action(server_id, body).status == 202
end
remove_flavor_access(flavor_ref, tenant_id) click to toggle source
# File lib/fog/openstack/compute/requests/remove_flavor_access.rb, line 5
def remove_flavor_access(flavor_ref, tenant_id)
  request(
    :body    => Fog::JSON.encode("removeTenantAccess" => {
                                   "tenant" => tenant_id.to_s
                                 }),
    :expects => [200, 203],
    :method  => 'POST',
    :path    => "flavors/#{flavor_ref}/action"
  )
end
remove_security_group(server_id, group_name) click to toggle source
# File lib/fog/openstack/compute/requests/remove_security_group.rb, line 5
def remove_security_group(server_id, group_name)
  body = {'removeSecurityGroup' => {"name" => group_name}}
  server_action(server_id, body)
end
rescue_server(server_id) click to toggle source

Rescue the server.

Parameters

  • server_id <~String> - The ID of the server to be rescued.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/rescue_server.rb, line 11
def rescue_server(server_id)
  body = {'rescue' => nil}
  server_action(server_id, body) == 202
end
reset_server_state(server_id, status) click to toggle source
# File lib/fog/openstack/compute/requests/reset_server_state.rb, line 5
def reset_server_state(server_id, status)
  body = {'os-resetState' => {'state' => status}}
  server_action(server_id, body, 202)
end
resize_server(server_id, flavor_ref) click to toggle source
# File lib/fog/openstack/compute/requests/resize_server.rb, line 5
def resize_server(server_id, flavor_ref)
  body = {'resize' => {'flavorRef' => flavor_ref}}
  server_action(server_id, body)
end
resume_server(server_id) click to toggle source

Resume the server.

Parameters

  • server_id <~String> - The ID of the server to be resumed.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/resume_server.rb, line 11
def resume_server(server_id)
  body = {'resume' => nil}
  server_action(server_id, body).status == 202
end
revert_resize_server(server_id) click to toggle source
# File lib/fog/openstack/compute/requests/revert_resize_server.rb, line 5
def revert_resize_server(server_id)
  body = {'revertResize' => nil}
  server_action(server_id, body)
end
server_action(server_id, body, expects = [200, 202]) click to toggle source
# File lib/fog/openstack/compute/requests/server_action.rb, line 5
def server_action(server_id, body, expects = [200, 202])
  request(
    :body    => Fog::JSON.encode(body),
    :expects => expects,
    :method  => 'POST',
    :path    => "servers/#{server_id}/action"
  )
end
server_actions(server_id) click to toggle source

Retrieve server actions.

Parameters

  • server_id <~String> - The ID of the server to query for available actions.

Returns

  • actions <~Array>

# File lib/fog/openstack/compute/requests/server_actions.rb, line 11
def server_actions(server_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "servers/#{server_id}/os-instance-actions"
  ).body['instanceActions']
end
server_diagnostics(server_id) click to toggle source

Retrieve server diagnostics.

Parameters

  • server_id <~String> - The ID of the server to retrieve diagnostics.

Returns

  • actions <~Array>

# File lib/fog/openstack/compute/requests/server_diagnostics.rb, line 11
def server_diagnostics(server_id)
  request(
    :method => 'GET',
    :path   => "servers/#{server_id}/diagnostics"
  )
end
set_metadata(collection_name, parent_id, metadata = {}) click to toggle source
# File lib/fog/openstack/compute/requests/set_metadata.rb, line 5
def set_metadata(collection_name, parent_id, metadata = {})
  request(
    :body    => Fog::JSON.encode('metadata' => metadata),
    :expects => 200,
    :method  => 'PUT',
    :path    => "#{collection_name}/#{parent_id}/metadata"
  )
end
set_tenant(tenant) click to toggle source
# File lib/fog/openstack/compute/requests/set_tenant.rb, line 5
def set_tenant(tenant)
  @openstack_must_reauthenticate = true
  @openstack_tenant = tenant.to_s
  authenticate
end
shelve_offload_server(server_id) click to toggle source

Shelve Off load the server. Data and resource associations are deleted.

Parameters

  • server_id <~String> - The ID of the server to be shelve off loaded

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/shelve_offload_server.rb, line 11
def shelve_offload_server(server_id)
  body = {'shelveOffload' => nil}
  server_action(server_id, body).status == 202
end
shelve_server(server_id) click to toggle source

Shelve the server.

Parameters

  • server_id <~String> - The ID of the server to be shelved

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/shelve_server.rb, line 11
def shelve_server(server_id)
  body = {'shelve' => nil}
  server_action(server_id, body).status == 202
end
start_server(server_id) click to toggle source

Start the server.

Parameters

  • server_id <~String> - The ID of the server to be started.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/start_server.rb, line 11
def start_server(server_id)
  body = {'os-start' => nil}
  server_action(server_id, body).status == 202
end
stop_server(server_id) click to toggle source

Stop the server.

Parameters

  • server_id <~String> - The ID of the server to be stopped.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/stop_server.rb, line 11
def stop_server(server_id)
  body = {'os-stop' => nil}
  server_action(server_id, body).status == 202
end
suspend_server(server_id) click to toggle source

Suspend the server.

Parameters

  • server_id <~String> - The ID of the server to suspend.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/suspend_server.rb, line 11
def suspend_server(server_id)
  body = {'suspend' => nil}
  server_action(server_id, body).status == 202
end
unpause_server(server_id) click to toggle source

Unpause the server.

Parameters

  • server_id <~String> - The ID of the server to unpause.

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/unpause_server.rb, line 11
def unpause_server(server_id)
  body = {'unpause' => nil}
  server_action(server_id, body).status == 202
end
unshelve_server(server_id) click to toggle source

Unshelve the server.

Parameters

  • server_id <~String> - The ID of the server to be unshelved

Returns

  • success <~Boolean>

# File lib/fog/openstack/compute/requests/unshelve_server.rb, line 11
def unshelve_server(server_id)
  body = {'unshelve' => nil}
  server_action(server_id, body).status == 202
end
update_aggregate(uuid, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/update_aggregate.rb, line 5
def update_aggregate(uuid, options = {})
  vanilla_options = [:name, :availability_zone]

  data = {'aggregate' => {}}
  vanilla_options.select { |o| options[o] }.each do |key|
    data['aggregate'][key] = options[key]
  end

  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200],
    :method  => 'PUT',
    :path    => "os-aggregates/#{uuid}"
  )
end
update_aggregate_metadata(uuid, metadata = {}) click to toggle source
# File lib/fog/openstack/compute/requests/update_aggregate_metadata.rb, line 5
def update_aggregate_metadata(uuid, metadata = {})
  data = {'set_metadata' => {'metadata' => metadata}}
  request(
    :body    => Fog::JSON.encode(data),
    :expects => [200],
    :method  => 'POST',
    :path    => "os-aggregates/#{uuid}/action"
  )
end
update_flavor_metadata(flavor_ref, key, value) click to toggle source
# File lib/fog/openstack/compute/requests/update_flavor_metadata.rb, line 5
def update_flavor_metadata(flavor_ref, key, value)
  data = {key => value}

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 200,
    :method  => 'PUT',
    :path    => "flavors/#{flavor_ref}/os-extra_specs/#{key}"
  )
end
update_meta(collection_name, parent_id, key, value) click to toggle source
# File lib/fog/openstack/compute/requests/update_meta.rb, line 5
def update_meta(collection_name, parent_id, key, value)
  request(
    :body    => Fog::JSON.encode('meta' => {key => value}),
    :expects => 200,
    :method  => 'PUT',
    :path    => "#{collection_name}/#{parent_id}/metadata/#{key}"
  )
end
update_metadata(collection_name, parent_id, metadata = {}) click to toggle source
# File lib/fog/openstack/compute/requests/update_metadata.rb, line 5
def update_metadata(collection_name, parent_id, metadata = {})
  request(
    :body    => Fog::JSON.encode('metadata' => metadata),
    :expects => 200,
    :method  => 'POST',
    :path    => "#{collection_name}/#{parent_id}/metadata"
  )
end
update_quota(tenant_id, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/update_quota.rb, line 5
def update_quota(tenant_id, options = {})
  request(
    :body    => Fog::JSON.encode('quota_set' => options),
    :expects => 200,
    :method  => 'PUT',
    :path    => "/os-quota-sets/#{tenant_id}"
  )
end
update_server(server_id, options = {}) click to toggle source
# File lib/fog/openstack/compute/requests/update_server.rb, line 5
def update_server(server_id, options = {})
  request(
    :body    => Fog::JSON.encode('server' => options),
    :expects => 200,
    :method  => 'PUT',
    :path    => "servers/#{server_id}"
  )
end