CloudyScripts 2.11.48 → 2.12.49

data/Rakefile

@@ -12,7 +12,7 @@ require 'rake/testtask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'CloudyScripts'
-  s.version = '2.11.48'
+  s.version = '2.12.49' #<number cloud-stacks supported>.<number cloud-scripts>.<counting releases>
   s.has_rdoc = true
   s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
   s.summary = 'Scripts to facilitate programming for infrastructure clouds.'

data/lib/help/ec2_helper.rb

@@ -134,6 +134,22 @@ class Ec2Helper
     end
   end
 
+  # Get info from "imagesSet"=>"item"[0]=>"blockDeviceMapping"=>"item"[0]
+  def ami_blkdevmap_ebs_prop(ami_id, prop)
+    amis = @ec2_api.describe_images(:image_id => ami_id)
+    begin
+      if amis['imagesSet']['item'].size == 0
+        raise Exception.new("image #{ami_id} not found")
+      end
+      if amis['imagesSet']['item'][0]['blockDeviceMapping']['item'].size == 0
+        raise Exception.new("blockDeviceMapping not found for image #{ami_id}")
+      end
+      return amis['imagesSet']['item'][0]['blockDeviceMapping']['item'][0]['ebs'][prop.to_s]
+    rescue
+        raise Exception.new("image #{ami_id} not found")
+    end
+  end
+
   def instance_prop(instance_id, prop, instances = nil)
     if instances == nil
       instances = @ec2_api.describe_instances(:instance_id => instance_id)

data/lib/help/remote_command_handler.rb

@@ -246,6 +246,20 @@ class RemoteCommandHandler
     remote_exec_helper(e, nil, nil, false) #TODO: handle output in stderr?
   end
 
+  # dump and compress a device in a file locally
+  def local_dump_and_compress(source_device, target_filename)
+    e = "sh -c 'dd if=#{source_device} | gzip > #{target_filename}'"
+    @logger.debug "going to execute #{e}" 
+    status = remote_exec_helper(e, nil, nil, true)
+  end
+
+  # idecompress and a file to a device locally
+  def local_decompress_and_dump(source_filename, target_device)
+    e = "sh -c 'gunzip -c #{source_filename} | dd of=#{target_device}'"
+    @logger.debug "going to execute #{e}" 
+    status = remote_exec_helper(e, nil, nil, true)
+  end
+
   # Zip the complete contents of the source path into the destination file.
   # Returns the an array with stderr output messages.
   def zip(source_path, destination_file)

data/lib/help/state_transition_helper.rb

@@ -14,7 +14,7 @@ require "AWS"
 
 class AWS::EC2::Base
   def register_image_updated(options)
-    puts "register_iamge_updated: #{options.inspect}"
+    puts "register_image_updated: #{options.inspect}"
     params = {}
     params["Name"] = options[:name].to_s
     params["BlockDeviceMapping.1.Ebs.SnapshotId"] = options[:snapshot_id].to_s
@@ -797,6 +797,48 @@ module StateTransitionHelper
     post_message("remote copy operation done")
   end
 
+  # dump and compress a device using dd and gzip
+  def local_dump_and_compress_device_to_file(source_device, target_filename)
+    post_message("going to start dumping and compressing source device '#{source_device}' to '#{target_filename}' file. This may take quite a time...")
+    @logger.debug "start dumping and compressing '#{source_device}' to '#{target_filename}'"
+    start_time = Time.new.to_i
+    if remote_handler().tools_installed?("dd") && remote_handler().tools_installed?("gzip")
+      @logger.debug "use dd and gzip command line"
+      status = remote_handler().local_dump_and_compress(source_device, target_filename)
+      if status == false
+        @logger.error "failed to dump and compress device"
+        raise Exception.new("failed to dump and compress device")
+      end
+    else
+      @logger.error "dd and/or gzip tools not installed"
+      raise Exception.new("dd and/or gzip tools not installed")
+    end
+    end_time = Time.new.to_i
+    @logger.info "dump and compress took #{(end_time-start_time)}s"
+    post_message("dumping and compressing done (took #{end_time-start_time})s")
+  end
+
+  # decompress and dump a file using gunzip and dd
+  def local_decompress_and_dump_file_to_device(source_filename, target_device)
+    post_message("going to start decompressing and dumping file '#{source_filename}' to '#{target_device}' target device. This may take quite a time...")
+    @logger.debug "start decompressing and dumping '#{source_filename}' to '#{target_device}'"
+    start_time = Time.new.to_i
+    if remote_handler().tools_installed?("dd") && remote_handler().tools_installed?("gunzip")
+      @logger.debug "use dd and gzip command line"
+      status = remote_handler().local_decompress_and_dump(source_filename, target_device)
+      if status == false
+        @logger.error "failed to decompress and dump file"
+        raise Exception.new("failed to decompress and dump file")
+      end
+    else
+      @logger.error "dd and/or gunzip tools not installed"
+      raise Exception.new("dd and/or gunzip tools not installed")
+    end
+    end_time = Time.new.to_i
+    @logger.info "decompress and dump filetook #{(end_time-start_time)}s"
+    post_message("decompressing and dumping done (took #{end_time-start_time})s")
+  end
+
   def disable_ssh_tty(host)
     post_message("going to disable SSH tty on #{host}...")
     @logger.debug "disable SSH tty on #{host}"
@@ -908,6 +950,11 @@ module StateTransitionHelper
   #    aki-ea5df7eb ec2-public-images-ap-northeast-1/pv-grub-hd00_1.02-x86_64.gz.manifest.xml
   #    aki-ec5df7ed ec2-public-images-ap-northeast-1/pv-grub-hd0_1.02-i386.gz.manifest.xml
   #    aki-ee5df7ef ec2-public-images-ap-northeast-1/pv-grub-hd0_1.02-x86_64.gz.manifest.xml
+  # * SA-East-1
+  #    aki-cc3ce3d1 ec2-public-images-sa-east-1/pv-grub-hd0_1.02-x86_64.gz.manifest.xml
+  #    aki-bc3ce3a1 ec2-public-images-sa-east-1/pv-grub-hd0_1.02-i386.gz.manifest.xml
+  #    aki-d23ce3cf ec2-public-images-sa-east-1/pv-grub-hd00_1.02-x86_64.gz.manifest.xml
+  #    aki-823ce39f ec2-public-images-sa-east-1/pv-grub-hd00_1.02-i386.gz.manifest.xml
   def get_aws_kernel_image_aki(source_endpoint, source_aki, target_endpoint)
     map = { 'us-east-1' => {'aki-4c7d9525' => 'pv-grub-hd00-V1.01-i386',
                             'aki-4e7d9527' => 'pv-grub-hd00-V1.01-x86_64',
@@ -980,6 +1027,18 @@ module StateTransitionHelper
                                  #RHEL kernel Amazon Kernel ID
                                  'aki-66c06a67' => 'aki-rhel-i386',
                                  'aki-68c06a69' => 'aki-rhel-x86_64'	
+                           },
+            'sa-east-1' => {'' => 'pv-grub-hd00-V1.01-i386',
+                            '' => 'pv-grub-hd00-V1.01-x86_64',
+                            '' => 'pv-grub-hd0-V1.01-i386',
+                            '' => 'pv-grub-hd0-V1.01-x86_64',
+                            'aki-bc3ce3a1' => 'pv-grub-hd00_1.02-i386',
+                            'aki-cc3ce3d1' => 'pv-grub-hd00_1.02-x86_64',
+                            'aki-823ce39f' => 'pv-grub-hd0_1.02-i386',
+                            'aki-d23ce3cf' => 'pv-grub-hd0_1.02-x86_64',
+                            #RHEL kernel Amazon Kernel ID
+                            '' => 'aki-rhel-i386',
+                            '' => 'aki-rhel-x86_64'	
                            }
           }
     target_aki = ''
@@ -1024,6 +1083,8 @@ module StateTransitionHelper
         region = "ap-southeast-1"
       when /ap-northeast/
         region = "ap-northeast-1"
+      when /sa-east-1/
+        region = "sa-east-1"
       else
         region = "us-east-1"
     end

data/lib/scripts/ec2/copy_mswindows_ami.rb

@@ -0,0 +1,449 @@
+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"
+require 'pp'
+
+# 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 CopyMsWindowsAmi < 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)
+    @local_ec2_helper = Ec2Helper.new(@input_params[:ec2_api_handler])
+    @remote_ec2_helper = Ec2Helper.new(@input_params[:target_ec2_handler]) 
+  end
+
+  def check_input_parameters()
+    # MS Windows AMI, source and target region
+    if @input_params[:ami_id] == nil && !(@input_params[:ami_id] =~ /^ami-.*$/)
+      raise Exception.new("Invalid AMI ID specified: #{@input_params[:ami_id]}")
+    end
+    if @local_ec2_helper.ami_prop(@input_params[:ami_id], 'rootDeviceType') != "ebs"
+      raise Exception.new("must be an EBS type image")
+    end
+    if @local_ec2_helper.ami_prop(@input_params[:ami_id], 'platform') != "windows"
+      raise Exception.new("Not a MS Windows AMI: #{@local_ec2_helper.ami_prop(@input_params[:ami_id], 'platform')}")
+    end
+    if @input_params[:helper_ami_id] == nil && !(@input_params[:helper_ami_id] =~ /^ami-.*$/)
+      raise Exception.new("Invalid Helper AMI ID specified: #{@input_params[:helper_ami_id]}")
+    end
+    if @local_ec2_helper.ami_prop(@input_params[:helper_ami_id], 'rootDeviceType') != "ebs"
+      raise Exception.new("must be an EBS type image")
+    end
+    if @local_ec2_helper.ami_prop(@input_params[:helper_ami_id], 'platform') != "windows"
+      raise Exception.new("Not a MS Windows AMI: #{@local_ec2_helper.ami_prop(@input_params[:helper_ami_id], 'platform')}")
+    end
+    # AWS Linux AMI, source and target region
+    if @input_params[:source_ami_id] == nil && !(@input_params[:source_ami_id] =~ /^ami-.*$/)
+      raise Exception.new("Invalid source AMI ID specified: #{@input_params[:source_ami_id]}")
+    end
+    if @input_params[:target_ami_id] == nil && !(@input_params[:target_ami_id] =~ /^ami-.*$/)
+      raise Exception.new("Invalid target AMI ID specified: #{@input_params[:target_ami_id]}")
+    end
+    # AWS SecurityGroup, source and target regions
+    if @input_params[:source_security_groups] == nil
+      @input_params[:source_security_groups] = "default"
+    end
+    if !@local_ec2_helper.check_open_port(@input_params[:source_security_groups], 22)
+      raise Exception.new("Port 22 must be opened for security group '#{@input_params[:source_security_groups]}' to connect via SSH in source-region")
+    end
+    if @input_params[:target_security_groups] == nil
+      @input_params[:target_security_groups] = "default"
+    end
+    if !@remote_ec2_helper.check_open_port(@input_params[:target_security_groups], 22)
+      raise Exception.new("Port 22 must be opened for security group '#{@input_params[:target_security_groups]}' to connect via SSH in target-region")
+    end
+    # Device to use for volume
+    if @input_params[:root_device_name] == nil
+      @input_params[:root_device_name] = "/dev/sda1"
+    end
+    if @input_params[:device_name] == nil
+      @input_params[:device_name] = "/dev/sdj"
+    end
+    if @input_params[:temp_device_name] == nil
+      @input_params[:temp_device_name] = "/dev/sdk"
+    end
+    if @input_params[:temp_device_name] == @input_params[:device_name]
+      raise Exception.new("Device name '#{@input_params[:device_name]}' and temporary device name '#{@input_params[:temp_device_name]}' must be different")
+    end
+    # SSH Parameters, source and target region
+    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
+    if @input_params[:fs_type] == nil
+      @input_params[:fs_type] = "ext3"
+    end
+  end
+
+  # Load the initial state for the script.
+  # Abstract method to be implemented by extending classes.
+  def load_initial_state()
+    CopyMsWindowsAmiState.load_state(@input_params)
+  end
+
+  private
+
+  # Here begins the state machine implementation
+  class CopyMsWindowsAmiState < ScriptExecutionState
+
+    def self.load_state(context)
+      InitialState.new(context)
+      
+    end
+
+    def local_region
+      self.ec2_handler = (@context[:ec2_api_handler])
+      @local_ec2_helper = Ec2Helper.new(self.ec2_handler)
+    end
+
+    def remote_region
+      self.ec2_handler = (@context[:target_ec2_handler])
+      @remote_ec2_helper = Ec2Helper.new(self.ec2_handler)
+    end
+  end
+
+  # Initial State: Retrieve all information on this AMI we need later on 
+  #                and set some parameters such as the Availability Zone
+  #   - Snapshot ID from this AMI
+  #   - Volume size from this AMI
+  #   - Availability Zone 
+  #NB: less modification if we get the AZ from the launched instance
+  class InitialState < CopyMsWindowsAmiState 
+    def enter()
+      local_region()
+      puts "Retrieving AMI parammeters"
+      @context[:snapshot_id] = @local_ec2_helper.ami_blkdevmap_ebs_prop(@context[:ami_id], 'snapshotId')
+      @context[:volume_size] = @local_ec2_helper.ami_blkdevmap_ebs_prop(@context[:ami_id], 'volumeSize')
+      @context[:architecture] = @local_ec2_helper.ami_prop(@context[:ami_id], 'architecture')
+      @context[:root_device_name] = @local_ec2_helper.ami_prop(@context[:ami_id], 'rootDeviceName')
+      #puts "Setting Source and Target Availability Zone if not set" 
+      #@context[:source_availability_zone] = "us-east-1a" unless @context[:source_availability_zone] != nil
+      #@context[:target_availability_zone] = "us-west-1a" unless @context[:target_availability_zone] != nil
+      puts "DEBUG: Parameters: #{@context[:snapshot_id]}, #{@context[:volume_size]}, #{@context[:architecture]}, #{@context[:root_device_name]}"
+  
+      #raise Exception.new("DEBUG: FORCED Script exit")   
+      InitialStateDone.new(@context)
+    end
+  end
+
+  # Initial state: Launch an Amazon Linux AMI in the source Region
+  class InitialStateDone < CopyMsWindowsAmiState 
+    def enter()
+      local_region()
+      result = launch_instance(@context[:source_ami_id], @context[:source_key_name], @context[:source_security_groups])
+      @context[:source_instance_id] = result.first
+      @context[:source_dns_name] = result[1]
+      @context[:source_availability_zone] = result[2]
+      #@context[:source_root_device_name] = @local_ec2_helper.ami_prop(@context[:source_ami_id], 'rootDeviceName')
+      @context[:source_root_device_name] = result[6]
+      puts "DEBUG: Parameters: #{@context[:source_instance_id]}, #{@context[:source_dns_name]}, #{@context[:source_availability_zone]}, #{@context[:source_root_device_name]}"
+
+      SourceInstanceLaunchedState.new(@context)
+    end
+  end
+
+  # Source instance is started.
+  # Steps:
+  #   - create and attach a volume from the Snapshot of the AMI to copy
+  #   - create and attach a temp volume of the same size to dump and compress the entire drive
+  #   - create a filesystem on the temp volume and mount the temp volume
+  #   - dump and compress the entire drive to the temp volume
+  class SourceInstanceLaunchedState < CopyMsWindowsAmiState
+    def enter()
+      local_region()
+      # Step1: create and attach a volume from the Snapshot of the AMI to copy
+      @context[:source_volume_id] = create_volume_from_snapshot(@context[:snapshot_id],
+        @context[:source_availability_zone])
+      source_device = @context[:device_name]
+      attach_volume(@context[:source_volume_id], @context[:source_instance_id], source_device)
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata]) 
+      # detect if there is a shift for device mapping (between AWS and the operating system of the system)
+      root_device_name = get_root_device_name()
+      # detect letters
+      aws_root_device = @context[:source_root_device_name]
+      aws_letter = aws_root_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      os_letter = root_device_name.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      aws_device_letter = source_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      if !aws_letter.eql?(os_letter)
+        post_message("Detected specific kernel with shift between AWS and Kernel OS for device naming")
+      end
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      source_device = "/dev/sd#{aws_device_letter}"
+      post_message("Using AWS name source device '#{@context[:device_name]}' and OS name '#{source_device}'")
+      @context[:source_device_name] = source_device
+      # Step2: create and attach a temp volume of the same size to dump and compress the entire drive
+      @context[:source_temp_volume_id] = create_volume(@context[:source_availability_zone], @context[:volume_size])
+      temp_device = @context[:temp_device_name] 
+      attach_volume(@context[:source_temp_volume_id], @context[:source_instance_id], temp_device)
+      aws_device_letter = temp_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      temp_device="/dev/sd#{aws_device_letter}" 
+      post_message("Using AWS name source device '#{@context[:temp_device_name]}' and OS name '#{temp_device}'") 
+      # Step3: mount the temp volume
+      mount_point = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      create_labeled_fs(@context[:source_dns_name], temp_device, @context[:fs_type], nil)
+      mount_fs(mount_point, temp_device)
+      disconnect()
+
+      SourceVolumeReadyState.new(@context)
+    end
+  end
+
+  # Source is ready
+  # Steps:
+  #   - dump and compress the entire source drive to the temp volume
+  class SourceVolumeReadyState < CopyMsWindowsAmiState
+    def enter()
+      local_region()
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      @context[:source_filename] = "#{mount_point}" + "/" + "#{@context[:snapshot_id]}" + ".gz"
+      local_dump_and_compress_device_to_file(@context[:source_device_name], @context[:source_filename])
+      disconnect()
+
+      BackupedDataState.new(@context)
+    end
+  end
+
+  # Source is ready.
+  # Steps:
+  #   - start an instance of AWS Linux AMI in the target region
+  class BackupedDataState < CopyMsWindowsAmiState 
+    def enter()
+      remote_region()
+      result = launch_instance(@context[:target_ami_id], @context[:target_key_name], @context[:target_security_groups])
+      @context[:target_instance_id] = result.first
+      @context[:target_dns_name] = result[1]
+      @context[:target_availability_zone] = result[2]
+      #@context[:remote_root_device_name] = @remote_ec2_helper.ami_prop(@context[:target_ami_id], 'rootDeviceName')
+      @context[:target_root_device_name] = result[6]
+      puts "DEBUG: Parameters: #{@context[:target_instance_id]}, #{@context[:target_dns_name]}, #{@context[:target_availability_zone]}, #{@context[:target_root_device_name]}"
+
+      TargetInstanceLaunchedState.new(@context)
+    end
+  end
+
+  # Destination instance is started. Now configure storage.
+  # Steps:
+  #   - create and attach a temp volume for receiving archive of the drive
+  #   - create a filesystem on the temp volume and mount the temp volume
+  #   - create and attach a volume for uncompressing and restoring the entire drive 
+  class TargetInstanceLaunchedState < CopyMsWindowsAmiState
+    def enter()
+      remote_region()
+      # Step1: create and attach a temp volume for receiving archive of the drive
+      @context[:target_temp_volume_id] = create_volume(@context[:target_availability_zone], @context[:volume_size])
+      temp_device = @context[:temp_device_name] 
+      attach_volume(@context[:target_temp_volume_id], @context[:target_instance_id], temp_device)
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata]) 
+      # detect if there is a shift for device mapping (between AWS and the operating system of the system)
+      root_device_name = get_root_device_name()
+      # detect letters
+      aws_root_device = @context[:target_root_device_name]
+      aws_letter = aws_root_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      os_letter = root_device_name.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      aws_device_letter = temp_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      if !aws_letter.eql?(os_letter)
+        post_message("Detected specific kernel with shift between AWS and Kernel OS for device naming")
+      end
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      temp_device = "/dev/sd#{aws_device_letter}"
+      post_message("Using AWS name source device '#{@context[:device_name]}' and OS name '#{temp_device}'")
+      # Step2: mount the temp volume
+      mount_point = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      create_labeled_fs(@context[:target_dns_name], temp_device, @context[:fs_type], nil)
+      mount_fs(mount_point, temp_device)
+      # Step3: create and attach a volume for uncompressing and restoring the entire drive
+      @context[:target_volume_id] = create_volume(@context[:target_availability_zone], @context[:volume_size])
+      target_device = @context[:device_name]
+      attach_volume(@context[:target_volume_id], @context[:target_instance_id], target_device)
+      aws_device_letter = target_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      if !aws_letter.eql?(os_letter)
+        post_message("Detected specific kernel with shift between AWS and Kernel OS for device naming")
+      end
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      target_device = "/dev/sd#{aws_device_letter}"
+      @context[:target_device_name] = target_device
+      post_message("Using AWS name source device '#{@context[:device_name]}' and OS name '#{target_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 < CopyMsWindowsAmiState
+    def enter()
+      post_message("upload key of target-instance to source-instance...")
+      path_candidates = ["/#{@context[:source_ssh_username]}/.ssh/", "/home/#{@context[:source_ssh_username]}/.ssh/"]
+      key_path = determine_file(@context[:source_dns_name], @context[:source_ssh_username], @context[:source_ssh_keydata], path_candidates)
+      upload_file(@context[:source_dns_name], @context[:source_ssh_username], @context[:source_ssh_keydata],
+        @context[:target_ssh_keyfile], "#{key_path}#{@context[:target_key_name]}.pem")
+      post_message("credentials are in place to connect source and target (from source to target).")
+
+      KeyInPlaceState.new(@context)
+    end
+  end
+
+  # Now we can copy.
+  class KeyInPlaceState < CopyMsWindowsAmiState
+    def enter()
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      disable_ssh_tty(@context[:target_dns_name])
+      disconnect()
+      #
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      source_dir = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      dest_dir = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      remote_copy(@context[:source_ssh_username], @context[:target_key_name], source_dir, 
+        @context[:target_dns_name], @context[:target_ssh_username], dest_dir)
+      disconnect()
+      #
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      enable_ssh_tty(@context[:target_dns_name])
+      disconnect()
+
+      DataCopiedState.new(@context)
+    end
+  end
+
+  # Decompress data on the device
+  class DataCopiedState < CopyMsWindowsAmiState
+    def enter()
+      remote_region()
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      @context[:source_filename] = "#{mount_point}" + "/" + "#{@context[:snapshot_id]}" + ".gz"
+      local_decompress_and_dump_file_to_device(@context[:source_filename], @context[:target_device_name])
+      disconnect()
+
+      RestoredDataState.new(@context)
+    end
+  end
+
+  # Data of snapshot now copied to the new volume.
+  # Steps:
+  #   - detach the target volume
+  #XXX: TODO
+  class RestoredDataState < CopyMsWindowsAmiState
+    def enter()
+      remote_region()
+      detach_volume(@context[:target_volume_id], @context[:target_instance_id])
+
+      #@context[:new_snapshot_id] = create_snapshot(@context[:target_volume_id], "Created by CloudyScripts - copy_mswindows_ami")
+
+      TargetVolumeCreatedState.new(@context)
+    end
+  end
+
+  # Snapshot Operation done. Now this snapshot must be registered as AMI
+  # Steps:
+  #   - launch same AMI as the one we want to copy and stop it (after it has boot up): use helper_ami_id
+  #   - detach the volume of this instance and attach the new volume
+  #   - start the instance to see if everything is good, then stop it
+  #   - create an AMi from this instance
+  class TargetVolumeCreatedState < CopyMsWindowsAmiState
+    def enter()
+      remote_region()
+      #XXX: launch instance in the right AZ
+      result = launch_instance(@context[:helper_ami_id], @context[:target_key_name], @context[:target_security_groups])
+      @context[:ihelper_instance_id] = result.first
+      @context[:helper_dns_name] = result[1]
+      @context[:helper_availability_zone] = result[2]
+      @context[:target_root_device_name] = result[6]
+
+      #XXX:
+      #  - wait for it to be running, and then stop it
+      #  - wait for it to be stopped, and then sttart it with the new volume
+      shut_down_instance(@context[:source_instance_id])
+
+      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.
+  # Steps:
+  #   - cleanup source region
+  #     - unmount temp volume
+  #     - detach source and temp volume
+  #     - terminate instance
+  #     - delete source and temp volume
+  #   - cleanup target region
+  #     - unmount temp volume
+  #     - detach temp volume
+  #     - terminate instance
+  #     - delete source and temp volume
+  class AmiRegisteredState < CopyMsWindowsAmiState
+    def enter()
+      local_region()
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      unmount_fs(mount_point)
+      disconnect()
+      detach_volume(@context[:source_temp_volume_id], @context[:source_instance_id])
+      detach_volume(@context[:source_volume_id], @context[:source_instance_id])
+      shut_down_instance(@context[:source_instance_id])
+      delete_volume(@context[:source_temp_volume_id])
+      delete_volume(@context[:source_volume_id])
+      #
+      remote_region()
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      unmount_fs(mount_point)
+      disconnect()
+      detach_volume(@context[:target_temp_volume_id], @context[:target_instance_id])
+      shut_down_instance(@context[:target_instance_id])
+      delete_volume(@context[:target_temp_volume_id])
+      delete_volume(@context[:target_volume_id])
+ 
+      Done.new(@context)
+    end
+  end
+
+end

data/lib/scripts/ec2/copy_mswindows_snapshot.rb

@@ -0,0 +1,401 @@
+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"
+require 'pp'
+
+# 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 CopyMsWindowsSnapshot < 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)
+    @local_ec2_helper = Ec2Helper.new(@input_params[:ec2_api_handler])
+    @remote_ec2_helper = Ec2Helper.new(@input_params[:target_ec2_handler]) 
+  end
+
+  def check_input_parameters()
+    if @input_params[:snapshot_id] == nil && !(@input_params[:snapshot_id] =~ /^snap-.*$/)
+      raise Exception.new("Invalid Snapshot ID specified: #{@input_params[:snapshot_id]}")
+    end
+    if @input_params[:source_ami_id] == nil && !(@input_params[:source_ami_id] =~ /^ami-.*$/)
+      raise Exception.new("Invalid source AMI ID specified: #{@input_params[:source_ami_id]}")
+    end
+    if @input_params[:target_ami_id] == nil && !(@input_params[:target_ami_id] =~ /^ami-.*$/)
+      raise Exception.new("Invalid target AMI ID specified: #{@input_params[:target_ami_id]}")
+    end
+    if @input_params[:source_security_groups] == nil
+      @input_params[:source_security_groups] = "default"
+    end
+    if !@local_ec2_helper.check_open_port(@input_params[:source_security_groups], 22)
+      raise Exception.new("Port 22 must be opened for security group '#{@input_params[:source_security_groups]}' to connect via SSH in source-region")
+    end
+    if @input_params[:target_security_groups] == nil
+      @input_params[:target_security_groups] = "default"
+    end
+    if !@remote_ec2_helper.check_open_port(@input_params[:target_security_groups], 22)
+      raise Exception.new("Port 22 must be opened for security group '#{@input_params[:target_security_groups]}' to connect via SSH in target-region")
+    end
+    if @input_params[:root_device_name] == nil
+      @input_params[:root_device_name] = "/dev/sda1"
+    end
+    if @input_params[:device_name] == nil
+      @input_params[:device_name] = "/dev/sdj"
+    end
+    if @input_params[:temp_device_name] == nil
+      @input_params[:temp_device_name] = "/dev/sdk"
+    end
+    if @input_params[:temp_device_name] == @input_params[:device_name]
+      raise Exception.new("Device name '#{@input_params[:device_name]}' and temporary device name '#{@input_params[:temp_device_name]}' must be different")
+    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
+    if @input_params[:fs_type] == nil
+      @input_params[:fs_type] = "ext3"
+    end
+  end
+
+  # Load the initial state for the script.
+  # Abstract method to be implemented by extending classes.
+  def load_initial_state()
+    CopyMsWindowsSnapshotState.load_state(@input_params)
+  end
+
+  private
+
+  # Here begins the state machine implementation
+  class CopyMsWindowsSnapshotState < ScriptExecutionState
+
+    def self.load_state(context)
+      InitialState.new(context)
+    end
+
+    def local_region
+      self.ec2_handler = (@context[:ec2_api_handler])
+      @local_ec2_helper = Ec2Helper.new(self.ec2_handler)
+    end
+
+    def remote_region
+      self.ec2_handler = (@context[:target_ec2_handler])
+      @remote_ec2_helper = Ec2Helper.new(self.ec2_handler)
+    end
+  end
+
+  # Initial State: Retrieve all information on this AMI we need later on 
+  #                and set some parameters such as the Availability Zone
+  #   - Snapshot ID from this AMI
+  #   - Volume size from this AMI
+  #   - Availability Zone 
+  #NB: less modification if we get the AZ from the launched instance
+  class InitialState < CopyMsWindowsSnapshotState 
+    def enter()
+      local_region()
+      puts "Retrieving AMI parammeters"
+      @context[:volume_size] = @local_ec2_helper.snapshot_prop(@context[:snapshot_id], :volumeSize).to_i
+      #puts "Setting Source and Target Availability Zone if not set" 
+      #@context[:source_availability_zone] = "us-east-1a" unless @context[:source_availability_zone] != nil
+      #@context[:target_availability_zone] = "us-west-1a" unless @context[:target_availability_zone] != nil
+      puts "DEBUG: Parameters: #{@context[:snapshot_id]}, #{@context[:volume_size]}"
+  
+      InitialStateDone.new(@context)
+    end
+  end
+
+  # Initial state: Launch an Amazon Linux AMI in the source Region
+  class InitialStateDone < CopyMsWindowsSnapshotState 
+    def enter()
+      local_region()
+      result = launch_instance(@context[:source_ami_id], @context[:source_key_name], @context[:source_security_groups])
+      @context[:source_instance_id] = result.first
+      @context[:source_dns_name] = result[1]
+      @context[:source_availability_zone] = result[2]
+      #@context[:source_root_device_name] = @local_ec2_helper.ami_prop(@context[:source_ami_id], 'rootDeviceName')
+      @context[:source_root_device_name] = result[6]
+      puts "DEBUG: Parameters: #{@context[:source_instance_id]}, #{@context[:source_dns_name]}, #{@context[:source_availability_zone]}, #{@context[:source_root_device_name]}"
+
+      SourceInstanceLaunchedState.new(@context)
+    end
+  end
+
+  # Source instance is started.
+  # Steps:
+  #   - create and attach a volume from the Snapshot of the AMI to copy
+  #   - create and attach a temp volume of the same size to dump and compress the entire drive
+  #   - create a filesystem on the temp volume and mount the temp volume
+  #   - dump and compress the entire drive to the temp volume
+  class SourceInstanceLaunchedState < CopyMsWindowsSnapshotState
+    def enter()
+      local_region()
+      # Step1: create and attach a volume from the Snapshot of the AMI to copy
+      @context[:source_volume_id] = create_volume_from_snapshot(@context[:snapshot_id],
+        @context[:source_availability_zone])
+      source_device = @context[:device_name]
+      attach_volume(@context[:source_volume_id], @context[:source_instance_id], source_device)
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata]) 
+      # detect if there is a shift for device mapping (between AWS and the operating system of the system)
+      root_device_name = get_root_device_name()
+      # detect letters
+      aws_root_device = @context[:source_root_device_name]
+      aws_letter = aws_root_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      os_letter = root_device_name.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      aws_device_letter = source_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      if !aws_letter.eql?(os_letter)
+        post_message("Detected specific kernel with shift between AWS and Kernel OS for device naming")
+      end
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      source_device = "/dev/sd#{aws_device_letter}"
+      post_message("Using AWS name source device '#{@context[:device_name]}' and OS name '#{source_device}'")
+      @context[:source_device_name] = source_device
+      # Step2: create and attach a temp volume of the same size to dump and compress the entire drive
+      @context[:source_temp_volume_id] = create_volume(@context[:source_availability_zone], @context[:volume_size])
+      temp_device = @context[:temp_device_name] 
+      attach_volume(@context[:source_temp_volume_id], @context[:source_instance_id], temp_device)
+      aws_device_letter = temp_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      temp_device="/dev/sd#{aws_device_letter}" 
+      post_message("Using AWS name source device '#{@context[:temp_device_name]}' and OS name '#{temp_device}'") 
+      # Step3: mount the temp volume
+      mount_point = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      create_labeled_fs(@context[:source_dns_name], temp_device, @context[:fs_type], nil)
+      mount_fs(mount_point, temp_device)
+      disconnect()
+
+      SourceVolumeReadyState.new(@context)
+    end
+  end
+
+  # Source is ready
+  # Steps:
+  #   - dump and compress the entire source drive to the temp volume
+  class SourceVolumeReadyState < CopyMsWindowsSnapshotState
+    def enter()
+      local_region()
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      @context[:source_filename] = "#{mount_point}" + "/" + "#{@context[:snapshot_id]}" + ".gz"
+      local_dump_and_compress_device_to_file(@context[:source_device_name], @context[:source_filename])
+      disconnect()
+
+      BackupedDataState.new(@context)
+    end
+  end
+
+  # Source is ready.
+  # Steps:
+  #   - start an instance of AWS Linux AMI in the target region
+  class BackupedDataState < CopyMsWindowsSnapshotState 
+    def enter()
+      remote_region()
+      result = launch_instance(@context[:target_ami_id], @context[:target_key_name], @context[:target_security_groups])
+      @context[:target_instance_id] = result.first
+      @context[:target_dns_name] = result[1]
+      @context[:target_availability_zone] = result[2]
+      #@context[:remote_root_device_name] = @remote_ec2_helper.ami_prop(@context[:target_ami_id], 'rootDeviceName')
+      @context[:target_root_device_name] = result[6]
+      puts "DEBUG: Parameters: #{@context[:target_instance_id]}, #{@context[:target_dns_name]}, #{@context[:target_availability_zone]}, #{@context[:target_root_device_name]}"
+
+      TargetInstanceLaunchedState.new(@context)
+    end
+  end
+
+  # Destination instance is started. Now configure storage.
+  # Steps:
+  #   - create and attach a temp volume for receiving archive of the drive
+  #   - create a filesystem on the temp volume and mount the temp volume
+  #   - create and attach a volume for uncompressing and restoring the entire drive 
+  class TargetInstanceLaunchedState < CopyMsWindowsSnapshotState
+    def enter()
+      remote_region()
+      # Step1: create and attach a temp volume for receiving archive of the drive
+      @context[:target_temp_volume_id] = create_volume(@context[:target_availability_zone], @context[:volume_size])
+      temp_device = @context[:temp_device_name] 
+      attach_volume(@context[:target_temp_volume_id], @context[:target_instance_id], temp_device)
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata]) 
+      # detect if there is a shift for device mapping (between AWS and the operating system of the system)
+      root_device_name = get_root_device_name()
+      # detect letters
+      aws_root_device = @context[:target_root_device_name]
+      aws_letter = aws_root_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      os_letter = root_device_name.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      aws_device_letter = temp_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      if !aws_letter.eql?(os_letter)
+        post_message("Detected specific kernel with shift between AWS and Kernel OS for device naming")
+      end
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      temp_device = "/dev/sd#{aws_device_letter}"
+      post_message("Using AWS name source device '#{@context[:device_name]}' and OS name '#{temp_device}'")
+      # Step2: mount the temp volume
+      mount_point = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      create_labeled_fs(@context[:target_dns_name], temp_device, @context[:fs_type], nil)
+      mount_fs(mount_point, temp_device)
+      # Step3: create and attach a volume for uncompressing and restoring the entire drive
+      @context[:target_volume_id] = create_volume(@context[:target_availability_zone], @context[:volume_size])
+      target_device = @context[:device_name]
+      attach_volume(@context[:target_volume_id], @context[:target_instance_id], target_device)
+      aws_device_letter = target_device.split('/')[2].gsub('sd', '').gsub('xvd', '').gsub(/[0-9]/, '')
+      if !aws_letter.eql?(os_letter)
+        post_message("Detected specific kernel with shift between AWS and Kernel OS for device naming")
+      end
+      while !aws_letter.eql?(os_letter)
+        aws_letter.succ!
+        aws_device_letter.succ!
+      end
+      target_device = "/dev/sd#{aws_device_letter}"
+      @context[:target_device_name] = target_device
+      post_message("Using AWS name source device '#{@context[:device_name]}' and OS name '#{target_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 < CopyMsWindowsSnapshotState
+    def enter()
+      post_message("upload key of target-instance to source-instance...")
+      path_candidates = ["/#{@context[:source_ssh_username]}/.ssh/", "/home/#{@context[:source_ssh_username]}/.ssh/"]
+      key_path = determine_file(@context[:source_dns_name], @context[:source_ssh_username], @context[:source_ssh_keydata], path_candidates)
+      upload_file(@context[:source_dns_name], @context[:source_ssh_username], @context[:source_ssh_keydata],
+        @context[:target_ssh_keyfile], "#{key_path}#{@context[:target_key_name]}.pem")
+      post_message("credentials are in place to connect source and target (from source to target).")
+
+      KeyInPlaceState.new(@context)
+    end
+  end
+
+  # Now we can copy.
+  class KeyInPlaceState < CopyMsWindowsSnapshotState
+    def enter()
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      disable_ssh_tty(@context[:target_dns_name])
+      disconnect()
+      #
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      source_dir = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      dest_dir = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      remote_copy(@context[:source_ssh_username], @context[:target_key_name], source_dir, 
+        @context[:target_dns_name], @context[:target_ssh_username], dest_dir)
+      disconnect()
+      #
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      enable_ssh_tty(@context[:target_dns_name])
+      disconnect()
+
+      DataCopiedState.new(@context)
+    end
+  end
+
+  # Decompress data on the device
+  class DataCopiedState < CopyMsWindowsSnapshotState
+    def enter()
+      remote_region()
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      @context[:source_filename] = "#{mount_point}" + "/" + "#{@context[:snapshot_id]}" + ".gz"
+      local_decompress_and_dump_file_to_device(@context[:source_filename], @context[:target_device_name])
+      disconnect()
+
+      RestoredDataState.new(@context)
+    end
+  end
+
+  # Data of snapshot now copied to the new volume.
+  # Steps:
+  #   - detach the target volume
+  #XXX: TODO
+  class RestoredDataState < CopyMsWindowsSnapshotState
+    def enter()
+      remote_region()
+      detach_volume(@context[:target_volume_id], @context[:target_instance_id])
+      @context[:new_snapshot_id] = create_snapshot(@context[:target_volume_id], "Created by CloudyScripts - copy_mswindows_ami")
+      @context[:result][:snapshot_id] = @context[:new_snapshot_id]
+
+      #XXX: for testing, bypass cleanup
+      Done.new(@context)
+      #TargetSnapshotCreatedState.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.
+  # Steps:
+  #   - cleanup source region
+  #     - unmount temp volume
+  #     - detach source and temp volume
+  #     - terminate instance
+  #     - delete source and temp volume
+  #   - cleanup target region
+  #     - unmount temp volume
+  #     - detach temp volume
+  #     - terminate instance
+  #     - delete source and temp volume
+  class TargetSnapshotCreatedState < CopyMsWindowsSnapshotState
+    def enter()
+      local_region()
+      connect(@context[:source_dns_name], @context[:source_ssh_username], nil, @context[:source_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:source_temp_volume_id]}"
+      unmount_fs(mount_point)
+      disconnect()
+      detach_volume(@context[:source_temp_volume_id], @context[:source_instance_id])
+      detach_volume(@context[:source_volume_id], @context[:source_instance_id])
+      shut_down_instance(@context[:source_instance_id])
+      delete_volume(@context[:source_temp_volume_id])
+      delete_volume(@context[:source_volume_id])
+      #
+      remote_region()
+      connect(@context[:target_dns_name], @context[:target_ssh_username], nil, @context[:target_ssh_keydata])
+      mount_point = "/mnt/tmp_#{@context[:target_temp_volume_id]}"
+      unmount_fs(mount_point)
+      disconnect()
+      detach_volume(@context[:target_temp_volume_id], @context[:target_instance_id])
+      shut_down_instance(@context[:target_instance_id])
+      delete_volume(@context[:target_temp_volume_id])
+      delete_volume(@context[:target_volume_id])
+ 
+      Done.new(@context)
+    end
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: CloudyScripts
 version: !ruby/object:Gem::Version 
-  hash: 67
+  hash: 93
   prerelease: false
   segments: 
   - 2
-  - 11
-  - 48
-  version: 2.11.48
+  - 12
+  - 49
+  version: 2.12.49
 platform: ruby
 authors: 
 - Matthias Jung
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-29 00:00:00 +00:00
+date: 2011-12-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -251,10 +251,12 @@ files:
 - lib/audit/benchmark_ssh.zip
 - lib/scripts/vCloud/v_cloud_script.rb
 - lib/scripts/vCloud/open_port_checker_vm.rb
+- lib/scripts/ec2/copy_mswindows_snapshot.rb
 - lib/scripts/ec2/port_range_detector.rb
 - lib/scripts/ec2/dm_encrypt.rb
 - lib/scripts/ec2/vpc_critical_ports_audit.rb
 - lib/scripts/ec2/ami2_ebs_conversion.rb
+- lib/scripts/ec2/copy_mswindows_ami.rb
 - lib/scripts/ec2/audit_via_ssh.rb
 - lib/scripts/ec2/open_port_checker.rb
 - lib/scripts/ec2/copy_ami.rb