Class/Module Index [+]

Quicksearch

Deltacloud::Drivers::EC2::EC2Driver

Constants

DEFAULT_REGION

Public Instance Methods

address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 591
def address(credentials, opts={})
  addresses(credentials, :id => opts[:id]).first
end
addresses(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 576
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 =~ /InvalidAddress\.NotFound:/
      raise e
    end
  end
end
associate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 609
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 536
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={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 467
def blob_data(credentials, bucket_id, blob_id, opts={})
  s3_client = new_client(credentials, :s3)
  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 449
def blob_metadata(credentials, opts={})
  s3_client = new_client(credentials, :s3)
  blob_meta = {}
  safely do
    the_blob = s3_client.bucket(opts['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 477
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 392
def blobs(credentials, opts = {})
  s3_client = new_client(credentials, :s3)
  blobs = []
  safely do
    s3_bucket = s3_client.bucket(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 353
def buckets(credentials, opts={})
  buckets = []
  safely do
    s3_client = new_client(credentials, :s3)
    unless (opts[:id].nil?)
      bucket = s3_client.bucket(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
configured_providers() click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 704
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 595
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 412
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(/^x-amz-meta-/)}
            }
          )
end
create_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 370
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 654
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 675
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 163
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 212
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
  instance_options[:key_name] = opts[:keyname] if opts[:keyname]
  instance_options[:availability_zone] = opts[:realm_id] if opts[:realm_id]
  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 =~ /firewalls\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_instance = convert_instance(ec2.launch_instances(image_id, instance_options).first)
    new_instance
  end
end
create_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 283
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 318
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, opts['name'])
  end
end
create_storage_snapshot(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 560
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 515
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 442
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 385
def delete_bucket(credentials, name, opts={})
  s3_client = new_client(credentials, :s3)
  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 666
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 689
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 602
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 172
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 262
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 290
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 330
def destroy_load_balancer(credentials, id)
  ec2 = new_client( credentials, :elb )
  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 567
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 526
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, opts[:id])
  end
end
detach_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 543
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 620
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 634
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 131
def images(credentials, opts={})
  ec2 = new_client(credentials)
  img_arr = []
  opts ||= {}
  if opts[:id]
    safely do
      img_arr = ec2.describe_images([opts[:id]]).collect do |image|
        convert_image(image)
      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)
    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 181
def instance(credentials, opts={})
  ec2 = new_client(credentials)
  inst_arr = []
  safely do
    ec2_inst = ec2.describe_instances([opts[:id]]).first
    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][%{<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 200
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 273
def keys(credentials, opts={})
  ec2 = new_client(credentials)
  opts ||= {}
  safely do
    ec2.describe_key_pairs(opts[:id] || nil).collect do |key|
      convert_key(key)
    end
  end
end
lb_register_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 337
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 345
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 300
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 306
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
providers(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 698
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']}#{settings.root_url}\;provider=#{r}" }) }
end
realms(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 153
def realms(credentials, opts={})
  ec2 = new_client(credentials)
  zone_id = opts ? opts[:id] : nil
  safely do
    return ec2.describe_availability_zones(zone_id).collect do |realm|
      convert_realm(realm)
    end
  end
end
reboot_instance(credentials, instance_id) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 253
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 239
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] = target.public_addresses
  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 550
def storage_snapshots(credentials, opts={})
  ec2 = new_client(credentials)
  snapshot_list = (opts and opts[:id]) ? opts[:id] : []
  safely do
    ec2.describe_snapshots(snapshot_list).collect do |snapshot|
      convert_snapshot(snapshot)
    end
  end
end
storage_volumes(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 505
def storage_volumes(credentials, opts={})
  ec2 = new_client( credentials )
  volume_list = (opts and opts[:id]) ? opts[:id] : nil
  safely do
    ec2.describe_volumes(volume_list).collect do |volume|
      convert_volume(volume)
    end
  end
end
supported_collections() click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 35
def supported_collections

  DEFAULT_COLLECTIONS + [ :keys, :buckets, :load_balancers, :addresses, :firewalls ]
end
update_blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 458
def update_blob_metadata(credentials, opts={})
  s3_client = new_client(credentials, :s3)
  meta_hash = BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
  safely do
    the_blob = s3_client.bucket(opts['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 708
def valid_credentials?(credentials)
  retval = true
  begin
    realms(credentials)
  rescue
    retval = false
  end
  retval
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.