# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 591 def address(credentials, opts={}) addresses(credentials, :id => opts[:id]).first end
# 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
# 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
# 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
# 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
# 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
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
# 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
# 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
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 704 def configured_providers Deltacloud::Drivers::driver_config[:ec2][:entrypoints]["ec2"].keys end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 300 def load_balancer(credentials, opts={}) load_balancers(credentials, { :names => [opts[:id]] }).first end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/deltacloud/drivers/ec2/ec2_driver.rb, line 35 def supported_collections DEFAULT_COLLECTIONS + [ :keys, :buckets, :load_balancers, :addresses, :firewalls ] end
# 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
Generated with the Darkfish Rdoc Generator 2.