CloudyScripts 0.0.4 → 0.0.5

data/README.rdoc

@@ -21,4 +21,7 @@
 # * #DmEncrypt (encrypt Amazon EBS Storage using dm-encrypt)
 #
 # =Questions and Suggestions
+# Matthias Jung
 # matthias.jung@gmail.com
+# http://elastic-security.com
+

data/Rakefile

@@ -12,7 +12,7 @@ require 'rake/testtask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'CloudyScripts'
-  s.version = '0.0.4'
+  s.version = '0.0.5'
   s.has_rdoc = true
   s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
   s.summary = 'Scripts to facilitate programming for infrastructure clouds.'

data/lib/help/dm_crypt_helper.rb

@@ -4,6 +4,11 @@ require 'help/remote_command_handler'
 # (see #Scripts::EC2::DmEncrypt)
 
 class DmCryptHelper
+  attr_accessor :logger
+
+  def initialize
+    @logger = Logger.new(STDOUT)
+  end
 
   # Passes an remote command handler object
   # (see #Help::RemoteCommandHandler)
@@ -46,15 +51,15 @@ class DmCryptHelper
     else
       mapper_exists = false
     end
-    puts "mapper exists = #{mapper_exists}"
+    @logger.info "mapper exists = #{mapper_exists}"
     exec_string = "cryptsetup create dm-#{name} #{device}"
     if !mapper_exists
       #mapper does not exist, create it
       channel = @ssh_session.open_channel do |ch|
         ch.send_data("#{password}\n")
-        puts "execute #{exec_string}"
+        @logger.debug "execute #{exec_string}"
         ch.exec exec_string do |ch, success|
-          puts "success = #{success}"
+          @logger.debug "success = #{success}"
           if !success
             err = "Failed during creation of encrypted partition"
             #puts "#{err}: #{data}"
@@ -78,12 +83,12 @@ class DmCryptHelper
     end
     if !pv_exists
       exec_string = "pvcreate /dev/mapper/dm-#{name}"
-      puts "pv does not exist - execute: #{exec_string}"
+      @logger.info "pv does not exist - execute: #{exec_string}"
       #private volume does not exist, create it
       channel = @ssh_session.open_channel do |ch|
         ch.send_data("y\n")
         ch.exec exec_string do |ch, success|
-          puts "success = #{success}"
+          @logger.debug "success = #{success}"
           if !success
             err = "Failed during creation of physical volume"
             #puts "#{err}: #{data}"
@@ -106,26 +111,26 @@ class DmCryptHelper
     end
     if !vg_exists
       exec_string = "vgcreate vg-#{name} /dev/mapper/dm-#{name}"
-      puts "vg_exists == false; execute #{exec_string}"
+      @logger.info "vg_exists == false; execute #{exec_string}"
       @ssh_session.exec! exec_string do |ch, stream, data|
         if stream == :stderr && data != nil
           err = "Failed during creation of volume group"
-          puts "#{err}: #{data}"
+          @logger.warn "#{err}: #{data}"
           raise Exception.new(err)
         end
       end
       #exec_string = "lvcreate -n lv-#{name} -L#{size_in_mb.to_s}M vg-#{name}"
       exec_string = "lvcreate -n lv-#{name} -l100%FREE vg-#{name}"
-      puts "execute #{exec_string}"
+      @logger.info "execute #{exec_string}"
       @ssh_session.exec! exec_string do |ch, stream, data|
         if stream == :stderr && data != nil
           err = "Failed during creation of logical volume"
-          puts "#{err}: #{data}"
+          @logger.debug "#{err}: #{data}"
           raise Exception.new(err)
         end
       end
-      exec_string = "mkfs -t ext3 /dev/vg-#{name}/lv-#{name}"
-      puts "execute #{exec_string}"
+      exec_string = "mkfs -t ext3 /dev/vg-#{name}/lv-#{name}" #TODO: use method in remote_command_handler
+      @logger.info "execute #{exec_string}"
       @ssh_session.exec! exec_string #do |ch, stream, data|
         #if stream == :stderr && data != nil
         #err = "Failed during creation of file-system"
@@ -139,11 +144,11 @@ class DmCryptHelper
       end
     else
       exec_string = "/sbin/vgchange -a y vg-#{name}"
-      puts "vg_exists == true; execute #{exec_string}"
+      @logger.info "vg_exists == true; execute #{exec_string}"
       @ssh_session.exec! exec_string do |ch, stream, data| #TODO: the right size instead L2G!
         if stream == :stderr && data != nil
           err = "Failed during re-activation of volume group"
-          puts "#{err}: #{data}"
+          @logger.info "#{err}: #{data}"
           raise Exception.new(err)
         end
       end
@@ -158,29 +163,29 @@ class DmCryptHelper
   # Undo encryption for the volume specified by name and path
   def undo_encryption(name, path)
     exec_string = "umount #{path}"
-    puts "going to execute #{exec_string}"
+    @logger.debug "going to execute #{exec_string}"
     @ssh_session.exec! exec_string do |ch, stream, data|
-      puts "returns #{data}"
+      @logger.debug "returns #{data}"
     end
     exec_string = "lvremove --verbose vg-#{name} -f" #[with confirmation?]
-    puts "going to execute #{exec_string}"
+    @logger.debug "going to execute #{exec_string}"
     @ssh_session.exec! exec_string do |ch, stream, data|
-      puts "returns #{data}"
+      @logger.debug "returns #{data}"
     end
     exec_string = "vgremove vg-#{name}"
-    puts "going to execute #{exec_string}"
+    @logger.debug "going to execute #{exec_string}"
     @ssh_session.exec! exec_string do |ch, stream, data|
-      puts "returns #{data}"
+      @logger.debug "returns #{data}"
     end
     exec_string = "pvremove /dev/mapper/dm-#{name}"
-    puts "going to execute #{exec_string}"
+    @logger.debug "going to execute #{exec_string}"
     @ssh_session.exec! exec_string do |ch, stream, data|
-      puts "returns #{data}"
+      @logger.debug "returns #{data}"
     end
     exec_string = "cryptsetup remove dm-#{name}"
-    puts "going to execute #{exec_string}"
+    @logger.debug "going to execute #{exec_string}"
     @ssh_session.exec! exec_string do |ch, stream, data|
-      puts "returns #{data}"
+      @logger.debug "returns #{data}"
     end
   end
 

data/lib/help/remote_command_handler.rb

@@ -4,8 +4,10 @@ require 'help/dm_crypt_helper'
 
 # Provides methods to be executed via ssh to remote instances.
 class RemoteCommandHandler
+  attr_accessor :logger
   def initialize
     @crypto = DmCryptHelper.new #TODO: instantiate helpers for different tools
+    @logger = Logger.new(STDOUT)
   end
 
   # Check if the path/file specified exists
@@ -23,7 +25,7 @@ class RemoteCommandHandler
   # Params:
   # * ip: ip address of the machine to connect to
   # * keyfile: path of the keyfile to be used for authentication
-  def connect(ip, keyfile)
+  def connect_with_keyfile(ip, keyfile)
     @ssh_session = Net::SSH.start(ip, 'root', :keys => [keyfile])
     @crypto.set_ssh(@ssh_session)
   end
@@ -63,24 +65,46 @@ class RemoteCommandHandler
     drive_mounted?(path) #TODO: must at least also check the name
   end
 
+  def create_filesystem(fs_type, volume)
+    e = "echo y >tmp.txt; mkfs -t #{fs_type} #{volume} <tmp.txt; rm -f tmp.txt"
+    @logger.debug "exec #{e}"
+    @ssh_session.exec! e do |ch, stream, data|
+      @logger.debug "#{e}: output on #{stream.inspect}: #{data}"
+    end
+  end
+
+  def mkdir(path)
+    e = "mkdir #{path}"
+    @logger.debug "exec #{e}"
+    @ssh_session.exec! e do |ch, stream, data|
+      @logger.debug "#{e}: output on #{stream.inspect}: #{data}"
+    end
+  end
+
+  def mount(device, path)
+    e = "mount #{device} #{path}"
+    @logger.debug "exec #{e}"
+    @ssh_session.exec! e do |ch, stream, data|
+      @logger.debug "#{e}: output on #{stream.inspect}: #{data}"
+    end
+  end
+
   # Checks if the drive on path is mounted
   def drive_mounted?(path)
     #check if drive mounted
     drive_found = false
     @ssh_session.exec! "mount" do |ch, stream, data|
       if stream == :stdout
-        puts "mount command produces the following data: #{data}\n---------------"
+        @logger.debug "mount command produces the following data: #{data}\n---------------"
         if data.include?("on #{path} type")
           drive_found = true
-        else
-          puts "not mounted: #{data}"
         end
       end
     end
     if drive_found
       return RemoteCommandHandler.file_exists?(@ssh_session, path)
     else
-      puts "not mounted (since #{path} non-existing)"
+      @logger.debug "not mounted (since #{path} non-existing)"
       false
     end
   end
@@ -93,8 +117,6 @@ class RemoteCommandHandler
       if stream == :stdout
         if data.include?("#{device} on #{path} type")
           drive_mounted = true
-        else
-          puts "not mounted: #{data}"
         end
       end
     end
@@ -104,19 +126,10 @@ class RemoteCommandHandler
   # Activates the encrypted volume, i.e. mounts it if not yet done.
   def activate_encrypted_volume(name, path)
     drive_mounted = drive_mounted?(path)
-    puts "drive #{path} mounted? #{drive_mounted}"
+    @logger.debug "drive #{path} mounted? #{drive_mounted}"
     if !drive_mounted
-      @ssh_session.exec! "mkdir #{path}"
-      exec_string = "mount /dev/vg-#{name}/lv-#{name} #{path}"
-      puts "drive not mounted; execute: #{exec_string}"
-      @ssh_session.exec! "mount /dev/vg-#{name}/lv-#{name} #{path}" do |ch, stream, data|
-        if stream == :stderr && data != nil
-          err = "Failed during mounting encrypted device"
-          puts "#{err}: #{data}"
-          puts "mount /dev/vg-#{name}/lv-#{name} #{path}"
-          raise Exception.new(err)
-        end
-      end
+      mkdir(path)
+      mount("/dev/vg-#{name}/lv-#{name}", "#{path}")
     end
   end
 
@@ -128,11 +141,20 @@ class RemoteCommandHandler
   # Unmount the specified path.
   def umount(path)
     exec_string = "umount #{path}"
-    puts "going to execute #{exec_string}"
+    @logger.debug "going to execute #{exec_string}"
     @ssh_session.exec! exec_string do |ch, stream, data|
-      puts "ssh_api.umount: returns #{data}"
+      @logger.debug "ssh_api.umount: returns #{data}"
     end
     !drive_mounted?(path)
   end
   
+  # Copy directory using options -avHx
+  def rsync(source_path, dest_path)
+    e = "rsync -avHx #{source_path} #{dest_path}"
+    @logger.debug "going to execute #{e}"
+    @ssh_session.exec! e do |ch, stream, data|
+      @logger.debug "#{e}: output on #{stream.inspect}: #{data}"
+    end
+  end
+
 end

data/lib/help/script_execution_state.rb

@@ -4,11 +4,16 @@
 # return another state.
 class ScriptExecutionState
   # context information for the state (hash)
-  attr_reader :context
+  attr_reader :context, :logger
 
   def initialize(context)
     @context = context
     @state_change_listeners = []
+    @logger = context[:logger]
+    if @logger == nil
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::WARN
+    end
   end
 
   # Listener should extend #StateChangeListener (or implement a 
@@ -20,16 +25,17 @@ class ScriptExecutionState
   # Start the state machine using this state as initial state.
   def start_state_machine
     @current_state = self
-    puts "start state machine with #{@current_state.inspect}"
+    @logger.info "start state machine with #{@current_state.inspect}"
     while !@current_state.done? && !@current_state.failed?
       begin
+        @logger.info "state machine: current state = #{@current_state.inspect}"
         @current_state = @current_state.enter()
         notify_state_change_listeners(@current_state)
       rescue Exception => e
         @current_state = FailedState.new(@context, e.to_s, @current_state)
         notify_state_change_listeners(@current_state)
-        puts "Exception: #{e}"
-        puts "#{e.backtrace.join("\n")}"
+        @logger.warn "Exception: #{e}"
+        @logger.warn "#{e.backtrace.join("\n")}"
       end
     end
     @current_state

data/lib/scripts/ec2/ami2_ebs_conversion.rb

@@ -0,0 +1,443 @@
+require "help/script_execution_state"
+require "scripts/ec2/ec2_script"
+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.
+#
+
+class Ami2EbsConversion < Ec2Script
+  # Input parameters
+  # * aws_access_key => the Amazon AWS Access Key (see Your Account -> Security Credentials)
+  # * 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_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)
+  # * ec2_api_handler => object that allows to access the EC2 API (optional)
+  # * ec2_api_server => server to connect to (option, default is us-east-1.ec2.amazonaws.com)
+  # * name => the name of the AMI to be created
+  # * description => description on AMI to be created (optional)
+  # * temp_device_name => [default /dev/sdj] device name used to attach the temporary storage; change this only if there's already a volume attacged as /dev/sdj (optional, default is /dev/sdj)
+  # * root_device_name"=> [default /dev/sda1] device name used for the root device (optional)
+  def initialize(input_params)
+    super(input_params)
+    @result = {:done => false}
+  end
+
+  # Executes the script.
+  def start_script()
+    begin
+      # optional parameters and initialization
+      if @input_params[:name] == nil
+        @input_params[:name] = "Boot EBS (for AMI #{@input_params[:ami_id]}) at #{Time.now.strftime('%d/%m/%Y %H.%M.%S')}"
+      else
+      end
+      if @input_params[:description] == nil
+        @input_params[:description] = @input_params[:name]
+      end
+      if @input_params[:temp_device_name] == nil
+        @input_params[:temp_device_name] = "/dev/sdj"
+      end
+      if @input_params[:root_device_name] == nil
+        @input_params[:root_device_name] = "/dev/sda1"
+      end
+      # start state machine
+      current_state = Ami2EbsConversionState.load_state(@input_params)
+      @state_change_listeners.each() {|listener|
+        current_state.register_state_change_listener(listener)
+      }
+      end_state = current_state.start_state_machine()
+      if end_state.failed?
+        @result[:failed] = true
+        @result[:failure_reason] = current_state.end_state.failure_reason
+        @result[:end_state] = current_state.end_state
+      else
+        @result[:failed] = false
+      end
+    rescue Exception => e
+      @logger.warn "exception during encryption: #{e}"
+      @logger.warn e.backtrace.join("\n")
+      err = e.to_s
+      err += " (in #{current_state.end_state.to_s})" unless current_state == nil
+      @result[:failed] = true
+      @result[:failure_reason] = err
+      @result[:end_state] = current_state.end_state unless current_state == nil
+    ensure
+      begin
+      @input_params[:remote_command_handler].disconnect
+      rescue Exception => e2
+      end
+    end
+
+    #
+    @result[:done] = true
+  end
+
+  # Returns a hash with the following information:
+  # :done => if execution is done
+  #
+  def get_execution_result
+    @result
+  end
+  
+  private
+
+  # Here begins the state machine implementation
+  class Ami2EbsConversionState < ScriptExecutionState
+    def self.load_state(context)
+      state = context[:initial_state] == nil ? InitialState.new(context) : context[:initial_state]
+      state
+    end
+
+    def connect
+      if @context[:remote_command_handler] == nil
+        @context[:remote_command_handler] = RemoteCommandHandler.new
+      end
+      connected = false
+      remaining_trials = 3
+      while !connected && remaining_trials > 0
+        remaining_trials -= 1
+        if @context[:ssh_keyfile] != nil
+          begin
+            @context[:remote_command_handler].connect_with_keyfile(@context[:dns_name], @context[:ssh_keyfile])
+            connected = true
+          rescue Exception => e
+            @logger.info("connection failed due to #{e}")
+          end
+        elsif @context[:ssh_keydata] != nil
+          begin
+            @context[:remote_command_handler].connect(@context[:dns_name], "root", @context[:ssh_keydata])
+            connected = true
+          rescue Exception => e
+            @logger.info("connection failed due to #{e}")
+          end
+        else
+          raise Exception.new("no key information specified")
+        end
+        if !connected
+          sleep(5) #try again
+        end
+      end
+      @logger.info "connected to #{@context[:dns_name]}"
+    end
+
+  end
+
+  # Nothing done yet. Start by instantiating an AMI (in the right zone?)
+  # which serves to create 
+  class InitialState < Ami2EbsConversionState
+    def enter
+      startup_ami()
+    end
+
+    private
+
+    def startup_ami()
+      @logger.debug "start up AMI #{@context[:ami_id]}"
+      res = @context[:ec2_api_handler].run_instances(:image_id => @context[:ami_id], 
+        :security_group => @context[:security_group_name], :key_name => @context[:key_name])
+      puts "res = #{res.inspect}"#TODO:remove
+      instance_id = res['instancesSet']['item'][0]['instanceId']
+      @context[:instance_id] = instance_id
+      @logger.info "started instance #{instance_id}"
+      #availability_zone , key_name/group_name
+      started = false
+      while started == false
+        sleep(5)
+        res = @context[:ec2_api_handler].describe_instances(:instance_id => @context[:instance_id])
+        state = res['reservationSet']['item'][0]['instancesSet']['item'][0]['instanceState']
+        @logger.info "instance in state #{state['name']} (#{state['code']})"
+        if state['code'].to_i == 16
+          started = true
+          @context[:dns_name] = res['reservationSet']['item'][0]['instancesSet']['item'][0]['dnsName']
+          @context[:availability_zone] = res['reservationSet']['item'][0]['instancesSet']['item'][0]['placement']['availabilityZone']
+          @context[:kernel_id] = res['reservationSet']['item'][0]['instancesSet']['item'][0]['kernelId']
+          @context[:ramdisk_id] = res['reservationSet']['item'][0]['instancesSet']['item'][0]['ramdiskId']
+          @context[:architecture] = res['reservationSet']['item'][0]['instancesSet']['item'][0]['architecture']
+        elsif state['code'].to_i != 0
+          raise Exception.new('instance failed to start up')
+        end
+      end
+      AmiStarted.new(@context)
+    end
+  end
+
+  # Ami started. Create a storage
+  class AmiStarted < Ami2EbsConversionState
+    def enter
+      create_storage()
+    end
+
+    private
+
+    def create_storage()
+      @logger.debug "create volume in zone #{@context[:availability_zone]}"
+      res = @context[:ec2_api_handler].create_volume(:availability_zone => @context[:availability_zone], :size => "10")
+      @context[:volume_id] = res['volumeId']
+      started = false
+      while !started
+        sleep(5)
+        #TODO: check for timeout?
+        res = @context[:ec2_api_handler].describe_volumes(:volume_id => @context[:volume_id])
+        state = res['volumeSet']['item'][0]['status']
+        @logger.debug "volume state #{state}"
+        if state == 'available'
+          started = true
+        end
+      end
+      StorageCreated.new(@context)
+    end
+
+  end
+
+  # Storage created. Attach it.
+  class StorageCreated < Ami2EbsConversionState
+    def enter
+      attach_storage()
+    end
+
+    private
+
+    def attach_storage()
+      @logger.debug "attach volume #{@context[:volume_id]} to instance #{@context[:instance_id]} on device #{@context[:temp_device_name]}"
+      @context[:ec2_api_handler].attach_volume(:volume_id => @context[:volume_id],
+        :instance_id => @context[:instance_id],
+        :device => @context[:temp_device_name]
+      )
+      done = false
+      while !done
+        sleep(5)
+        #TODO: check for timeout?
+        res = @context[:ec2_api_handler].describe_volumes(:volume_id => @context[:volume_id])
+        state = res['volumeSet']['item'][0]['status']
+        @logger.debug "storage attaching: #{state}"
+        if  state == 'in-use'
+          done = true
+        end
+      end
+      StorageAttached.new(@context)
+    end
+
+  end
+
+  # Storage attached. Create a file-system and moun it
+  class StorageAttached < Ami2EbsConversionState
+    def enter
+      create_fs()
+    end
+
+    private
+
+    def create_fs()
+      @logger.debug "create filesystem on #{@context[:dns_name]} to #{@context[:temp_device_name]}"
+      connect()
+      @context[:remote_command_handler].create_filesystem("ext3", @context[:temp_device_name])
+      FileSystemCreated.new(@context)
+    end
+  end
+
+  # File system created. Mount it.
+  class FileSystemCreated < Ami2EbsConversionState
+    def enter
+      mount_fs()
+    end
+
+    private
+
+    def mount_fs()
+      @context[:path] = "/mnt/tmp_#{@context[:volume_id]}"
+      @logger.debug "mount #{@context[:temp_device_name]} on #{@context[:path]}"
+      @context[:remote_command_handler].mkdir(@context[:path])
+      @context[:remote_command_handler].mount(@context[:temp_device_name], @context[:path])
+      sleep(2) #give mount some time
+      if !@context[:remote_command_handler].drive_mounted?(@context[:path])
+        raise Exception.new("drive #{@context[:path]} not mounted")
+      end
+      FileSystemMounted.new(@context)
+    end
+  end
+
+  # File system created and mounted. Copy the root partition.
+  class FileSystemMounted < Ami2EbsConversionState
+    def enter
+      copy()
+    end
+
+    private
+
+    def copy()
+      @logger.debug "start copying to #{@context[:path]}"
+      start = Time.new.to_i
+      @context[:remote_command_handler].rsync("/", "#{@context[:path]}")
+      @context[:remote_command_handler].rsync("/dev/", "#{@context[:path]}/dev/")
+      endtime = Time.new.to_i
+      @logger.info "copy took #{(endtime-start)}s"
+      CopyDone.new(@context)
+    end
+  end
+  
+  # Copy operation done. Unmount volume.
+  class CopyDone < Ami2EbsConversionState
+    def enter
+      unmount()
+    end
+
+    private
+
+    def unmount()
+      @logger.debug "unmount #{@context[:path]}"
+      @context[:remote_command_handler].umount(@context[:path])
+      sleep(2) #give umount some time
+      if @context[:remote_command_handler].drive_mounted?(@context[:path])
+        raise Exception.new("drive #{@context[:path]} not unmounted")
+      end
+      VolumeUnmounted.new(@context)
+    end
+  end
+
+  # Volume unmounted. Detach it.
+  class VolumeUnmounted < Ami2EbsConversionState
+    def enter
+      detach()
+    end
+
+    private
+
+    def detach()
+      @logger.debug "detach volume #{@context[:volume_id]}"
+      @context[:ec2_api_handler].detach_volume(:volume_id => @context[:volume_id],
+        :instance_id => @context[:instance_id]
+      )
+      done = false
+      while !done
+        sleep(3)
+        #TODO: check for timeout?
+        res = @context[:ec2_api_handler].describe_volumes(:volume_id => @context[:volume_id])
+        @logger.debug "volume detaching: #{res.inspect}"
+        if res['volumeSet']['item'][0]['status'] == 'available'
+          done = true
+        end
+      end
+      VolumeDetached.new(@context)
+    end
+  end
+
+
+  # VolumeDetached. Create snaphot
+  class VolumeDetached < Ami2EbsConversionState
+    def enter
+      create_snapshot()
+    end
+
+    private
+
+    def create_snapshot()
+      @logger.debug "create snapshot for volume #{@context[:volume_id]}"
+      res = @context[:ec2_api_handler].create_snapshot(:volume_id => @context[:volume_id])
+      @context[:snapshot_id] = res['snapshotId']
+      @logger.info "snapshot_id = #{@context[:snapshot_id]}"
+      done = false
+      while !done
+        sleep(5)
+        #TODO: check for timeout?
+        res = @context[:ec2_api_handler].describe_snapshots(:snapshot_id => @context[:snapshot_id])
+        @logger.debug "snapshot creating: #{res.inspect}"
+        if res['snapshotSet']['item'][0]['status'] == 'completed'
+          done = true
+        end
+      end
+      SnapshotCreated.new(@context)      
+    end
+  end
+
+  # Snapshot created. Delete volume.
+  class SnapshotCreated < Ami2EbsConversionState
+    def enter
+      delete_volume()
+    end
+
+    private
+
+    def delete_volume
+      @logger.debug "delete volume #{@context[:volume_id]}"
+      res = @context[:ec2_api_handler].delete_volume(:volume_id => @context[:volume_id])
+      VolumeDeleted.new(@context)
+    end
+  end
+
+  # Volume deleted. Register snapshot.
+  class VolumeDeleted < Ami2EbsConversionState
+    def enter
+      register()
+    end
+
+    private
+
+    def register()
+      @logger.debug "register snapshot #{@context[:snapshot_id]} as #{@context[:name]}"
+      res = @context[:ec2_api_handler].register_image_updated(:snapshot_id => @context[:snapshot_id],
+        :kernel_id => @context[:kernel_id], :architecture => @context[:architecture], 
+        :root_device_name => @context[:root_device_name],
+        :description => @context[:description], :name => @context[:name],
+        :ramdisk_id => @context[:ramdisk_id]
+      )
+      @logger.debug "result of registration = #{res.inspect}"
+      @context[:image_id] = res['imageId']
+      @logger.info "resulting image_id = #{@context[:image_id]}"
+      SnapshotRegistered.new(@context)
+    end
+  end
+
+  # Snapshot registered. Shutdown instance.
+  class SnapshotRegistered < Ami2EbsConversionState
+    def enter
+      shut_down()
+    end
+
+    private
+
+    def shut_down()
+      @logger.debug "shutdown instance #{@context[:instance_id]}"
+      res = @context[:ec2_api_handler].terminate_instances(:instance_id => @context[:instance_id])
+      done = false
+      while done == false
+        sleep(5)
+        res = @context[:ec2_api_handler].describe_instances(:instance_id => @context[:instance_id])
+        state = res['reservationSet']['item'][0]['instancesSet']['item'][0]['instanceState']
+        @logger.debug "instance in state #{state['name']} (#{state['code']})"
+        if state['code'].to_i == 48
+          done = true
+        elsif state['code'].to_i != 32
+          raise Exception.new('instance failed to shut down')
+        end
+      end
+      Done.new(@context)      
+    end
+  end
+
+  # Instance shutdown. Done.
+  class Done < Ami2EbsConversionState
+    def done?
+      true
+    end
+  end
+  
+end

data/lib/scripts/ec2/dm_encrypt.rb

@@ -54,8 +54,8 @@ class DmEncrypt < Ec2Script
         @result[:failed] = false
       end
     rescue Exception => e
-      puts "exception during encryption: #{e}"
-      puts e.backtrace.join("\n")
+      @logger.warn "exception during encryption: #{e}"
+      @logger.info e.backtrace.join("\n")
       err = e.to_s
       err += " (in #{current_state.end_state.to_s})" unless current_state == nil
       @result[:failed] = true
@@ -65,7 +65,6 @@ class DmEncrypt < Ec2Script
       begin
       @input_params[:remote_command_handler].disconnect
       rescue Exception => e2
-        puts "rescue disconnect: #{e2}"
       end
     end
 
@@ -99,9 +98,9 @@ class DmEncrypt < Ec2Script
     private
 
     def connect()
-      puts "InitialState.connect"
+      @logger.debug "InitialState.connect"
       if @context[:ssh_key_file] != nil
-        @context[:remote_command_handler].connect(@context[:ip_address], @context[:ssh_key_file])
+        @context[:remote_command_handler].connect_with_keyfile(@context[:ip_address], @context[:ssh_key_file])
       elsif @context[:ssh_key_data] != nil
         @context[:remote_command_handler].connect(@context[:ip_address], "root", @context[:ssh_key_data])
       else
@@ -119,12 +118,12 @@ class DmEncrypt < Ec2Script
 
     private
     def install_tools
-      puts "ConnectedState.install_tools"
+      @logger.debug "ConnectedState.install_tools"
       if !tools_installed?
         @context[:remote_command_handler].install("dm-crypt") #TODO: constant somewhere? admin parameter?
       end
       if tools_installed?
-        puts "system says that tools are installed"
+        @logger.debug "system says that tools are installed"
         ToolInstalledState.new(@context)
       else
         FailedState.new(@context, "Installation of Tools failed", ConnectedState.new(@context))
@@ -148,7 +147,7 @@ class DmEncrypt < Ec2Script
 
     private
     def create_encrypted_volume
-      puts "ToolInstalledState.create_encrypted_volume"
+      @logger.debug "ToolInstalledState.create_encrypted_volume"
       #first check if the drive is not yet mounted by someone else
       if @context[:remote_command_handler].drive_mounted?(@context[:storage_path])
         if !@context[:remote_command_handler].drive_mounted_as?(calc_device_name(), @context[:storage_path])
@@ -176,7 +175,7 @@ class DmEncrypt < Ec2Script
 
     private
     def mount_and_activate
-      puts "VolumeCreatedState.mount_and_activate"
+      @logger.debug "VolumeCreatedState.mount_and_activate"
       @context[:remote_command_handler].activate_encrypted_volume(@context[:device_name],@context[:storage_path])
       MountedAndActivatedState.new(@context)
     end
@@ -190,7 +189,7 @@ class DmEncrypt < Ec2Script
 
     private
     def cleanup()
-      puts "MountedAndActivatedState.cleanup"
+      @logger.debug "MountedAndActivatedState.cleanup"
       @context[:remote_command_handler].disconnect()
       DoneState.new(@context)
     end

data/lib/scripts/ec2/ec2_script.rb

@@ -4,16 +4,25 @@ class Ec2Script
   # * aws_access_key => the Amazon AWS Access Key (see Your Account -> Security Credentials)
   # * aws_secret_key => the Amazon AWS Secret Key
   # * ec2_api_server => the API Server to connect to (optional, default is us-east-1 (=> <ec2_api_server>.ec2.amazonaws.com)
+  # * logger => allows to pass a ruby logger object used for logging (optional, default is a stdout logger with level WARN)
   # Scripts may add specific key/value pairs.
   def initialize(input_params)
     @input_params = input_params
     @state_change_listeners = []
+    if input_params[:logger] == nil
+      @logger = Logger.new(STDOUT)
+      @logger .level = Logger::WARN
+      input_params[:logger] = @logger
+    end
   end
 
   def register_state_change_listener(listener)
     @state_change_listeners << listener
   end
 
+  def start_script
+    raise Exception.new("must be implemented")
+  end
 
   # Return a hash of results. Common values are:
   # * :done => is true when the script has terminated, otherwise false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: CloudyScripts
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Matthias Jung
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-05 00:00:00 +01:00
+date: 2010-01-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,7 @@ files:
 - lib/help/remote_command_handler.rb
 - lib/help/script_execution_state.rb
 - lib/help/state_change_listener.rb
+- lib/scripts/ec2/ami2_ebs_conversion.rb
 - lib/scripts/ec2/dm_encrypt.rb
 - lib/scripts/ec2/ec2_script.rb
 has_rdoc: true