class Deltacloud::Drivers::Ec2::Ec2Driver

Monkey patch EC2 driver to return a client

Constants

DEFAULT_REGION

Public Instance Methods

addresses(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 685
def addresses(credentials, opts={})
  ec2 = new_client(credentials)
  address_id = (opts and opts[:id]) ? [opts[:id]] : []
  safely do
    begin
      ec2.describe_addresses(address_id).collect do |address|
        Address.new(:id => address[:public_ip], :instance_id => address[:instance_id])
      end
    rescue Exception => e
      return [] if e.message =~ %rInvalidAddress\.NotFound:/
      raise e
    end
  end
end
associate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 714
def associate_address(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    if ec2.associate_address(opts[:instance_id], opts[:id])
      Address.new(:id => opts[:id], :instance_id => opts[:instance_id])
    else
      raise "ERROR: Cannot associate IP address to an Instance"
    end
  end
end
attach_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 637
def attach_storage_volume(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    convert_volume(ec2.attach_volume(opts[:id], opts[:instance_id], opts[:device]))
  end
end
blob_data(credentials, bucket_id, blob_id, opts={}) { |chunk| ... } click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 567
def blob_data(credentials, bucket_id, blob_id, opts={})
  s3_client = new_client(credentials, :s3)
  s3_client = get_bucket_with_endpoint(s3_client, credentials, bucket_id)[1]
  safely do
    s3_client.interface.get(bucket_id, blob_id) do |chunk|
      yield chunk
    end
  end
end
blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 547
def blob_metadata(credentials, opts={})
  s3_client = new_client(credentials, :s3)
  blob_meta = {}
  safely do
    the_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts['bucket'])
    the_blob = the_bucket.key(opts[:id], true)
    blob_meta = the_blob.meta_headers
  end
end
blob_stream_connection(params) click to toggle source

params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata}

# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 578
def blob_stream_connection(params)
  #canonicalise metadata:
  #http://docs.amazonwebservices.com/AmazonS3/latest/dev/index.html?RESTAuthentication.html
  metadata = params[:metadata] || {}
  signature_meta_string = ""
  BlobHelper::rename_metadata_headers(metadata, 'x-amz-meta-')
  keys_array = metadata.keys.sort!
  keys_array.each {|k| signature_meta_string << "#{k}:#{metadata[k]}\n"}
  provider = "https://#{endpoint_for_service(:s3)}"
  uri = URI.parse(provider)
  http = Net::HTTP.new("#{params[:bucket]}.#{uri.host}", uri.port )
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
  timestamp = Time.now.httpdate
  string_to_sign =
    "PUT\n\n#{params[:content_type]}\n#{timestamp}\n#{signature_meta_string}/#{params[:bucket]}/#{params[:blob]}"
  auth_string = Aws::Utils::sign(params[:password], string_to_sign)
  request = Net::HTTP::Put.new("/#{params[:blob]}")
  request['Host'] = "#{params[:bucket]}.#{uri.host}"
  request['Date'] = timestamp
  request['Content-Type'] = params[:content_type]
  request['Content-Length'] = params[:content_length]
  request['Authorization'] = "AWS #{params[:user]}:#{auth_string}"
  request['Expect'] = "100-continue"
  metadata.each{|k,v| request[k] = v}
  return http, request
end
blobs(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 490
def blobs(credentials, opts = {})
  s3_client = new_client(credentials, :s3)
  blobs = []
  safely do
    s3_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts['bucket'])
    if(opts[:id])
      blobs << convert_object(s3_bucket.key(opts[:id], true))
    else
      s3_bucket.keys({}, true).each do |s3_object|
        blobs << convert_object(s3_object)
      end
    end
  end
  blobs = filter_on(blobs, :id, opts)
  blobs
end
buckets(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 450
def buckets(credentials, opts={})
  buckets = []
  safely do
    s3_client = new_client(credentials, :s3)
    unless (opts[:id].nil?)
      bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts[:id])
      buckets << convert_bucket(bucket)
    else
      bucket_list = s3_client.buckets
      bucket_list.each do |current|
        buckets << Bucket.new({:name => current.name, :id => current.name})
      end
    end
  end
  filter_on(buckets, :id, opts)
end
client(credentials) click to toggle source
# File tests/drivers/ec2/common.rb, line 15
def client(credentials)
  new_client(credentials)
end
configured_providers() click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 809
def configured_providers
  Deltacloud::Drivers::driver_config[:ec2][:entrypoints]["ec2"].keys
end
create_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 700
def create_address(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    Address.new(:id => ec2.allocate_address)
  end
end
create_blob(credentials, bucket_id, blob_id, data = nil, opts = {}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 510
def create_blob(credentials, bucket_id, blob_id, data = nil, opts = {})
  s3_client = new_client(credentials, :s3)
  #data is a construct with the temporary file created by server @.tempfile
  #also file[:type] will give us the content-type
  res = nil
  # File stream needs to be reopened in binary mode for whatever reason
  file = File::open(data[:tempfile].path, 'rb')
  #insert ec2-specific header for user metadata ... x-amz-meta-KEY = VALUE
  BlobHelper::rename_metadata_headers(opts, 'x-amz-meta-')
  opts["Content-Type"] = data[:type]
  safely do
    res = s3_client.interface.put(bucket_id,
                                blob_id,
                                file,
                                opts)
  end
  #create a new Blob object and return that
  Blob.new( { :id => blob_id,
              :bucket => bucket_id,
              :content_length => data[:tempfile].length,
              :content_type => data[:type],
              :last_modified => '',
              :user_metadata => opts.select{|k,v| k.match(%r^x-amz-meta-/)}
            }
          )
end
create_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 467
def create_bucket(credentials, name, opts={})
  bucket = nil
  safely do
    s3_client = new_client(credentials, :s3)
    bucket_location = opts['location']
    if (bucket_location && bucket_location.size >0 &&
                                       (not bucket_location.eql?(DEFAULT_REGION)) )
      bucket = Aws::S3::Bucket.create(s3_client, name, true, nil, :location => bucket_location)
    else
      bucket = Aws::S3::Bucket.create(s3_client, name, true)
    end
  end
  convert_bucket(bucket)
end
create_firewall(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 759
def create_firewall(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    ec2.create_security_group(opts["name"], opts["description"])
  end
  Firewall.new( { :id=>opts["name"], :name=>opts["name"],
                  :description => opts["description"], :owner_id => "", :rules => [] } )
end
create_firewall_rule(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 780
def create_firewall_rule(credentials, opts={})
  ec2 = new_client(credentials)
  groups = []
  opts['groups'].each do |k,v|
    groups << {"group_name" => k, "owner" =>v}
  end
  safely do
    ec2.manage_security_group_ingress(opts['id'], opts['port_from'], opts['port_to'], opts['protocol'],
      "authorize", opts['addresses'], groups)
  end
end
create_image(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 203
def create_image(credentials, opts={})
  ec2 = new_client(credentials)
  instance = instance(credentials, :id => opts[:id])
  safely do
    new_image_id = ec2.create_image(instance.id, opts[:name], opts[:description])
    image(credentials, :id => new_image_id)
  end
end
create_instance(credentials, image_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 257
def create_instance(credentials, image_id, opts={})
  ec2 = new_client(credentials)
  instance_options = {}
  if opts[:user_data]
    instance_options[:user_data] = Base64::decode64(opts[:user_data])
  end
  if opts[:metrics] and !opts[:metrics].empty?
    instance_options[:monitoring_enabled] = true
  end
  if opts[:realm_id]
    az, sn = opts[:realm_id].split(":")
    if sn
      instance_options[:subnet_id] = sn
    else
      instance_options[:availability_zone] = az
    end
  end
  instance_options[:key_name] = opts[:keyname] if opts[:keyname]
  instance_options[:instance_type] = opts[:hwp_id] if opts[:hwp_id] && opts[:hwp_id].length > 0
  firewalls = opts.inject([]){|res, (k,v)| res << v if k =~ %rfirewalls\d+$/; res}
  instance_options[:group_ids] = firewalls unless firewalls.empty?
  if opts[:instance_count] and opts[:instance_count].length != 0
    instance_options[:min_count] = opts[:instance_count]
    instance_options[:max_count] = opts[:instance_count]
  end
  if opts[:snapshot_id] and opts[:device_name]
    instance_options[:block_device_mappings] = [{
      :snapshot_id => opts[:snapshot_id],
      :device_name => opts[:device_name]
    }]
  end
  safely do
    new_instances = ec2.launch_instances(image_id, instance_options).collect do |i|
      convert_instance(i)
    end
    if new_instances.size == 1
      new_instances.first
    else
      new_instances
    end
  end
end
create_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 379
def create_key(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    convert_key(ec2.create_key_pair(opts[:key_name]))
  end
end
create_load_balancer(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 414
def create_load_balancer(credentials, opts={})
  ec2 = new_client( credentials, :elb )
  safely do
    ec2.create_load_balancer(opts['name'], [opts['realm_id']],
      [{:load_balancer_port => opts['listener_balancer_port'],
        :instance_port => opts['listener_instance_port'],
        :protocol => opts['listener_protocol']}]
    )
    return load_balancer(credentials, :id => opts['name'])
  end
end
create_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 669
def create_storage_snapshot(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    convert_snapshot(ec2.try_create_snapshot(opts[:volume_id]))
  end
end
create_storage_volume(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 616
def create_storage_volume(credentials, opts=nil)
  ec2 = new_client(credentials)
  opts ||= {}
  opts[:snapshot_id] ||= ""
  opts[:capacity] ||= "1"
  opts[:realm_id] ||= realms(credentials).first.id
  safely do
    convert_volume(ec2.create_volume(opts[:snapshot_id], opts[:capacity], opts[:realm_id]))
  end
end
delete_blob(credentials, bucket_id, blob_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 540
def delete_blob(credentials, bucket_id, blob_id, opts={})
  s3_client = new_client(credentials, :s3)
  safely do
    s3_client.interface.delete(bucket_id, blob_id)
  end
end
delete_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 482
def delete_bucket(credentials, name, opts={})
  s3_client = new_client(credentials, :s3)
  s3_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, name)
  safely do
    s3_client.interface.delete_bucket(name)
  end
end
delete_firewall(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 771
def delete_firewall(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    ec2.delete_security_group(opts["id"])
  end
end
delete_firewall_rule(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 794
def delete_firewall_rule(credentials, opts={})
  ec2 = new_client(credentials)
  firewall = opts[:firewall]
  protocol, from_port, to_port, addresses, groups = firewall_rule_params(opts[:rule_id])
  safely do
    ec2.manage_security_group_ingress(firewall, from_port, to_port, protocol, "revoke", addresses, groups)
  end
end
destroy_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 707
def destroy_address(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    ec2.release_address(opts[:id])
  end
end
destroy_image(credentials, image_id) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 212
def destroy_image(credentials, image_id)
  ec2 = new_client(credentials)
  safely do
    unless ec2.deregister_image(image_id)
      raise "ERROR: Unable to deregister AMI"
    end
  end
end
destroy_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 323
def destroy_instance(credentials, instance_id)
  ec2 = new_client(credentials)
  if ec2.terminate_instances([instance_id])
    instance(credentials, :id => instance_id)
  else
    raise Deltacloud::BackendError.new(500, "Instance", "Instance cannot be terminated", "")
  end
end
Also aliased as: stop_instance
destroy_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 386
def destroy_key(credentials, opts={})
  ec2 = new_client(credentials)
  original_key = key(credentials, opts)
  safely do
    ec2.delete_key_pair(original_key.id)
    original_key= original_key.state = "DELETED"
  end
  original_key
end
destroy_load_balancer(credentials, id) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 426
def destroy_load_balancer(credentials, id)
  ec2 = new_client( credentials, :elb )
  return 'InvalidLoadBalancer' if load_balancer(credentials, :id => id).nil?
  safely do
    ec2.delete_load_balancer(id)
  end
end
destroy_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 676
def destroy_storage_snapshot(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    unless ec2.delete_snapshot(opts[:id])
      raise Deltacloud::BackendError.new(500, "StorageSnapshot", "Cannot destroy this snapshot")
    end
  end
end
destroy_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 627
def destroy_storage_volume(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    unless ec2.delete_volume(opts[:id])
      raise Deltacloud::BackendError.new(500, "StorageVolume", "Cannot delete storage volume")
    end
    storage_volume(credentials, :id => opts[:id])
  end
end
detach_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 644
def detach_storage_volume(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    convert_volume(ec2.detach_volume(opts[:id], opts[:instance_id], opts[:device], true))
  end
end
disassociate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 725
def disassociate_address(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    if ec2.disassociate_address(opts[:id])
      Address.new(:id => opts[:id])
    else
      raise "ERROR: Cannot disassociate an IP address from the Instance"
    end
  end
end
firewalls(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 739
def firewalls(credentials, opts={})
  ec2 = new_client(credentials)
  the_firewalls = []
  groups = []
  safely do
    if opts[:id]
      groups = ec2.describe_security_groups([opts[:id]])
    else
      groups = ec2.describe_security_groups()
    end
  end
  groups.each do |security_group|
    the_firewalls << convert_security_group(security_group)
  end
  the_firewalls
end
images(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 140
def images(credentials, opts={})
  ec2 = new_client(credentials)
  img_arr = []
  opts ||= {}
  profiles = hardware_profiles(nil)
  if opts[:id]
    safely do
      begin
        img_arr = ec2.describe_images([opts[:id]]).collect do |image|
          convert_image(image, profiles)
        end
      rescue => e
        raise e unless e.message =~ %rInvalid id/ or e.message =~ %rdoes not exist/
        img_arr = []
      end
    end
    return img_arr
  end
  owner_id = opts[:owner_id] || default_image_owner
  safely do
    img_arr = ec2.describe_images_by_owner([owner_id], default_image_type).collect do |image|
      convert_image(image, profiles)
    end
  end
  img_arr = filter_on( img_arr, :architecture, opts )
  img_arr.sort_by { |e| [e.owner_id, e.name] }
end
instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 221
def instance(credentials, opts={})
  ec2 = new_client(credentials)
  safely do
    begin
      ec2_inst = ec2.describe_instances([opts[:id]]).first
    rescue => e
      raise e unless e.message =~ %rInvalid id/ or e.message =~ %rNotFound/
      ec2_inst = nil
    end
    return if ec2_inst.nil?
    instance = convert_instance(ec2_inst)
    return nil unless instance
    if ec2_inst[:aws_platform] == 'windows'
      console_output = ec2.get_console_output(instance.id)
      windows_password = console_output[:aws_output][%r{<Password>(.+)</Password>}] && $1
      if windows_password
        instance.username = 'Administrator'
        instance.password = windows_password
      end
    end
    instance
  end
end
instances(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 245
def instances(credentials, opts={})
  ec2 = new_client(credentials)
  inst_arr = []
  safely do
    inst_arr = ec2.describe_instances.collect do |instance|
      convert_instance(instance) if instance
    end.flatten
  end
  inst_arr = filter_on( inst_arr, :id, opts )
  filter_on( inst_arr, :state, opts )
end
keys(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 364
def keys(credentials, opts={})
  ec2 = new_client(credentials)
  opts ||= {}
  safely do
    begin
      ec2.describe_key_pairs(opts[:id] ? [opts[:id]] : nil).collect do |key|
        convert_key(key)
      end
    rescue => e
      raise e unless e.message =~ %rdoes not exist/
      []
    end
  end
end
lb_register_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 434
def lb_register_instance(credentials, opts={})
  ec2 = new_client( credentials, :elb)
  safely do
    ec2.register_instances_with_load_balancer(opts['id'], [opts['instance_id']])
    load_balancer(credentials, :id => opts[:id])
  end
end
lb_unregister_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 442
def lb_unregister_instance(credentials, opts={})
  ec2 = new_client( credentials, :elb)
  safely do
    ec2.deregister_instances_from_load_balancer(opts['id'], [opts['instance_id']])
    load_balancer(credentials, :id => opts['id'])
  end
end
load_balancer(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 396
def load_balancer(credentials, opts={})
  load_balancers(credentials, {
    :names => [opts[:id]]
  }).first
end
load_balancers(credentials, opts=nil) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 402
def load_balancers(credentials, opts=nil)
  ec2 = new_client( credentials, :elb )
  result = []
  safely do
    loadbalancers = ec2.describe_load_balancers(opts || {})
    loadbalancers.each do |loadbalancer|
      result << convert_load_balancer(credentials, loadbalancer)
    end
  end
  return result
end
metric(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 349
def metric(credentials, opts={})
  cw = new_client(credentials, :mon)
  m = metrics(credentials, :id => opts[:id])
  return [] if m.empty?
  m = m.first
  # Get statistics from last 1 hour
  start_time = (Time.now - 3600).utc.iso8601.to_s
  end_time = Time.now.utc.iso8601.to_s
  m.properties.each do |p|
    p.values = cw.get_metric_statistics(p.name,  ['Minimum', 'Maximum', 'Average'],
                start_time, end_time, metric_unit_for(p.name), { m.entity => opts[:id]})
  end
  m
end
metrics(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 334
def metrics(credentials, opts={})
  cw = new_client(credentials, :mon)
  metrics_arr = []
  cw.list_metrics( :namespace => 'AWS/EC2' ).each do |metric|
    if metrics_arr.any? { |m| m.id == metric[:value] }
      i = metrics_arr.index { |m| m.id == metric[:value] }
      metrics_arr[i] = metrics_arr[i].add_property(metric[:measure_name])
    else
      metrics_arr << convert_metric(metric)
    end
  end
  metrics_arr.reject! { |m| m.unknown? }
  filter_on(metrics_arr, :id, opts)
end
providers(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 803
def providers(credentials, opts={})
  ec2 = new_client(credentials)
  @providers ||= ec2.describe_regions.map{|r| Provider.new( {:id=>r, :name=>r,
   :url=>"#{ENV['API_HOST']}:#{ENV['API_PORT']}#{Deltacloud.default_frontend.root_url}\;provider=#{r}" }) }
end
realms(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 168
def realms(credentials, opts={})
  # We have two different kinds of realms:
  #  (1) Availability Zones
  #  (2) Subnets in VPC's (scoped to an AZ)
  # For the latter, the ID is AZ:SUBNET, and we can tell that we
  # are looking at such a realm by checking if the id contains a colon
  ec2 = new_client(credentials)
  realms = []
  safely do
    if opts[:id] and !opts[:id].empty?
      az, sn = opts[:id].split(":")
      begin
        if sn
          subnet = ec2.describe_subnets(sn).first
          realms << convert_realm(subnet) if subnet
        else
          ec2.describe_availability_zones([az]).collect do |realm|
            realms << convert_realm(realm) unless realm.empty?
          end
        end
      rescue => e
        raise e unless e.message =~ %rInvalid availability zone/
        realms = []
      end
    else
      realms = ec2.describe_availability_zones.collect do |realm|
        convert_realm(realm) unless realm.empty?
      end
      realms = realms +
        ec2.describe_subnets.map { |sn| convert_realm(sn) }
    end
  end
  realms
end
reboot_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 314
def reboot_instance(credentials, instance_id)
  ec2 = new_client(credentials)
  if ec2.reboot_instances([instance_id])
    instance(credentials, :id => instance_id)
  else
    raise Deltacloud::BackendError.new(500, "Instance", "Instance reboot failed", "")
  end
end
run_on_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 300
def run_on_instance(credentials, opts={})
  target = instance(credentials, :id => opts[:id])
  param = {}
  param[:credentials] = {
    :username => 'root', # Default for EC2 Linux instances
  }
  param[:port] = opts[:port] || '22'
  param[:ip] = opts[:ip] || target.public_addresses.first.address
  param[:private_key] = (opts[:private_key].length > 1) ? opts[:private_key] : nil
  safely do
    Deltacloud::Runner.execute(opts[:cmd], param)
  end
end
stop_instance(credentials, instance_id) click to toggle source
Alias for: destroy_instance
storage_snapshots(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 651
def storage_snapshots(credentials, opts={})
  ec2 = new_client(credentials)
  snapshot_list = opts[:id] ? [opts[:id]] : []
  safely do
    begin
    ec2.describe_snapshots(snapshot_list).collect do |snapshot|
      convert_snapshot(snapshot)
    end
    rescue => e
      if e.message =~ %rNotFound/
        []
      else
        raise e
      end
    end
  end
end
storage_volumes(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 606
def storage_volumes(credentials, opts={})
  ec2 = new_client( credentials )
  volume_list = (opts and opts[:id]) ? [opts[:id]] : []
  safely do
    ec2.describe_volumes(volume_list).collect do |volume|
      convert_volume(volume)
    end
  end
end
update_blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 557
def update_blob_metadata(credentials, opts={})
  s3_client = new_client(credentials, :s3)
  meta_hash = BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
  safely do
    the_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts['bucket'])
    the_blob = the_bucket.key(opts[:id])
    the_blob.save_meta(meta_hash)
  end
end
valid_credentials?(credentials) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 813
def valid_credentials?(credentials)
  begin
    realms(credentials) && true
  rescue => e
    if e.class.name =~ %rAuthFailure/
      false
    else
      safely { raise e }
    end
  end
end