class Fog::Compute::Ecloud::Real

Public Class Methods

basic_request(name, expects = [200], method = :get, headers = {}, body = "") click to toggle source
# File lib/fog/compute/ecloud.rb, line 277
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/compute/ecloud.rb, line 291
def initialize(options = {})
  @base_path               = options[:base_path] || "/cloudapi/ecloud"
  @connections             = {}
  @connection_options      = options[:connection_options] || {}
  @host                    = options[:ecloud_host] || API_URL
  @persistent              = options[:persistent] || false
  @version                 = options[:ecloud_version] || "2015-05-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
    if @access_key.nil?
      raise ArgumentError, "Incomplete cloud auth credentials supplied!"
    end
    @private_key = @private_key.to_s
    @access_key = @access_key.to_s
    @hmac = Fog::HMAC.new("sha256", @private_key)
  end
end

Public Instance Methods

authentication_levels_edit(data) click to toggle source
# File lib/fog/compute/ecloud/requests/admin_edit_authentication_levels.rb, line 5
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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/virtual_machine_edit_hardware_configuration.rb, line 18
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/compute/ecloud/requests/compute_pool_edit.rb, line 20
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/compute/ecloud/requests/firewall_acls_create.rb, line 7
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/compute/ecloud/requests/get_virtual_machine_assigned_ips.rb, line 5
def get_virtual_machine_assigned_ips(virtual_machine_id)
  request(
    :uri => "#{base_path}/virtualmachines/#{virtual_machine_id}/assignedips",
    :parse   => true
  )
end
groups_create(data) click to toggle source
# File lib/fog/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/admin_edit_login_banner.rb, line 5
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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/internet_service_edit.rb, line 43
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/compute/ecloud/requests/admin_edit_password_complexity_rules.rb, line 5
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/compute/ecloud.rb, line 318
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::XML::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

  begin
    response = @connections[host_url].request(options)
  rescue Excon::Errors::Error => error
    raise ServiceError.slurp(error)
  end

  # 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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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/compute/ecloud/requests/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
ssh_key_create(data) click to toggle source
# File lib/fog/compute/ecloud/requests/ssh_key_create.rb, line 7
def ssh_key_create(data)
  validate_data([:Name], data)

  request(
    :body => generate_ssh_key_create_request(data),
    :expects => 201,
    :method => "POST",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  ).body
end
ssh_key_edit(data) click to toggle source
# File lib/fog/compute/ecloud/requests/ssh_key_edit.rb, line 7
def ssh_key_edit(data)
  request(
    :body => generate_ssh_key_edit_request(data),
    :expects => 200,
    :method => "PUT",
    :headers => {},
    :uri => data[:uri],
    :parse => true
  ).body
end
trusted_network_groups_create(data) click to toggle source
# File lib/fog/compute/ecloud/requests/trusted_network_groups_create.rb, line 7
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/compute/ecloud/requests/trusted_network_groups_edit.rb, line 7
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/compute/ecloud/requests/virtual_machine_attach_disk.rb, line 16
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/compute/ecloud/requests/virtual_machine_copy.rb, line 101
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/compute/ecloud/requests/virtual_machine_copy_identical.rb, line 28
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/compute/ecloud/requests/virtual_machine_create_from_template.rb, line 102
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/compute/ecloud/requests/virtual_machine_detach_disk.rb, line 17
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/compute/ecloud/requests/virtual_machine_edit.rb, line 30
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/compute/ecloud/requests/virtual_machine_edit_assigned_ips.rb, line 24
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/compute/ecloud/requests/virtual_machine_edit_hardware_configuration.rb, line 5
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/compute/ecloud/requests/virtual_machine_import.rb, line 50
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/compute/ecloud/requests/virtual_machine_upload_file.rb, line 14
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

Private Instance Methods

build_authentication_levels_edit(data) click to toggle source
# File lib/fog/compute/ecloud/requests/admin_edit_authentication_levels.rb, line 20
def build_authentication_levels_edit(data)
  xml = Builder::XmlMarkup.new
  xml.AuthenticationLevels do
    xml.BasicEnabled data[:basic]
    xml.SHA1Enabled data[:sha1]
    xml.SHA256Enabled data[:sha256]
    xml.SHA512Enabled data[:sha512]
  end
end
build_login_banner_edit(data) click to toggle source
# File lib/fog/compute/ecloud/requests/admin_edit_login_banner.rb, line 20
def build_login_banner_edit(data)
  xml = Builder::XmlMarkup.new
  xml.LoginBanner do
    xml.Display data[:display]
    xml.Text data[:text] if data[:text]
  end
end
build_password_complexity_rules_edit(data) click to toggle source
# File lib/fog/compute/ecloud/requests/admin_edit_password_complexity_rules.rb, line 24
def build_password_complexity_rules_edit(data)
  xml = Builder::XmlMarkup.new
  xml.PasswordComplexityRules do
    xml.RuleType data[:rule_type]
    if data[:rule_type] == "Custom"
      xml.CustomRules do
        xml.MinimumCharacters do
          xml.Enabled data[:custom_rules][:minimum_characters][:enabled]
          xml.Value data[:custom_rules][:minimum_characters][:value]
        end
        xml.MinimumUpperCaseCharacters do
          xml.Enabled data[:custom_rules][:minimum_uppercase_characters][:enabled]
          xml.Value data[:custom_rules][:minimum_uppercase_characters][:value]
        end
        xml.MinimumLowerCaseCharacters do
          xml.Enabled data[:custom_rules][:minimum_lowercase_characters][:enabled]
          xml.Value data[:custom_rules][:minimum_lowercase_characters][:value]
        end
        xml.MinimumNumericCharacters do
          xml.Enabled data[:custom_rules][:minimum_numeric_characters][:enabled]
          xml.Value data[:custom_rules][:minimum_numeric_characters][:value]
        end
        xml.MinimumSpecialCharacters do
          xml.Enabled data[:custom_rules][:minimum_special_characters][:enabled]
          xml.Value data[:custom_rules][:minimum_special_characters][:value]
        end
        xml.MaximumConsecutiveCharactersFromPriorPasswords do
          xml.Enabled data[:custom_rules][:maximum_consecutive_characters_from_prior_passwords][:enabled]
          xml.Value data[:custom_rules][:maximum_consecutive_characters_from_prior_passwords][:value]
        end
        xml.MinimumLifetimeRestriction do
          xml.Enabled data[:custom_rules][:minimum_lifetime_restriction][:enabled]
          xml.Value data[:custom_rules][:minimum_lifetime_restriction][:value]
        end
        xml.MinimumGenerationsBeforeReuse do
          xml.Enabled data[:custom_rules][:minimum_generations_before_reuse][:enabled]
          xml.Value data[:custom_rules][:minimum_generations_before_reuse][:value]
        end
      end
    end
    if data[:description]
      xml.Description data[:description]
    end
  end
end
canonicalize_headers(headers) click to toggle source

section 5.6.3.2 in the ~1000 page pdf spec

# File lib/fog/compute/ecloud.rb, line 417
def canonicalize_headers(headers)
  tmp = headers.inject({}) do |ret, h|
    ret[h.first.downcase] = h.last if h.first.match(/^x-tmrk/i)
    ret
  end
  tmp.reject! { |k, _v| k == "x-tmrk-authorization" }
  tmp = tmp.sort.map { |e| "#{e.first}:#{e.last}" }.join("\n")
  tmp
end
canonicalize_resource(path) click to toggle source

section 5.6.3.3 in the ~1000 page pdf spec

# File lib/fog/compute/ecloud.rb, line 428
def canonicalize_resource(path)
  uri, query_string = path.split("?")
  return uri.downcase if query_string.nil?
  query_string_pairs = query_string.split("&").sort.map { |e| e.split("=") }
  tm_query_string = query_string_pairs.map { |x| "#{x.first.downcase}:#{x.last}" }.join("\n")
  "#{uri.downcase}\n#{tm_query_string}\n"
end
cloud_api_signature(params) click to toggle source
# File lib/fog/compute/ecloud.rb, line 399
def cloud_api_signature(params)
  verb = params[:method].to_s.upcase
  headers = params[:headers]
  path = params[:uri].path
  canonicalized_headers = canonicalize_headers(headers)
  canonicalized_resource = canonicalize_resource(path)
  string = [
    verb,
    headers["Content-Length"].to_s,
    headers["Content-Type"].to_s,
    headers["Date"].to_s,
    canonicalized_headers,
    canonicalized_resource + "\n"
  ].join("\n")
  Base64.encode64(@hmac.sign(string)).chomp
end
generate_backup_internet_service_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/backup_internet_service_create.rb, line 25
def generate_backup_internet_service_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateBackupInternetService(:name => data[:name]) do
    xml.Protocol data[:protocol]
    xml.Enabled data[:enabled]
    if data[:description]
      xml.Description data[:description]
    end
    xml.Persistence do
      xml.Type data[:persistence][:type]
      if data[:persistence][:timeout]
        xml.Timeout data[:persistence][:timeout]
      end
    end
    if data[:redirect_url]
      xml.RedirectUrl data[:redirect_url]
    end
  end
end
generate_create_firewall_acls_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/firewall_acls_create.rb, line 24
def generate_create_firewall_acls_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateFirewallAcl do
    xml.Permission data[:permission]
    xml.Protocol data[:protocol]
    xml.Source do
      xml.Type data[:source][:type]
      if data[:source][:external_ip_address]
        xml.ExternalIpAddress data[:external_ip_address]
      end
      if data[:source][:external_network]
        xml.ExternalNetwork do
          xml.Address data[:source][:external_network][:address]
          xml.Size data[:source][:external_network][:size]
        end
      end
      if data[:source][:ip_address]
        xml.IpAddress(:href => data[:source][:ip_address])
      end
      if data[:source][:network]
        xml.Network(:href => data[:source][:network][:href], :name => data[:source][:network][:name])
      end
    end
    xml.Destination do
      xml.Type data[:destination][:type]
      if data[:destination][:external_ip_address]
        xml.ExternalIpAddress data[:external_ip_address]
      end
      if data[:destination][:external_network]
        xml.ExternalNetwork do
          xml.Address data[:destination][:external_network][:address]
          xml.Size data[:destination][:external_network][:size]
        end
      end
      if data[:destination][:ip_address]
        xml.IpAddress(:href => data[:destination][:ip_address])
      end
      if data[:destination][:network]
        xml.Network(:href => data[:destination][:network][:href], :name => data[:destination][:network][:name])
      end
    end
    xml.PortRange do
      if data[:port_range][:start]
        xml.Start data[:port_range][:start]
      end
      if data[:port_range][:end]
        xml.End data[:port_range][:end]
      end
    end
  end
end
generate_create_trusted_network_groups_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/trusted_network_groups_create.rb, line 25
def generate_create_trusted_network_groups_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateTrustedNetworkGroup(:name => data[:name]) do
    if data[:hosts]
      xml.Hosts do
        data[:hosts].each do |ip|
          xml.IpAddress ip
        end
      end
    end
    if data[:networks]
      xml.Networks do
        data[:networks].each do |network|
          address, subnet = network.split("/")
          xml.Network do
            xml.Address address
            xml.Size subnet
          end
        end
      end
    end
  end
end
generate_ecv_monitor_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/monitors_create_ecv.rb, line 22
def generate_ecv_monitor_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateEcvMonitor do
    xml.Interval data[:interval]
    xml.ResponseTimeout data[:response_timeout]
    xml.Retries data[:retries]
    xml.Downtime data[:downtime]
    xml.Enabled data[:enabled]
    xml.SendString data[:send_string]
    if data[:http_headers]
      xml.HttpHeaders data[:http_headers]
    end
    xml.ReceiveString data[:receive_string]
  end
end
generate_edit_ecv_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/monitors_edit_ecv.rb, line 22
def generate_edit_ecv_request(data)
  xml = Builder::XmlMarkup.new
  xml.EcvMonitor do
    xml.Interval data[:interval]
    xml.ResponseTimeout data[:response_timeout]
    xml.Retries data[:retries]
    xml.Downtime data[:downtime]
    xml.Enabled data[:enabled]
    xml.SendString data[:send_string]
    if data[:http_headers]
      xml.HttpHeaders data[:http_headers]
    end
    xml.ReceiveString data[:receive_string]
  end
end
generate_edit_http_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/monitors_edit_http.rb, line 22
def generate_edit_http_request(data)
  xml = Builder::XmlMarkup.new
  xml.HttpMonitor do
    xml.Interval data[:interval]
    xml.ResponseTimeout data[:response_timeout]
    xml.Retries data[:retries]
    xml.Downtime data[:downtime]
    xml.Enabled data[:enabled]
    xml.RequestUri data[:request_uri]
    if xml[:httpheaders]
      xml.HttpHeaders xml[:http_headers]
    end
    xml.ResponseCodes do
      xml[:response_codes].each do |c|
        xml.ResponseCode c
      end
    end
  end
end
generate_edit_ping_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/monitors_edit_ping.rb, line 22
def generate_edit_ping_request(data)
  xml = Builder::XmlMarkup.new
  xml.PingMonitor do
    xml.Interval data[:interval]
    xml.ResponseTimeout data[:response_timeout]
    xml.Retries data[:retries]
    xml.Downtime data[:downtime]
    xml.Enabled data[:enabled]
  end
end
generate_edit_trusted_network_groups_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/trusted_network_groups_edit.rb, line 25
def generate_edit_trusted_network_groups_request(data)
  xml = Builder::XmlMarkup.new
  xml.TrustedNetworkGroup(:name => data[:name]) do
    if data[:hosts]
      xml.Hosts do
        data[:hosts].each do |ip|
          xml.IpAddress ip
        end
      end
    end
    if data[:networks]
      xml.Networks do
        data[:networks].each do |network|
          address, subnet = network.split("/")
          xml.Network do
            xml.Address address
            xml.Size subnet
          end
        end
      end
    end
  end
end
generate_groups_create_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/groups_create.rb, line 22
def generate_groups_create_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateLayoutGroup(:name => data[:name]) do
    xml.Row(:href => data[:href], :name => data[:row_name], :type => "application/vnd.tmrk.cloud.layoutRow")
  end
end
generate_groups_edit_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/groups_edit.rb, line 22
def generate_groups_edit_request(data)
  xml = Builder::XmlMarkup.new
  xml.LayoutGroup(:name => data[:name])
end
generate_http_monitor_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/monitors_create_http.rb, line 22
def generate_http_monitor_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateHttpMonitor do
    xml.Interval data[:interval]
    xml.ResponseTimeout data[:response_timeout]
    xml.Retries data[:retries]
    xml.Downtime data[:downtime]
    xml.Enabled data[:enabled]
    xml.RequestUri data[:request_uri]
    if data[:http_headers]
      xml.HttpHeaders data[:http_headers]
    end
    xml.ResponseCodes do
      data[:response_codes].each do |c|
        xml.ResponseCode c
      end
    end
  end
end
generate_internet_service_request(service_data) click to toggle source
# File lib/fog/compute/ecloud/requests/internet_service_create.rb, line 37
def generate_internet_service_request(service_data)
  xml = Builder::XmlMarkup.new
  xml.CreateInternetService(:name => service_data[:name]) do
    xml.Protocol service_data[:protocol]
    xml.Port service_data[:port]
    xml.Enabled service_data[:enabled]
    xml.Description service_data[:description]
    xml.Persistence do
      xml.Type service_data[:persistence][:type]
      if service_data[:persistence][:timeout]
        xml.Timeout service_data[:persistence][:timeout]
      end
    end
    if service_data[:redirect_url]
      xml.RedirectUrl service_data[:redirect_url]
    end
    if service_data[:trusted_network_group]
      xml.TrustedNetworkGroup(:href => service_data[:trusted_network_group][:href], :name => service_data[:trusted_network_group][:name], :type => "application/vnd.tmrk.cloud.trustedNetworkGroup")
    end
    if service_data[:backup_internet_service]
      xml.BackupInternetService(:href => service_data[:backup_internet_service][:href], :name => service_data[:backup_internet_service][:name], :type => "application/vnd.tmrk.cloud.backupInternetService")
    end
    if service_data[:load_balancing_method]
      xml.LoadBalancingMethod service_data[:load_balancing_method]
    end
  end
end
generate_node_service_request(service_data) click to toggle source
# File lib/fog/compute/ecloud/requests/node_service_create.rb, line 31
def generate_node_service_request(service_data)
  xml = Builder::XmlMarkup.new
  xml.CreateNodeService(:name => service_data[:name]) do
    xml.IpAddress(:href => service_data[:ip_address], :name => service_data[:ip_address].scan(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/)[0])
    xml.Port service_data[:port]
    xml.Enabled service_data[:enabled]
    if service_data[:description]
      xml.Description service_data[:description]
    end
  end
end
generate_ping_monitor_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/monitors_create_ping.rb, line 22
def generate_ping_monitor_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreatePingMonitor do
    xml.Interval data[:interval]
    xml.ResponseTimeout data[:response_timeout]
    xml.Retries data[:retries]
    xml.Downtime data[:downtime]
    xml.Enabled data[:enabled]
  end
end
generate_rnat_associations_create_device_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/rnat_associations_create_device.rb, line 22
def generate_rnat_associations_create_device_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateRnatAssociation do
    xml.PublicIp(:href => data[:public_ip_href])
    xml.IpAddress(:href => data[:host_ip_href])
  end
end
generate_rnat_associations_edit_network_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/rnat_associations_edit_network.rb, line 22
def generate_rnat_associations_edit_network_request(data)
  xml = Builder::XmlMarkup.new
  xml.NetworkRnat do
    xml.Rnat(:href => data[:href])
  end
end
generate_rows_create_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/rows_create.rb, line 22
def generate_rows_create_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateLayoutRow(:name => data[:name])
end
generate_rows_edit_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/rows_edit.rb, line 22
def generate_rows_edit_request(data)
  xml = Builder::XmlMarkup.new
  xml.LayoutRow(:name => data[:name])
end
generate_ssh_key_create_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/ssh_key_create.rb, line 22
def generate_ssh_key_create_request(data)
  xml = Builder::XmlMarkup.new
  xml.CreateSshKey(:name => data[:Name]) do
    xml.Default data[:Default]
  end
end
generate_ssh_key_edit_request(data) click to toggle source
# File lib/fog/compute/ecloud/requests/ssh_key_edit.rb, line 20
def generate_ssh_key_edit_request(data)
  xml = Builder::XmlMarkup.new
  xml.SshKey(:name => data[:Name]) do
    xml.Default data[:Default]
  end
end
set_extra_headers_for(params) click to toggle source

if Authorization and x-tmrk-authorization are used, the x-tmrk-authorization takes precendence.

# File lib/fog/compute/ecloud.rb, line 367
def set_extra_headers_for(params)
  length_required = ["PUT", "POST", "DELETE"]
  params[:headers] = {
    "x-tmrk-version" => @version,
    "Date"           => Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT"),
  }.merge(params[:headers] || {})
  if length_required.include?(params[:method]) && !params[:headers]["Content-Length"]
    body_size = 0
    if params[:body]
      body_size = params[:body].size
    end
    params[:headers].merge!("Content-Length" => body_size)
  end
  if params[:method] == "POST" || params[:method] == "PUT"
    params[:headers].merge!("Content-Type" => "application/xml") unless params[:headers]["Content-Type"]
    params[:headers].merge!("Accept" => "application/xml")
  end
  unless params[:body].nil? || params[:body].empty?
    params[:headers].merge!("x-tmrk-contenthash" => "Sha256 #{Base64.encode64(Digest::SHA2.digest(params[:body].to_s)).chomp}")
  end
  if @authentication_method == :basic_auth
    params[:headers].merge!("Authorization" => "Basic #{Base64.encode64(@username + ":" + @password).delete("\r\n")}")
  elsif @authentication_method == :cloud_api_auth
    signature = cloud_api_signature(params)
    params[:headers].merge!(
      "x-tmrk-authorization" => %Q{CloudApi AccessKey="#{@access_key}" SignatureType="HmacSha256" Signature="#{signature}"},
      "Authorization" => %Q{CloudApi AccessKey="#{@access_key}" SignatureType="HmacSha256" Signature="#{signature}"}
    )
  end
  params[:headers]
end