CloudyScripts 1.4.15 → 1.5.16

data/Rakefile

@@ -12,7 +12,7 @@ require 'rake/testtask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'CloudyScripts'
-  s.version = '1.4.15'
+  s.version = '1.5.16' 
   s.has_rdoc = true
   s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
   s.summary = 'Scripts to facilitate programming for infrastructure clouds.'
@@ -28,6 +28,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.add_dependency("amazon-ec2")
   s.add_dependency("net-ssh")
+  s.add_dependency("net-scp")
 end
 
 Rake::GemPackageTask.new(spec) do |p|

data/lib/help/ec2_helper.rb

@@ -52,6 +52,28 @@ class Ec2Helper
     return false
   end
 
+  def get_attached_volumes(instance_id)
+    instances = @ec2_api.describe_instances(:instance_id => instance_id)
+    begin
+      if instances['reservationSet']['item'][0]['instancesSet']['item'].size == 0
+        raise Exception.new("instance #{instance_id} not found")
+      end
+      puts "instances = #{instances.inspect}"
+      puts "attachments: #{instances['reservationSet']['item'][0]['instancesSet']['item'][0]['blockDeviceMapping']['item'].inspect}"
+      attached = instances['reservationSet']['item'][0]['instancesSet']['item'][0]['blockDeviceMapping']['item'].collect() { |item|
+        #
+        puts "item = #{item['ebs'].inspect}"
+        item['ebs']
+      }
+      puts "going to return #{attached.size.to_s}"
+      return attached
+    rescue Exception => e
+      puts "exception: #{e.inspect}"
+      puts e.backtrace.join("\n")
+      raise Exception.new("error during retrieving attachments from instance #{instance_id} not found")
+    end
+  end
+
   def volume_prop(volume_id, prop)
     vols = @ec2_api.describe_volumes(:volume_id => volume_id)
     if vols['volumeSet']['item'].size == 0
@@ -90,7 +112,7 @@ class Ec2Helper
       if instances['reservationSet']['item'][0]['instancesSet']['item'].size == 0
         raise Exception.new("instance #{instance_id} not found")
       end
-      return instances['reservationSet']['item'][0]['instancesSet']['item'][prop.to_s]
+      return instances['reservationSet']['item'][0]['instancesSet']['item'][0][prop.to_s]
     rescue
       raise Exception.new("instance #{instance_id} not found")
     end

data/lib/help/remote_command_handler.rb

@@ -14,8 +14,8 @@ class RemoteCommandHandler
   # Params:
   # * ip: ip address of the machine to connect to
   # * keyfile: path of the keyfile to be used for authentication
-  def connect_with_keyfile(ip, keyfile, timeout = 30)
-    @ssh_session = Net::SSH.start(ip, 'root', {:keys => [keyfile], :timeout => timeout})
+  def connect_with_keyfile(ip, user_name, keyfile, timeout = 30)
+    @ssh_session = Net::SSH.start(ip, user_name, {:keys => [keyfile], :timeout => timeout})
   end
 
   # Connect to the machine as root using keydata from a keyfile.

data/lib/help/state_transition_helper.rb

@@ -1,4 +1,5 @@
 require 'net/scp'
+require "AWS"
 
 # Contains methods that are used by the scripts in the state-machines. Since
 # they are reused by different scripts, they are factored into this module.
@@ -10,16 +11,33 @@ require 'net/scp'
 # * :remote_command_handler => ssh wrapper object
 # * :ec2_api_handler => wrapper object around EC2 API access
 
+class AWS::EC2::Base
+  def register_image_updated(options)
+    puts "register_iamge_updated: #{options.inspect}"
+    params = {}
+    params["Name"] = options[:name].to_s
+    params["BlockDeviceMapping.1.Ebs.SnapshotId"] = options[:snapshot_id].to_s
+    params["BlockDeviceMapping.1.DeviceName"] = options[:root_device_name].to_s
+    params["Description"] = options[:description].to_s
+    params["KernelId"] = options[:kernel_id].to_s unless options[:kernel_id] == nil
+    params["RamdiskId"] = options[:ramdisk_id].to_s unless options[:ramdisk_id] == nil
+    params["Architecture"] = options[:architecture].to_s
+    params["RootDeviceName"] = options[:root_device_name].to_s
+    return response_generator(:action => "RegisterImage", :params => params)
+  end
+end
+
 module StateTransitionHelper
 
   # Connects to the remote host via SSH.
   # Params:
   # * dns_name => machine to connect to
+  # * user_name => name to be used for connection
   # * ssh_keyfile => key-file used for ssh
   # * ssh_keydata => contents of key-file (either use ssh_keyfile or ssh_keydata)
   # Returns:
   # * OS of the connected machine
-  def connect(dns_name, ssh_keyfile = nil, ssh_keydata = nil)
+  def connect(dns_name, user_name, ssh_keyfile = nil, ssh_keydata = nil)
     post_message("connecting to #{dns_name}...")
     connected = false
     last_connection_problem = ""
@@ -39,7 +57,7 @@ module StateTransitionHelper
       elsif ssh_keydata != nil
         begin
           @logger.info("connecting using keydata")
-          remote_handler().connect(dns_name, "root", ssh_keydata)
+          remote_handler().connect(dns_name, user_name, ssh_keydata)
           connected = true
         rescue Exception => e
           @logger.info("connection failed due to #{e}")
@@ -290,6 +308,15 @@ module StateTransitionHelper
     return snapshot_id
   end
 
+  # Deletes a snapshot.
+  def delete_snapshot(snapshot_id)
+    post_message("going to delete snapshot #{snapshot_id}...")
+    @logger.info("going to delete snapshot #{snapshot_id}...")
+    ec2_handler().delete_snapshot(:snapshot_id => snapshot_id)
+    @logger.info("snapshot #{snapshot_id} deleted")
+    post_message("snapshot #{snapshot_id} deleted")
+  end
+
   # Registers a snapshot as EBS-booted AMI.
   # Input Parameters:
   # * snapshot_id => EC2 Snapshot ID used to be used

data/lib/scripts/ec2/ami2_ebs_conversion.rb

@@ -4,21 +4,6 @@ require "help/remote_command_handler"
 #require "help/dm_crypt_helper"
 require "AWS"
 
-class AWS::EC2::Base
-  def register_image_updated(options)
-    params = {}
-    params["Name"] = options[:name].to_s
-    params["BlockDeviceMapping.1.Ebs.SnapshotId"] = options[:snapshot_id].to_s
-    params["BlockDeviceMapping.1.DeviceName"] = options[:root_device_name].to_s
-    params["Description"] = options[:description].to_s
-    params["KernelId"] = options[:kernel_id].to_s
-    params["RamdiskId"] = options[:ramdisk_id].to_s
-    params["Architecture"] = options[:architecture].to_s
-    params["RootDeviceName"] = options[:root_device_name].to_s
-    return response_generator(:action => "RegisterImage", :params => params)
-  end
-end
-
 # Creates a bootable EBS storage from an existing AMI.
 #
 
@@ -28,6 +13,7 @@ class Ami2EbsConversion < Ec2Script
   # * aws_secret_key => the Amazon AWS Secret Key
   # * ami_id => the ID of the AMI to be converted
   # * security_group_name => name of the security group to start
+  # * ssh_username => name of the ssh-user (default = root)
   # * ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
   # * ssh_key_files => Key information for the security group that starts the AMI
   # * remote_command_handler => object that allows to connect via ssh and execute commands (optional)
@@ -55,6 +41,9 @@ class Ami2EbsConversion < Ec2Script
     if @input_params[:root_device_name] == nil
       @input_params[:root_device_name] = "/dev/sda1"
     end
+    if @input_params[:ssh_username] == nil
+      @input_params[:ssh_username] = "root"
+    end
   end
 
   def load_initial_state()
@@ -103,7 +92,7 @@ class Ami2EbsConversion < Ec2Script
   class StorageAttached < Ami2EbsConversionState
     def enter
       @context[:result][:os] =
-        connect(@context[:dns_name], @context[:ssh_keyfile], @context[:ssh_keydata])
+        connect(@context[:dns_name], @context[:ssh_username], @context[:ssh_keyfile], @context[:ssh_keydata])
       create_fs(@context[:dns_name], @context[:temp_device_name])
       FileSystemCreated.new(@context)
     end

data/lib/scripts/ec2/copy_ami.rb

@@ -0,0 +1,222 @@
+require "help/script_execution_state"
+require "scripts/ec2/ec2_script"
+require "help/remote_command_handler"
+require "help/dm_crypt_helper"
+require "help/ec2_helper"
+require "AWS"
+
+# Copy a given snapshot to another region
+# * start up instance in source-region, create a snapshot from the mounted EBS
+# * then create volume from snapshot, attach volume, and mount it
+# * start up instance in destination-region, create empty volume of same size, attache volume, and mount it
+# * copy the destination key to the source instance
+# * perform an rsynch
+#   sync -PHAXaz --rsh "ssh -i /home/${src_user}/.ssh/id_${dst_keypair}" --rsync-path "sudo rsync" ${src_dir}/ ${dst_user}@${dst_public_fqdn}:${dst_dir}/
+# * create a snapshot of the volume
+# * register the snapshot as AMI
+# * clean-up everything
+
+class CopyAmi < Ec2Script
+  # context information needed
+  # * the EC2 credentials (see #Ec2Script)
+  # * ami_id => the ID of the AMI to be copied in another region
+  # * target_ec2_handler => The EC2 handler connected to the region where the snapshot is being copied to
+  # * source_ssh_username => The username for ssh for source-instance (default = root)
+  # * source_key_name => Key name of the instance that manages the snaphot-volume in the source region
+  # * source_ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
+  # * source_ssh_key_files => Key information for the security group that starts the AMI
+  # * target_ssh_username => The username for ssh for target-instance (default = root)
+  # * target_key_name => Key name of the instance that manages the snaphot-volume in the target region
+  # * target_ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
+  # * target_ssh_key_files => Key information for the security group that starts the AMI
+  # * target_ami_id => ID of the AMI to start in the target region
+  # * name => name of new AMI to be created
+  # * description => description of new AMI to be created
+  
+  def initialize(input_params)
+    super(input_params)
+  end
+
+  def check_input_parameters()
+    ec2_helper = Ec2Helper.new(@input_params[:ec2_api_handler])
+    if ec2_helper.ami_prop(@input_params[:ami_id], 'rootDeviceType') != "ebs"
+      raise Exception.new("must be an EBS type image")
+    end
+    if @input_params[:root_device_name] == nil
+      @input_params[:root_device_name] = "/dev/sda1"
+    end
+    if @input_params[:temp_device_name] == nil
+      @input_params[:temp_device_name] = "/dev/sdj"
+    end
+    if @input_params[:source_ssh_username] == nil
+      @input_params[:source_ssh_username] = "root"
+    end
+    if @input_params[:target_ssh_username] == nil
+      @input_params[:target_ssh_username] = "root"
+    end
+
+  end
+
+  # Load the initial state for the script.
+  # Abstract method to be implemented by extending classes.
+  def load_initial_state()
+    CopyAmiState.load_state(@input_params)
+  end
+
+  private
+
+  # Here begins the state machine implementation
+  class CopyAmiState < ScriptExecutionState
+
+    def self.load_state(context)
+      InitialState.new(context)
+    end
+
+    def local_region
+      self.ec2_handler=(@context[:ec2_api_handler])
+    end
+
+    def remote_region
+      self.ec2_handler=(@context[:target_ec2_handler])
+    end
+  end
+
+  # Initial state: start up AMI in source region
+  class InitialState < CopyAmiState
+    def enter()
+      @context[:source_instance_id], @context[:source_dns_name], @context[:source_availability_zone], 
+        @context[:kernel_id], @context[:ramdisk_id], @context[:architecture] =
+        launch_instance(@context[:ami_id], @context[:source_key_name], "default")
+      ec2_helper = Ec2Helper.new(@context[:ec2_api_handler])
+      puts "get_attached returns: #{ec2_helper.get_attached_volumes(@context[:source_instance_id]).inspect}"
+      @context[:ebs_volume_id] = ec2_helper.get_attached_volumes(@context[:source_instance_id])[0]['volumeId']#TODO: what when more root devices?
+      SourceInstanceLaunchedState.new(@context)
+    end
+  end
+
+ # Source is started. Create a snapshot on the volume that is linked to the instance.
+  class SourceInstanceLaunchedState < CopyAmiState
+    def enter()
+      @context[:snapshot_id] = create_snapshot(@context[:ebs_volume_id], "Cloudy_Scripts Snapshot for copying AMIs")
+      AmiSnapshotCreatedState.new(@context)
+    end
+  end
+
+  # Snapshot is created from the AMI. Create a volume from the snapshot, attach and mount the volume as second device.
+  class AmiSnapshotCreatedState < CopyAmiState
+    def enter()
+      @context[:source_volume_id] = create_volume_from_snapshot(@context[:snapshot_id],
+        @context[:source_availability_zone])
+      device = @context[:temp_device_name]
+      mount_point = "/mnt/tmp_#{@context[:source_volume_id]}"
+      attach_volume(@context[:source_volume_id], @context[:source_instance_id], device)
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      mount_fs(mount_point, device)
+      disconnect()
+      SourceVolumeReadyState.new(@context)
+    end
+  end
+
+  # Source is ready. Now start instance in the target region
+  class SourceVolumeReadyState < CopyAmiState
+    def enter()
+      remote_region()
+      result = launch_instance(@context[:target_ami_id], @context[:target_key_name], 
+        "default")
+      @context[:target_instance_id] = result.first
+      @context[:target_dns_name] = result[1]
+      @context[:target_availability_zone] = result[2]
+      TargetInstanceLaunchedState.new(@context)
+    end
+  end
+
+  # Destination instance is started. Now configure storage.
+  class TargetInstanceLaunchedState < CopyAmiState
+    def enter()
+      local_region()
+      ec2_helper = Ec2Helper.new(@context[:ec2_api_handler])
+      volume_size = ec2_helper.snapshot_prop(@context[:snapshot_id], :volumeSize).to_i
+      #
+      remote_region()
+      @context[:target_volume_id] = create_volume(@context[:target_availability_zone], volume_size)
+      device = @context[:temp_device_name]
+      mount_point = "/mnt/tmp_#{@context[:target_volume_id]}"
+      attach_volume(@context[:target_volume_id], @context[:target_instance_id], device)
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      create_fs(@context[:target_dns_name], device)
+      mount_fs(mount_point, device)
+      disconnect()
+      TargetVolumeReadyState.new(@context)
+    end
+  end
+
+  # Storages are ready. Only thing missing: the key of the target region
+  # must be available on the instance in the source region to be able to perform
+  # a remote copy.
+  class TargetVolumeReadyState < CopyAmiState
+    def enter()
+      post_message("upload key of target-instance to source-instance...")
+      upload_file(@context[:source_dns_name], "root", @context[:source_ssh_keydata],
+        @context[:target_ssh_keyfile], "/root/.ssh/#{@context[:target_key_name]}.pem")
+      post_message("credentials are in place to connect source and target.")
+      KeyInPlaceState.new(@context)
+    end
+  end
+
+  # Now we can copy.
+  class KeyInPlaceState < CopyAmiState
+    def enter()
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      source_dir = "/mnt/tmp_#{@context[:source_volume_id]}/"
+      dest_dir = "/mnt/tmp_#{@context[:target_volume_id]}"
+      remote_copy(@context[:target_key_name], source_dir, @context[:target_dns_name], dest_dir)
+      disconnect()
+      DataCopiedState.new(@context)
+    end
+  end
+
+  # Data of snapshot now copied to the new volume. Create a snapshot of the
+  # new volume.
+  class DataCopiedState < CopyAmiState
+    def enter()
+      remote_region()
+      @context[:new_snapshot_id] = create_snapshot(@context[:target_volume_id], "Created by Cloudy_Scripts - copy_snapshot")
+      TargetSnapshotCreatedState.new(@context)
+    end
+  end
+
+  # Snapshot Operation done. Now this snapshot must be registered as AMI
+  class TargetSnapshotCreatedState < CopyAmiState
+    def enter()
+      remote_region()
+      @context[:result][:image_id] = register_snapshot(@context[:new_snapshot_id], @context[:name],
+        @context[:root_device_name], @context[:description], nil,
+        nil, @context[:architecture])
+      AmiRegisteredState.new(@context)
+    end
+  end
+
+  # AMI is registered. Now only cleanup is missing, i.e. shut down instances and
+  # remote the volumes that were created. Start with cleaning the ressources
+  # in the local region.
+  class AmiRegisteredState < CopyAmiState
+    def enter()
+      local_region()
+      shut_down_instance(@context[:source_instance_id])
+      delete_volume(@context[:source_volume_id])
+      delete_snapshot(@context[:snapshot_id])
+      SourceCleanedUpState.new(@context)
+    end
+  end
+
+  # Cleanup the resources in the target region.
+  class SourceCleanedUpState < CopyAmiState
+    def enter()
+      remote_region()
+      shut_down_instance(@context[:target_instance_id])
+      delete_volume(@context[:target_volume_id])
+      Done.new(@context)
+    end
+  end
+
+end

data/lib/scripts/ec2/copy_snapshot.rb

@@ -19,12 +19,14 @@ class CopySnapshot< Ec2Script
   # * the EC2 credentials (see #Ec2Script)
   # * snapshot_id => The ID of the snapshot to be downloaded
   # * target_ec2_handler => The EC2 handler connected to the region where the snapshot is being copied to
+  # * source_ssh_username => user name to connect to the source instance (default = root)
   # * source_key_name => Key name of the instance that manages the snaphot-volume in the source region
   # * source_ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
-  # * source_ssh_key_files => Key information for the security group that starts the AMI
+  # * source_ssh_key_file => Key information for the security group that starts the AMI
+  # * target_ssh_username => user name to connect to the target instance (default = root)
   # * target_key_name => Key name of the instance that manages the snaphot-volume in the target region
   # * target_ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
-  # * target_ssh_key_files => Key information for the security group that starts the AMI
+  # * target_ssh_key_file => Key information for the security group that starts the AMI
   # * source_ami_id => ID of the AMI to start in the source region
   # * target_ami_id => ID of the AMI to start in the target region
   
@@ -33,6 +35,12 @@ class CopySnapshot< Ec2Script
   end
 
   def check_input_parameters()
+    if @input_params[:source_ssh_username] == nil
+      @input_params[:source_ssh_username] = "root"
+    end
+    if @input_params[:target_ssh_username] == nil
+      @input_params[:target_ssh_username] = "root"
+    end
   end
 
   # Load the initial state for the script.
@@ -78,7 +86,7 @@ class CopySnapshot< Ec2Script
       device = "/dev/sdj"  #TODO: make device configurable
       mount_point = "/mnt/tmp_#{@context[:source_volume_id]}"
       attach_volume(@context[:source_volume_id], @context[:source_instance_id], device)
-      connect(@context[:source_dns_name], nil, @context[:source_ssh_keydata])
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
       mount_fs(mount_point, device)
       disconnect()
       SourceVolumeReadyState.new(@context)
@@ -110,7 +118,7 @@ class CopySnapshot< Ec2Script
       device = "/dev/sdj"  #TODO: make device configurable
       mount_point = "/mnt/tmp_#{@context[:target_volume_id]}"
       attach_volume(@context[:target_volume_id], @context[:target_instance_id], device)
-      connect(@context[:target_dns_name], nil, @context[:target_ssh_keydata])
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
       create_fs(@context[:target_dns_name], device)
       mount_fs(mount_point, device)
       disconnect()
@@ -134,7 +142,7 @@ class CopySnapshot< Ec2Script
   # Now we can copy.
   class KeyInPlaceState < CopySnapshotState
     def enter()
-      connect(@context[:source_dns_name], nil, @context[:source_ssh_keydata])
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
       source_dir = "/mnt/tmp_#{@context[:source_volume_id]}/"
       dest_dir = "/mnt/tmp_#{@context[:target_volume_id]}"
       remote_copy(@context[:target_key_name], source_dir, @context[:target_dns_name], dest_dir)

data/lib/scripts/ec2/dm_encrypt.rb

@@ -16,6 +16,7 @@ class DmEncrypt < Ec2Script
   # * aws_access_key => the Amazon AWS Access Key (see Your Account -> Security Credentials)
   # * aws_secret_key => the Amazon AWS Secret Key
   # * ip_address => IP Address of the machine to connect to
+  # * ssh_username => name of the ssh-user (default = root)
   # * ssh_key_file => Path of the keyfile used to connect to the machine (optional, otherwise: ssh_key_data)
   # * ssh_key_data => Key information (optional, otherwise: ssh_key_file)
   # * device => Path of the device to encrypt
@@ -42,6 +43,9 @@ class DmEncrypt < Ec2Script
       @input_params[:ec2_api_handler] = AWS::EC2::Base.new(:access_key_id => @input_params[:aws_access_key],
       :secret_access_key => @input_params[:aws_secret_key], :server => @input_params[:ec2_api_server])
     end
+    if @input_params[:ssh_username] == nil
+      @input_params[:ssh_username] = "root"
+    end
   end
 
   def load_initial_state()
@@ -62,7 +66,7 @@ class DmEncrypt < Ec2Script
   class InitialState < DmEncryptState
     def enter
       @context[:result][:os] =
-        connect(@context[:dns_name], @context[:ssh_keyfile], @context[:ssh_keydata])
+        connect(@context[:dns_name], @context[:ssh_username], @context[:ssh_keyfile], @context[:ssh_keydata])
       install_tools()
     end
 

data/lib/scripts/ec2/download_snapshot.rb

@@ -22,6 +22,7 @@ class DownloadSnapshot < Ec2Script
   # * ami_id: the ID of the AMI to be started to perform the operations and to run the web-server for download
   # * security_group_name => name of the security group used to start the AMI (should open ports for SSH and HTTP)
   # * key_name => Name of the key to be used to access the instance providing the download
+  # * ssh_username => name of the ssh-user (default = root)
   # * ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
   # * ssh_key_files => Key information for the security group that starts the AMI
   # * snapshot_id => The ID of the snapshot to be downloaded
@@ -48,6 +49,9 @@ class DownloadSnapshot < Ec2Script
     if @input_params[:wait_time] == nil
       @input_params[:wait_time] = 300
     end
+    if @input_params[:ssh_username] == nil
+      @input_params[:ssh_username] = "root"
+    end
   end
 
   # Load the initial state for the script.
@@ -105,7 +109,7 @@ class DownloadSnapshot < Ec2Script
     def enter
       @context[:script].post_message("Going to prepare the two volumes for the zip-operation.")
       @context[:result][:os] =
-        connect(@context[:dns_name], @context[:ssh_keyfile], @context[:ssh_keydata])
+        connect(@context[:dns_name], @context[:ssh_username], @context[:ssh_keyfile], @context[:ssh_keydata])
       source_dir = "/mnt/tmp_#{@context[:source_volume_id]}"
       dest_dir = @context[:zip_file_dest]
       create_fs(@context[:dns_name], @context[:dest_device])

data/lib/scripts/ec2/ec2_script.rb

@@ -14,6 +14,8 @@ class Ec2Script
       @logger = Logger.new(STDOUT)
       @logger .level = Logger::WARN
       input_params[:logger] = @logger
+    else
+      @logger = input_params[:logger]
     end
     @result = {:done => false, :failed => false}
     @input_params[:result] = @result

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 4
-  - 15
-  version: 1.4.15
+  - 5
+  - 16
+  version: 1.5.16
 platform: ruby
 authors: 
 - Matthias Jung
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-27 00:00:00 +02:00
+date: 2010-05-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,6 +41,18 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: net-scp
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
 description: Scripts to facilitate programming for infrastructure clouds.
 email: matthias.jung@gmail.com
 executables: []
@@ -63,6 +75,7 @@ files:
 - lib/help/state_change_listener.rb
 - lib/help/state_transition_helper.rb
 - lib/scripts/ec2/ami2_ebs_conversion.rb
+- lib/scripts/ec2/copy_ami.rb
 - lib/scripts/ec2/copy_snapshot.rb
 - lib/scripts/ec2/dm_encrypt.rb
 - lib/scripts/ec2/download_snapshot.rb