In Files

Parent

Class/Module Index [+]

Quicksearch

Fog::Compute::Ecloud::Real

Public Class Methods

basic_request(name, expects=[200], method=:get, headers={}, body='') click to toggle source
# File lib/fog/ecloud/compute.rb, line 269
def basic_request(name, expects=[200], method=:get, headers={}, body='')
  define_method(name) do |uri|
    request({
      :expects => expects,
      :method  => method,
      :headers => headers,
      :body    => body,
      :parse   => true,
      :uri     => uri
    })
  end
end
new(options = {}) click to toggle source
# File lib/fog/ecloud/compute.rb, line 284
def initialize(options = {})
  require 'fog/core/parser'
  @connections             = {}
  @connection_options      = options[:connection_options] || {}
  @host                    = options[:ecloud_host] || API_URL
  @persistent              = options[:persistent] || false
  @version                 = options[:ecloud_version] || "2012-03-01"
  @authentication_method   = options[:ecloud_authentication_method] || :cloud_api_auth
  @access_key              = options[:ecloud_access_key]
  @private_key             = options[:ecloud_private_key]
  if @private_key.nil? || @authentication_method == :basic_auth
    @authentication_method = :basic_auth
    @username              = options[:ecloud_username]
    @password              = options[:ecloud_password]
    if @username.nil? || @password.nil?
      raise ArgumentError, "No credentials (cloud auth, or basic auth) passed!"
    end
  else
    @hmac = Fog::HMAC.new("sha256", @private_key)
  end
end

Public Instance Methods

authentication_levels_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/admin_edit_authentication_levels.rb, line 6
def authentication_levels_edit(data)
  validate_data([:basic, :sha1, :sha256, :sha512], data)
  body = build_authentication_levels_edit(data)
  request(
    :expects => 202,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => data[:uri],
    :parse => true
  )
end
backup_internet_service_create(data) click to toggle source
# File lib/fog/ecloud/requests/compute/backup_internet_service_create.rb, line 7
def backup_internet_service_create(data)
  validate_data([:name, :protocol, :enabled, :persistence], data)
  unless data[:persistence][:type]
    raise ArgumentError.new("Required data missing: :persistence[:type]")
  end          

  request(
    :body => generate_backup_internet_service_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
backup_internet_service_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/backup_internet_service_edit.rb, line 7
def backup_internet_service_edit(data)
  validate_data([:name, :protocol, :enabled, :persistence], data)
  unless data[:persistence][:type]
    raise ArgumentError.new("Required data missing: :persistence[:type]")
  end          

  request(
    :body => generate_backup_internet_service_request(data),
    :expects => 202,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
build_request_body_edit_hardware_configuration(data) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_edit_hardware_configuration.rb, line 19
def build_request_body_edit_hardware_configuration(data)
  xml = Builder::XmlMarkup.new
  xml.HardwareConfiguration do
    xml.ProcessorCount data[:cpus]
    xml.Memory do
      xml.Unit "MB"
      xml.Value data[:memory]
    end
    xml.Disks do
      data[:disks].each do |disk|
        xml.Disk do
          xml.Index disk[:Index]
          xml.Size do
            xml.Unit "GB"
            xml.Value disk[:Size][:Value]
          end
        end
      end
    end
    xml.Nics do
      data[:nics].each do |nic|
        xml.Nic do
          xml.UnitNumber nic[:UnitNumber]
          xml.MacAddress nic[:MacAddress]
          xml.Network(:href => nic[:Network][:href], :name => nic[:Network][:name], :type => "application/vnd.tmrk.cloud.network") do
          end
        end
      end
    end
  end
end
compute_pool_edit(options) click to toggle source
# File lib/fog/ecloud/requests/compute/compute_pool_edit.rb, line 22
def compute_pool_edit(options)
  validate_edit_compute_pool_options(options)
  body = build_compute_pool_body_edit(options)
  request(
    :expects => 200,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => options[:uri],
    :parse => true
  )
end
firewall_acls_create(data) click to toggle source
# File lib/fog/ecloud/requests/compute/firewall_acls_create.rb, line 8
def firewall_acls_create(data)
  validate_data([:permission, :protocol, :source, :destination], data)
  raise ArgumentError.new("Required data missing: source[:type] is required") unless data[:source][:type]
  raise ArgumentError.new("Required data missing: destination[:type] is required") unless data[:destination][:type]

  request(
    :body => generate_create_firewall_acls_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
get_virtual_machine_assigned_ips(virtual_machine_id) click to toggle source
# File lib/fog/ecloud/requests/compute/get_virtual_machine_assigned_ips.rb, line 6
def get_virtual_machine_assigned_ips(virtual_machine_id)
  request(
    :uri => "/cloudapi/ecloud/virtualmachines/#{virtual_machine_id}/assignedips",
    :parse   => true
  )
end
groups_create(data) click to toggle source
# File lib/fog/ecloud/requests/compute/groups_create.rb, line 7
def groups_create(data)
  validate_data([:name], data)

  request(
    :body => generate_groups_create_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
groups_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/groups_edit.rb, line 7
def groups_edit(data)
  validate_data([:name], data)

  request(
    :body => generate_groups_edit_request(data),
    :expects => 204,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => false
  )
end
internet_service_create(service_data) click to toggle source
# File lib/fog/ecloud/requests/compute/internet_service_create.rb, line 22
def internet_service_create(service_data)
  validate_internet_service_data(service_data)

  request(
    :body => generate_internet_service_request(service_data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => service_data[:uri],
    :parse => true
  )
end
login_banner_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/admin_edit_login_banner.rb, line 6
def login_banner_edit(data)
  validate_data([:display], data)
  body = build_login_banner_edit(data)
  request(
    :expects => 200,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => data[:uri],
    :parse => true
  )
end
monitors_create_ecv(data) click to toggle source
# File lib/fog/ecloud/requests/compute/monitors_create_ecv.rb, line 7
def monitors_create_ecv(data)
  validate_data([:interval, :response_timeout, :retries, :downtime, :enabled, :send_string, :receive_string], data)

  request(
    :body => generate_ecv_monitor_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
monitors_create_http(data) click to toggle source
# File lib/fog/ecloud/requests/compute/monitors_create_http.rb, line 7
def monitors_create_http(data)
  validate_data([:interval, :response_timeout, :retries, :downtime, :enabled, :request_uri, :response_codes], data)

  request(
    :body => generate_http_monitor_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
monitors_create_ping(data) click to toggle source
# File lib/fog/ecloud/requests/compute/monitors_create_ping.rb, line 7
def monitors_create_ping(data)
  validate_data([:interval, :response_timeout, :retries, :downtime, :enabled], data)

  request(
    :body => generate_ping_monitor_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
monitors_edit_ecv(data) click to toggle source
# File lib/fog/ecloud/requests/compute/monitors_edit_ecv.rb, line 7
def monitors_edit_ecv(data)
  validate_data([:interval, :response_timeout, :retries, :downtime, :enabled, :send_string, :receive_string], data)

  request(
    :body => generate_edit_ecv_request(data),
    :expects => 200,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
monitors_edit_http(data) click to toggle source
# File lib/fog/ecloud/requests/compute/monitors_edit_http.rb, line 7
def monitors_edit_http(data)
  validate_data([:interval, :response_timeout, :retries, :downtime, :enabled, :request_uri, :response_codes], data)

  request(
    :body => generate_edit_http_request(data),
    :expects => 200,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
monitors_edit_ping(data) click to toggle source
# File lib/fog/ecloud/requests/compute/monitors_edit_ping.rb, line 7
def monitors_edit_ping(data)
  validate_data([:interval, :response_timeout, :retries, :downtime, :enabled], data)

  request(
    :body => generate_edit_ping_request(data),
    :expects => 200,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
node_service_create(service_data) click to toggle source
# File lib/fog/ecloud/requests/compute/node_service_create.rb, line 16
def node_service_create(service_data)
  validate_node_service_data(service_data)

  request(
    :body => generate_node_service_request(service_data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => service_data[:uri],
    :parse => true
  )
end
node_service_edit(options) click to toggle source
# File lib/fog/ecloud/requests/compute/internet_service_edit.rb, line 45
def node_service_edit(options)
  validate_edit_node_service_options(options)
  body = build_node_service_body_edit(options)
  request(
    :expects => 202,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => options[:uri],
    :parse => true
  )
end
password_complexity_rules_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/admin_edit_password_complexity_rules.rb, line 6
def password_complexity_rules_edit(data)
  validate_data([:rule_type], data)
  if data[:rule_type] == "Custom"
    raise ArgumentError.new("Required data missing: custom_rules") unless data[:custom_rules]
  end
  validate_data([:minimum_characters, :minimum_uppercase_characters, :minimum_lowercase_characters, :minimum_numeric_characters, :minimum_special_characters, :maximum_consecutive_characters_from_prior_passwords, :minimum_lifetime_restriction, :minimum_generations_before_reuse], data[:custom_rules])
  body = build_password_complexity_rules_edit(data)
  request(
    :expects => 202,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => data[:uri],
    :parse => true
  )
end
request(params) click to toggle source
# File lib/fog/ecloud/compute.rb, line 306
def request(params)
  # Convert the uri to a URI if it's a string.
  if params[:uri].is_a?(String)
    params[:uri] = URI.parse(@host + params[:uri])
  end
  host_url = "#{params[:uri].scheme}://#{params[:uri].host}#{params[:uri].port ? ":#{params[:uri].port}" : ''}"

  # Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
  # different hosts.
  @connections[host_url] ||= Fog::Connection.new(host_url, @persistent, @connection_options)

  # Set headers to an empty hash if none are set.
  headers = set_extra_headers_for(params) || set_extra_headers_for({})

  # Make the request
  options = {
    :expects => (params[:expects] || 200),
    :method  => params[:method] || 'GET',
    :path    => params[:uri].path + "#{"?#{params[:uri].query}" if params[:uri].query}",
    :headers => headers
  }
  unless params[:body].nil? || params[:body].empty?
    options.merge!({:body => params[:body]})
  end
  response = @connections[host_url].request(options)
  # Parse the response body into a hash
  unless response.body.empty?
    if params[:parse]
      document = Fog::ToHashDocument.new
      parser = Nokogiri::XML::SAX::PushParser.new(document)
      parser << response.body
      parser.finish

      response.body = document.body
    end
  end

  response
end
rnat_associations_create_device(data) click to toggle source
# File lib/fog/ecloud/requests/compute/rnat_associations_create_device.rb, line 7
def rnat_associations_create_device(data)
  validate_data([:host_ip_href, :public_ip_href], data)

  request(
    :body => generate_rnat_associations_create_device_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
rnat_associations_edit_network(data) click to toggle source
# File lib/fog/ecloud/requests/compute/rnat_associations_edit_network.rb, line 7
def rnat_associations_edit_network(data)
  validate_data([:href], data)

  request(
    :body => generate_rnat_associations_edit_network_request(data),
    :expects => 202,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
rows_create(data) click to toggle source
# File lib/fog/ecloud/requests/compute/rows_create.rb, line 7
def rows_create(data)
  validate_data([:name], data)

  request(
    :body => generate_rows_create_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
rows_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/rows_edit.rb, line 7
def rows_edit(data)
  validate_data([:name], data)

  request(
    :body => generate_rows_edit_request(data),
    :expects => 204,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => false
  )
end
trusted_network_groups_create(data) click to toggle source
# File lib/fog/ecloud/requests/compute/trusted_network_groups_create.rb, line 8
def trusted_network_groups_create(data)
  validate_data([:name], data)
  unless (data[:hosts] || data[:networks])
    raise ArgumentError.new("Required data missing: Either hosts or networks must be present")
  end
  

  request(
    :body => generate_create_trusted_network_groups_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
trusted_network_groups_edit(data) click to toggle source
# File lib/fog/ecloud/requests/compute/trusted_network_groups_edit.rb, line 8
def trusted_network_groups_edit(data)
  validate_data([:name], data)
  unless (data[:hosts] || data[:networks])
    raise ArgumentError.new("Required data missing: Either hosts or networks must be present")
  end
  

  request(
    :body => generate_edit_trusted_network_groups_request(data),
    :expects => 202,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  )
end
virtual_machine_attach_disk(href, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_attach_disk.rb, line 17
def virtual_machine_attach_disk(href, options)
  body = build_request_body_attach_disk(options)
  request(
    :expects => 202,
    :method => 'POST',
    :headers => {},
    :body => body,
    :uri => href,
    :parse => true
  )
end
virtual_machine_copy(template_uri, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_copy.rb, line 103
def virtual_machine_copy(template_uri, options)
  options = validate_create_server_options_copy(template_uri, options)
  body = build_request_body_copy(options)
  request(
    :expects => 201,
    :method => 'POST',
    :headers => {},
    :body => body,
    :uri => template_uri,
    :parse => true
  )
end
virtual_machine_copy_identical(template_uri, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_copy_identical.rb, line 30
def virtual_machine_copy_identical(template_uri, options)
  options = validate_create_server_options_identical(template_uri, options)
  body = build_request_body_identical(options)
  request(
    :expects => 201,
    :method => 'POST',
    :headers => {},
    :body => body,
    :uri => template_uri,
    :parse => true
  )
end
virtual_machine_create_from_template(template_uri, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_create_from_template.rb, line 103
def virtual_machine_create_from_template(template_uri, options)
  options = validate_create_server_options(template_uri, options)

  request(
    :expects => 201,
    :method  => 'POST',
    :body    => build_request_body(options),
    :uri     => options[:uri],
    :parse   => true
  )
end
virtual_machine_detach_disk(href, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_detach_disk.rb, line 18
def virtual_machine_detach_disk(href, options)
  body = build_request_body_detach_disk(options)
  request(
    :expects => 201,
    :method => 'POST',
    :headers => {},
    :body => body,
    :uri => href,
    :parse => true
  )
end
virtual_machine_edit(vm_uri, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_edit.rb, line 32
def virtual_machine_edit(vm_uri, options)
  validate_edit_server_options(options)
  body = build_request_body_edit(options)
  request(
    :expects => [202,204],
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => vm_uri,
    :parse => true
  )
end
virtual_machine_edit_assigned_ips(href, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_edit_assigned_ips.rb, line 26
def virtual_machine_edit_assigned_ips(href, options)
  body = build_request_body_edit_assigned_ips(options)
  request(
    :expects => 202,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => href,
    :parse => true
  )
end
virtual_machine_edit_hardware_configuration(vm_uri, data) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_edit_hardware_configuration.rb, line 6
def virtual_machine_edit_hardware_configuration(vm_uri, data)
  validate_data([:cpus, :memory, :disks, :nics], data)
  body = build_request_body_edit_hardware_configuration(data)
  request(
    :expects => 202,
    :method => 'PUT',
    :headers => {},
    :body => body,
    :uri => vm_uri,
    :parse => true
  )
end
virtual_machine_import(template_uri, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_import.rb, line 52
def virtual_machine_import(template_uri, options)
  options = validate_import_server_options(template_uri, options)

  request(
    :expects => 201,
    :method  => 'POST',
    :body    => build_request_body_import(options),
    :uri     => options[:uri],
    :parse   => true
  )
end
virtual_machine_upload_file(vm_uri, options) click to toggle source
# File lib/fog/ecloud/requests/compute/virtual_machine_upload_file.rb, line 17
def virtual_machine_upload_file(vm_uri, options)
  validate_upload_file_options(options)
  request(
    :expects => 204,
    :method => 'POST',
    :headers => {'Content-Type' => 'application/octet-stream', 'X-Guest-User' => options[:credentials][:user], 'X-Guest-Password' => options[:credentials][:password], 'Content-Range' => "0-#{options[:file].bytesize - 1}/#{options[:file].bytesize}"},
    :body => options[:file],
    :uri => vm_uri + "?path=#{options[:path]}",
    :parse => true
  )
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.