CloudyScripts 0.0.13 → 0.0.14

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Matthias Jung
+Copyright (c) 2010 SecludIT (http://secludit.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/Rakefile

@@ -12,7 +12,7 @@ require 'rake/testtask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'CloudyScripts'
-  s.version = '0.0.13'
+  s.version = '0.0.14'
   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

@@ -51,4 +51,12 @@ class Ec2Helper
     }
     return false
   end
+
+  def volume_prop(volume_id, prop)
+    vols = @ec2_api.describe_volumes(:volume_id => volume_id)
+    if vols['volumeSet']['item'].size == 0
+      raise Exception.new("volume #{volume_id} not found")
+    end
+    return vols['volumeSet']['item'][0][prop.to_s]
+  end
 end

data/lib/help/remote_command_handler.rb

@@ -12,8 +12,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)
-    @ssh_session = Net::SSH.start(ip, 'root', :keys => [keyfile])
+  def connect_with_keyfile(ip, keyfile, timeout = 30)
+    @ssh_session = Net::SSH.start(ip, 'root', {:keys => [keyfile], :timeout => timeout})
   end
 
   # Connect to the machine as root using keydata from a keyfile.
@@ -21,8 +21,8 @@ class RemoteCommandHandler
   # * ip: ip address of the machine to connect to
   # * user: user name
   # * key_data: key_data to be used for authentication
-  def connect(ip, user, key_data)
-    @ssh_session = Net::SSH.start(ip, user, :key_data => [key_data])
+  def connect(ip, user, key_data, timeout = 30)
+    @ssh_session = Net::SSH.start(ip, user, {:key_data => [key_data], :timeout => timeout})
   end
 
   # Disconnect the current handler
@@ -115,7 +115,7 @@ class RemoteCommandHandler
   # Zip the complete contents of the source path into the destination file.
   def zip(source_path, destination_file)
     begin
-      exec = "cd #{source_path}; zip #{destination_file} *"
+      exec = "cd #{source_path}; zip -ry #{destination_file} *"
       remote_execute(exec, nil, true)
     rescue Exception => e
       raise Exception.new("zip failed due to #{e.message}")

data/lib/help/state_transition_helper.rb

@@ -1,37 +1,39 @@
 # 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.
-# Parameters are read from the @context variable that must be defined. Results
-# are written into @context[:result][...]
-# Note: @context[:script] is set to a script object to pass information and messages
-# to listeners
+# 
+# Note: it is supposed that a hash named @context exists @context[:script]
+# must be set to a script object to pass information and messages
+# to listeners.
+# Some other information is expected to be provided in the @context object:
+# * :remote_command_handler => ssh wrapper object
+# * :ec2_api_handler => wrapper object around EC2 API access
 
 module StateTransitionHelper
 
   # Connects to the remote host via SSH.
-  # Params in @context:
-  # * :dns_name => machine to connect to
-  # * :ssh_keyfile => key-file used for ssh OR :ssh_keydata => contents of key-file
-  # * :remote_command_handler => ssh wrapper object
-  def connect
-    @context[:script].post_message("connecting to #{@context[:dns_name]}...")
-    if @context[:remote_command_handler] == nil
-      @context[:remote_command_handler] = RemoteCommandHandler.new
-    end
+  # Params:
+  # * dns_name => machine to connect to
+  # * 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)
+    post_message("connecting to #{dns_name}...")
     connected = false
     remaining_trials = 3
     while !connected && remaining_trials > 0
       remaining_trials -= 1
-      if @context[:ssh_keyfile] != nil
+      if ssh_keyfile != nil
         begin
-          @context[:remote_command_handler].connect_with_keyfile(@context[:dns_name], @context[:ssh_keyfile])
+          remote_handler().connect_with_keyfile(dns_name, ssh_keyfile)
           connected = true
         rescue Exception => e
           @logger.info("connection failed due to #{e}")
           @logger.debug(e.backtrace.join("\n"))
         end
-      elsif @context[:ssh_keydata] != nil
+      elsif ssh_keydata != nil
         begin
-          @context[:remote_command_handler].connect(@context[:dns_name], "root", @context[:ssh_keydata])
+          remote_handler().connect(dns_name, "root", ssh_keydata)
           connected = true
         rescue Exception => e
           @logger.info("connection failed due to #{e}")
@@ -47,82 +49,81 @@ module StateTransitionHelper
     if !connected
       raise Exception.new("connection attempts stopped")
     end
-    @context[:result][:os] = @context[:remote_command_handler].retrieve_os()
-    @context[:script].post_message("connected to #{@context[:dns_name]}. OS installed is #{@context[:result][:os]}")
-    @logger.info "connected to #{@context[:dns_name]}"
+    os = remote_handler().retrieve_os()
+    post_message("connected to #{dns_name}. OS installed is #{os}")
+    @logger.info "connected to #{dns_name}"
+    return os
   end
 
   # Launch an instance based on an AMI ID
-  # Input Parameters in @context:
-  # * :ami_id => ID of the AMI to be launched
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  # * :key_name => name of the key to access the instance
-  # * :security_group_name => name of the security group to be used
-  # Output information set by this method in @context:
-  # * :instance_id => ID of the started instance
-  # * :dns_name => DNS name of the started instance
-  # * :availability_zone => Availability zone of the started instance
-  # * :kernel_id => EC2 Kernel ID of the started instance
-  # * :ramdisk_id => EC2 Ramdisk ID of the started instance
-  # * :architecture => architecture (e.g. 386i, 64x) of the started instance
-  def launch_instance
-    @context[:script].post_message("starting up instance to execute the script (AMI = #{@context[:ami_id]}) ...")
-    @logger.debug "start up AMI #{@context[:ami_id]}"
+  # Input Parameters:
+  # * ami_id => ID of the AMI to be launched
+  # * key_name => name of the key to access the instance
+  # * security_group_name => name of the security group to be used
+  # Returned information:
+  # * instance_id => ID of the started instance
+  # * dns_name => DNS name of the started instance
+  # * availability_zone => Availability zone of the started instance
+  # * kernel_id => EC2 Kernel ID of the started instance
+  # * ramdisk_id => EC2 Ramdisk ID of the started instance
+  # * architecture => architecture (e.g. 386i, 64x) of the started instance
+  def launch_instance(ami_id, key_name, security_group_name)
+    post_message("starting up instance to execute the script (AMI = #{ami_id}) ...")
+    @logger.debug "start up AMI #{ami_id}"
     # find out the image architecture first
-    image_props = @context[:ec2_api_handler].describe_images(:image_id => @context[:ami_id])
+    image_props = ec2_handler().describe_images(:image_id => ami_id)
     architecture = image_props['imagesSet']['item'][0]['architecture']
     instance_type = "m1.small"
     if architecture != "i386"
       instance_type = "m1.large"
     end
-    arch_log_msg = "Architecture of image #{@context[:ami_id]} is #{architecture}. Use instance_type #{instance_type}."
+    arch_log_msg = "Architecture of image #{ami_id} is #{architecture}. Use instance_type #{instance_type}."
     @logger.info arch_log_msg
-    @context[:script].post_message(arch_log_msg)
+    post_message(arch_log_msg)
     # now start it
-    res = @context[:ec2_api_handler].run_instances(:image_id => @context[:ami_id],
-      :security_group => @context[:security_group_name], :key_name => @context[:key_name],
+    res = ec2_handler().run_instances(:image_id => ami_id,
+      :security_group => security_group_name, :key_name => key_name,
       :instance_type => instance_type
     )
     instance_id = res['instancesSet']['item'][0]['instanceId']
-    @context[:instance_id] = instance_id
     @logger.info "started instance #{instance_id}"
-    @context[:script].post_message("Started instance #{instance_id}. wait until it is ready...")
+    post_message("Started instance #{instance_id}. wait until it is ready...")
     #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])
+      res = ec2_handler().describe_instances(:instance_id => instance_id)
       state = res['reservationSet']['item'][0]['instancesSet']['item'][0]['instanceState']
       @logger.info "instance is in state #{state['name']} (#{state['code']})"
       if state['code'].to_i == 16
         started = true
-        @context[:script].post_message("instance is up and running")
-        @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']
+        post_message("instance is up and running")
+        dns_name = res['reservationSet']['item'][0]['instancesSet']['item'][0]['dnsName']
+        availability_zone = res['reservationSet']['item'][0]['instancesSet']['item'][0]['placement']['availabilityZone']
+        kernel_id = res['reservationSet']['item'][0]['instancesSet']['item'][0]['kernelId']
+        ramdisk_id = res['reservationSet']['item'][0]['instancesSet']['item'][0]['ramdiskId']
+        architecture = res['reservationSet']['item'][0]['instancesSet']['item'][0]['architecture']
       elsif state['code'].to_i != 0
-        @context[:script].post_message("instance in state #{state['name']}")
+        post_message("instance in state #{state['name']}")
         raise Exception.new('instance failed to start up')
       else
-        @context[:script].post_message("instance still starting up...")
+        post_message("instance still starting up...")
       end
     end
+    return instance_id, dns_name, availability_zone, kernel_id, ramdisk_id, architecture
   end
 
   # Shuts down an instance.
-  # Input Parameters in @context:
-  # * :instance_id => ID of the instance to be shut down
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  def shut_down_instance()
-    @context[:script].post_message("going to shut down the temporary instance #{@context[:instance_id]}...")
-    @logger.debug "shutdown instance #{@context[:instance_id]}"
-    res = @context[:ec2_api_handler].terminate_instances(:instance_id => @context[:instance_id])
+  # Input Parameters:
+  # * instance_id => ID of the instance to be shut down
+  def shut_down_instance(instance_id)
+    post_message("going to shut down the temporary instance #{instance_id}...")
+    @logger.debug "shutdown instance #{instance_id}"
+    res = ec2_handler().terminate_instances(:instance_id => instance_id)
     done = false
     while done == false
       sleep(5)
-      res = @context[:ec2_api_handler].describe_instances(:instance_id => @context[:instance_id])
+      res = ec2_handler().describe_instances(:instance_id => 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
@@ -131,245 +132,267 @@ module StateTransitionHelper
         raise Exception.new('instance failed to shut down')
       end
     end
-    @context[:script].post_message("instance #{@context[:instance_id]} is terminated")
+    post_message("instance #{instance_id} is terminated")
   end
 
   # Creates a new EBS volume.
-  # Input Parameters in @context:
-  # * :availability_zone => availability zone for the volume
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  # Output information set by this method in @context:
-  # * :volume_id => EC2 EBS Volume ID
-  def create_volume()
-    @context[:script].post_message("going to create a new EBS volume...")
-    @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']
+  # Input Parameters:
+  # * availability_zone => availability zone for the volume
+  # * size => size in Gigabytes
+  # Returns
+  # * volume_id => EC2 EBS Volume ID
+  def create_volume(availability_zone, size = "10")
+    post_message("going to create a new EBS volume of size #{size}GB...")
+    @logger.debug "create volume in zone #{availability_zone}"
+    res = ec2_handler().create_volume(:availability_zone => availability_zone, :size => size.to_s)
+    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])
+      res = ec2_handler().describe_volumes(:volume_id => volume_id)
       state = res['volumeSet']['item'][0]['status']
       @logger.debug "volume state #{state}"
       if state == 'available'
         started = true
       end
     end
-    @context[:script].post_message("EBS volume #{@context[:volume_id]} is ready")
+    post_message("EBS volume #{volume_id} is ready")
+    return volume_id
   end
 
   # Creates a new EBS volume from a snapshot ID.
-  # Input Parameters in @context:
-  # * :availability_zone => availability zone for the volume
-  # * :snapshot_id => EC2 Snapshot ID used to create the volume
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  # Output information set by this method in @context:
-  # * :volume_id => EC2 EBS Volume ID created
-  def create_volume_from_snapshot
-    @context[:script].post_message("going to create a new EBS volume from the specified snapshot...")
-    @logger.debug "create volume in zone #{@context[:availability_zone]}"
-    res = @context[:ec2_api_handler].create_volume(:snapshot_id => @context[:snapshot_id], :availability_zone => @context[:availability_zone], :size => "10")
-    @context[:volume_id] = res['volumeId']
+  # Input Parameters:
+  # * availability_zone => availability zone for the volume
+  # * size => size of the volume to be created
+  # * snapshot_id => EC2 Snapshot ID used to create the volume
+  # Returns
+  # * volume_id => EC2 EBS Volume ID created
+  def create_volume_from_snapshot(snapshot_id, availability_zone)
+    post_message("going to create a new EBS volume from the specified snapshot...")
+    @logger.debug "create volume in zone #{availability_zone}"
+    res = ec2_handler().create_volume(:snapshot_id => snapshot_id, :availability_zone => availability_zone)
+    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])
+      res = ec2_handler().describe_volumes(:volume_id => volume_id)
       state = res['volumeSet']['item'][0]['status']
       @logger.debug "volume state #{state}"
       if state == 'available'
         started = true
       end
     end
-    @context[:script].post_message("EBS volume #{@context[:volume_id]} is ready")
+    post_message("EBS volume #{volume_id} is ready")
+    return volume_id
   end
 
   # Attaches an EBS volume to an instance
-  # Input Parameters in @context:
-  # * :volume_id => EC2 ID for the EBS Volume to be attached
-  # * :instance_id => EC2 ID for the instance to which the volume is supposed to be attached to
-  # * :temp_device_name => device name to be used for attaching (e.g. /dev/sdj1)
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  def attach_volume
-    @context[:script].post_message("going to attach volume #{@context[:volume_id]} to instance #{@context[:instance_id]} on device #{@context[:temp_device_name]}...")
-    @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]
+  # Input Parameters:
+  # * volume_id => EC2 ID for the EBS Volume to be attached
+  # * instance_id => EC2 ID for the instance to which the volume is supposed to be attached to
+  # * temp_device_name => device name to be used for attaching (e.g. /dev/sdj1)
+  def attach_volume(volume_id, instance_id, temp_device_name)
+    post_message("going to attach volume #{volume_id} to instance #{instance_id} on device #{temp_device_name}...")
+    @logger.debug "attach volume #{volume_id} to instance #{instance_id} on device #{temp_device_name}"
+    ec2_handler().attach_volume(:volume_id => volume_id,
+      :instance_id => instance_id,
+      :device => 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])
+      res = ec2_handler().describe_volumes(:volume_id => volume_id)
       state = res['volumeSet']['item'][0]['status']
       @logger.debug "storage attaching: #{state}"
       if  state == 'in-use'
         done = true
       end
     end
-    @context[:script].post_message("volume successfully attached")
+    post_message("volume successfully attached")
   end
 
   # Detach an EBS volume from an instance.
-  # Input Parameters in @context:
-  # * :volume_id => EC2 ID for the EBS Volume to be detached
-  # * :instance_id => EC2 ID for the instance to detach from
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  def detach_volume()
-    @context[:script].post_message("going to detach volume #{@context[:volume_id]}...")
-    @logger.debug "detach volume #{@context[:volume_id]}"
-    @context[:ec2_api_handler].detach_volume(:volume_id => @context[:volume_id],
-      :instance_id => @context[:instance_id]
+  # Input Parameters:
+  # * volume_id => EC2 ID for the EBS Volume to be detached
+  # * instance_id => EC2 ID for the instance to detach from
+  def detach_volume(volume_id, instance_id)
+    post_message("going to detach volume #{volume_id}...")
+    @logger.debug "detach volume #{volume_id}"
+    ec2_handler().detach_volume(:volume_id => volume_id,
+      :instance_id => instance_id
     )
     done = false
     while !done
       sleep(3)
       #TODO: check for timeout?
-      res = @context[:ec2_api_handler].describe_volumes(:volume_id => @context[:volume_id])
+      res = ec2_handler().describe_volumes(:volume_id => volume_id)
       @logger.debug "volume detaching: #{res.inspect}"
       if res['volumeSet']['item'][0]['status'] == 'available'
         done = true
       end
     end
-    @context[:script].post_message("volume #{@context[:volume_id]} detached.")
+    post_message("volume #{volume_id} detached.")
   end
 
   # Delete an EBS volume.
-  # Input Parameters in @context:
-  # * :volume_id => EC2 ID for the EBS Volume to be deleted
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  def delete_volume
-    @context[:script].post_message("going to delete volume #{@context[:volume_id]} (no longer needed)...")
-    @logger.debug "delete volume #{@context[:volume_id]}"
-    @context[:ec2_api_handler].delete_volume(:volume_id => @context[:volume_id])
-    @context[:script].post_message("volume #{@context[:volume_id]} deleted")
+  # Input Parameters:
+  # * volume_id => EC2 ID for the EBS Volume to be deleted
+  def delete_volume(volume_id)
+    post_message("going to delete volume #{volume_id} (no longer needed)...")
+    @logger.debug "delete volume #{volume_id}"
+    ec2_handler().delete_volume(:volume_id => volume_id)
+    post_message("volume #{volume_id} deleted")
   end
 
   # Creates a snapshot for an EBS volume.
-  # Input Parameters in @context:
-  # * :volume_id => EC2 ID for the EBS volume to be snapshotted
-  # * :snapshot_id => EC2 Snapshot ID used to create the volume
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  # Output information set by this method in @context:
-  # * :snapshot_id => EC2 ID for the snapshot created
-  def create_snapshot()
-    @context[:script].post_message("going to create a 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]}"
+  # Input Parameters::
+  # * volume_id => EC2 ID for the EBS volume to be snapshotted
+  # Returns:
+  # * snapshot_id => EC2 ID for the snapshot created
+  def create_snapshot(volume_id)
+    post_message("going to create a snapshot for volume #{volume_id}...")
+    @logger.debug "create snapshot for volume #{volume_id}"
+    res = ec2_handler().create_snapshot(:volume_id => volume_id)
+    snapshot_id = res['snapshotId']
+    @logger.info "snapshot_id = #{snapshot_id}"
     done = false
     while !done
       sleep(5)
       #TODO: check for timeout?
-      res = @context[:ec2_api_handler].describe_snapshots(:snapshot_id => @context[:snapshot_id])
+      res = ec2_handler().describe_snapshots(:snapshot_id => snapshot_id)
       @logger.debug "snapshot creating: #{res.inspect}"
       if res['snapshotSet']['item'][0]['status'] == 'completed'
         done = true
       end
     end
-    @context[:script].post_message("snapshot is done with ID=#{@context[:snapshot_id]}")
+    post_message("snapshot is done with ID=#{snapshot_id}")
+    return snapshot_id
   end
 
   # Registers a snapshot as EBS-booted AMI.
-  # Input Parameters in @context:
-  # * :snapshot_id => EC2 Snapshot ID used to be used
-  # * :name => name of the AMI to be created
-  # * :root_device_name => Root device name (e.g. /dev/sdj) to be used for AMI registration
-  # * :description => description of the AMI to be created
-  # * :kernel_id => EC2 Kernel ID to be used for AMI registration
-  # * :ramdisk_id => EC2 Ramdisk ID to be used for AMI registration
-  # * :architecture => architecture (e.g. 386i, 64x) to be used for AMI registration
-  # * :ec2_api_handler => wrapper object around EC2 API access
-  # Output information set by this method in @context:
-  # * {:result => :image_id} => ID of the AMI created and registered
-  def register_snapshot()
-    @context[:script].post_message("going to register snapshot #{@context[:snapshot_id]}...")
-    @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]
+  # Input Parameters:
+  # * snapshot_id => EC2 Snapshot ID used to be used
+  # * name => name of the AMI to be created
+  # * root_device_name => Root device name (e.g. /dev/sdj) to be used for AMI registration
+  # * description => description of the AMI to be created
+  # * kernel_id => EC2 Kernel ID to be used for AMI registration
+  # * ramdisk_id => EC2 Ramdisk ID to be used for AMI registration
+  # * architecture => architecture (e.g. 386i, 64x) to be used for AMI registration
+  # Returns:
+  # * image_id => ID of the AMI created and registered
+  def register_snapshot(snapshot_id, name, root_device_name, description, kernel_id, ramdisk_id, architecture)
+    post_message("going to register snapshot #{snapshot_id}...")
+    @logger.debug "register snapshot #{snapshot_id} as #{name}"
+    res = ec2_handler().register_image_updated(:snapshot_id => snapshot_id,
+      :kernel_id => kernel_id, :architecture => architecture,
+      :root_device_name => root_device_name,
+      :description => description, :name => name,
+      :ramdisk_id => ramdisk_id
     )
     @logger.debug "result of registration = #{res.inspect}"
-    @context[:result][:image_id] = res['imageId']
-    @logger.info "resulting image_id = #{@context[:result][:image_id]}"
-    @context[:script].post_message("snapshot #{@context[:snapshot_id]} successfully registered as AMI #{@context[:result][:image_id]} ")
+    image_id = res['imageId']
+    @logger.info "resulting image_id = #{image_id}"
+    post_message("snapshot #{snapshot_id} successfully registered as AMI #{image_id} ")
+    return image_id
   end
 
   # Create a file-system on a given machine (assumes to be connected already).
-  # Input Parameters in @context:
-  # * :dns_name => IP used
-  # * :temp_device_name => device name to be used #TODO: give it a better name
-  # * :remote_command_handler => ssh wrapper object
-  def create_fs()
-    @context[:script].post_message("going to create filesystem on #{@context[:dns_name]} to #{@context[:temp_device_name]}...")
-    @logger.debug "create filesystem on #{@context[:dns_name]} to #{@context[:temp_device_name]}"
-    @context[:remote_command_handler].create_filesystem("ext3", @context[:temp_device_name])
-    @context[:script].post_message("filesystem system successfully created")
+  # Input Parameters:
+  # * dns_name => IP used
+  # * device => device to be used for file-system creation (e.g. /dev/sdj)
+  def create_fs(dns_name, device)
+    post_message("going to create filesystem on #{dns_name} to #{device}...")
+    @logger.debug "create filesystem on #{dns_name} to #{device}"
+    remote_handler().create_filesystem("ext3", device)
+    post_message("filesystem system successfully created")
   end
 
   # Create a file-system on a given machine (assumes to be connected already).
-  # Input Parameters in @context:
-  # * :path => mount point #TODO: give it a better name
-  # * :temp_device_name => device used for mounting #TODO: give it a better name
-  # * :remote_command_handler => ssh wrapper object
-  def mount_fs()
-    @context[:path] = "/mnt/tmp_#{@context[:volume_id]}"
-    @context[:script].post_message("going to mount #{@context[:temp_device_name]} on #{@context[:path]}...")
-    @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")
+  # Input Parameters:
+  # * mount_point => directory to be mounted on the device
+  # * device => device used for mounting
+  def mount_fs(mount_point, device)
+    post_message("going to mount #{device} on #{mount_point}...")
+    @logger.debug "mount #{device} on #{mount_point}"
+    if !remote_handler.file_exists?(mount_point)
+      remote_handler().mkdir(mount_point)
+    end
+    remote_handler().mount(device, mount_point)
+    trials = 3
+    mounted = false
+    while trials > 0
+      sleep(5) #give mount some time
+      if remote_handler().drive_mounted?(mount_point)
+        mounted = true
+        break
+      end
+      trials -= trials
     end
-    @context[:script].post_message("mount successful")
+    if !mounted
+      raise Exception.new("drive #{mount_point} not mounted")
+    end
+    post_message("mount successful")
   end
 
   # Unmount a drive
-  # Input Parameters in @context:
-  # * :path => mount point #TODO: give it a better name
-  # * :remote_command_handler => ssh wrapper object
-  def unmount_fs()
-    @context[:script].post_message("Going to unmount ...")
-    @logger.debug "unmount #{@context[:path]}"
-    @context[:remote_command_handler].umount(@context[:path])
+  # Input Parameters:
+  # * mount_point => directory to be unmounted
+  def unmount_fs(mount_point)
+    post_message("Going to unmount ...")
+    @logger.debug "unmount #{mount_point}"
+    remote_handler().umount(mount_point)
     sleep(2) #give umount some time
-    if @context[:remote_command_handler].drive_mounted?(@context[:path])
-      raise Exception.new("drive #{@context[:path]} not unmounted")
+    if remote_handler().drive_mounted?(mount_point)
+      raise Exception.new("drive #{mount_point} not unmounted")
     end
-    @context[:script].post_message("device unmounted")
+    post_message("device unmounted")
   end
 
   # Copy all files of a running linux distribution via rsync to a mounted directory
-  # Input Parameters in @context:
-  # * :path => where to copy to
-  # * :remote_command_handler => ssh wrapper object
-  def copy()
-    @context[:script].post_message("going to start copying files to #{@context[:path]}. This may take quite a time...")
-    @logger.debug "start copying to #{@context[:path]}"
+  # Input Parameters:
+  # * destination_path => where to copy to
+  def copy_distribution(destination_path)
+    post_message("going to start copying files to #{destination_path}. This may take quite a time...")
+    @logger.debug "start copying to #{destination_path}"
     start = Time.new.to_i
-    @context[:remote_command_handler].rsync("/", "#{@context[:path]}", "#{@context[:path]}")
-    @context[:remote_command_handler].rsync("/dev/", "#{@context[:path]}/dev/")
+    remote_handler().rsync("/", "#{destination_path}", "#{destination_path}")
+    remote_handler().rsync("/dev/", "#{destination_path}/dev/")
     endtime = Time.new.to_i
     @logger.info "copy took #{(endtime-start)}s"
-    @context[:script].post_message("copying is done (took #{endtime-start})s")
+    post_message("copying is done (took #{endtime-start})s")
   end
 
   # Zips all files on a mounted-directory into a file
-  # Input Parameters in @context:
-  # * :path => where to copy from
-  # * :zip_file_dest => path where the zip-file should be stored
-  # # :zip_file_name => name of the zip file (without .zip suffix)
-  # * :remote_command_handler => ssh wrapper object
-  def zip_volume
-    @context[:script].post_message("going to zip the EBS volume")
-    @context[:remote_command_handler].zip(@context[:path], @context[:zip_file_dest]+@context[:zip_file_name])
-    @context[:script].post_message("EBS volume successfully zipped")
+  # Input Parameters:
+  # * source_dir => where to copy from
+  # * zip_file_dest => path where the zip-file should be stored
+  # # zip_file_name => name of the zip file (without .zip suffix)
+  def zip_volume(source_dir, zip_file_dest, zip_file_name)
+    post_message("going to zip the EBS volume")
+    remote_handler().zip(source_dir, zip_file_dest+"/"+zip_file_name)
+    post_message("EBS volume successfully zipped")
+  end
+
+  protected
+
+  def post_message(msg)
+    if @context[:script] != nil
+      @context[:script].post_message(msg)
+    end
+  end
+
+  def remote_handler()
+    if @context[:remote_command_handler] == nil
+      @context[:remote_command_handler] = RemoteCommandHandler.new
+    end
+    @context[:remote_command_handler]
+  end
+
+  def ec2_handler()
+    @context[:ec2_api_handler]
   end
 
 end

data/lib/scripts/ec2/ami2_ebs_conversion.rb

@@ -76,7 +76,9 @@ class Ami2EbsConversion < Ec2Script
   # which serves to create 
   class InitialState < Ami2EbsConversionState
     def enter
-      launch_instance()
+      @context[:instance_id], @context[:dns_name], @context[:availability_zone], 
+        @context[:kernel_id], @context[:ramdisk_id], @context[:architecture] =
+        launch_instance(@context[:ami_id], @context[:key_name], @context[:security_group_name])
       AmiStarted.new(@context)
     end
   end
@@ -84,7 +86,7 @@ class Ami2EbsConversion < Ec2Script
   # Ami started. Create a storage
   class AmiStarted < Ami2EbsConversionState
     def enter
-      create_volume()
+      @context[:volume_id] = create_volume(@context[:availability_zone], "10")
       StorageCreated.new(@context)
     end
   end
@@ -92,7 +94,7 @@ class Ami2EbsConversion < Ec2Script
   # Storage created. Attach it.
   class StorageCreated < Ami2EbsConversionState
     def enter
-      attach_volume()
+      attach_volume(@context[:volume_id], @context[:instance_id], @context[:temp_device_name])
       StorageAttached.new(@context)
     end
   end
@@ -100,8 +102,9 @@ class Ami2EbsConversion < Ec2Script
   # Storage attached. Create a file-system and moun it
   class StorageAttached < Ami2EbsConversionState
     def enter
-      connect()
-      create_fs()
+      @context[:result][:os] =
+        connect(@context[:dns_name], @context[:ssh_keyfile], @context[:ssh_keydata])
+      create_fs(@context[:dns_name], @context[:temp_device_name])
       FileSystemCreated.new(@context)
     end
   end
@@ -109,7 +112,8 @@ class Ami2EbsConversion < Ec2Script
   # File system created. Mount it.
   class FileSystemCreated < Ami2EbsConversionState
     def enter
-      mount_fs()
+      @context[:mount_dir] = "/mnt/tmp_#{@context[:volume_id]}"
+      mount_fs(@context[:mount_dir], @context[:temp_device_name])
       FileSystemMounted.new(@context)
     end
   end
@@ -117,7 +121,7 @@ class Ami2EbsConversion < Ec2Script
   # File system created and mounted. Copy the root partition.
   class FileSystemMounted < Ami2EbsConversionState
     def enter
-      copy()
+      copy_distribution(@context[:mount_dir])
       CopyDone.new(@context)
     end
   end
@@ -125,7 +129,7 @@ class Ami2EbsConversion < Ec2Script
   # Copy operation done. Unmount volume.
   class CopyDone < Ami2EbsConversionState
     def enter
-      unmount_fs()
+      unmount_fs(@context[:mount_dir])
       VolumeUnmounted.new(@context)
     end
   end
@@ -133,7 +137,7 @@ class Ami2EbsConversion < Ec2Script
   # Volume unmounted. Detach it.
   class VolumeUnmounted < Ami2EbsConversionState
     def enter
-      detach_volume()
+      detach_volume(@context[:volume_id], @context[:instance_id])
       VolumeDetached.new(@context)
     end
   end
@@ -141,7 +145,7 @@ class Ami2EbsConversion < Ec2Script
   # VolumeDetached. Create snaphot
   class VolumeDetached < Ami2EbsConversionState
     def enter
-      create_snapshot()
+      @context[:snapshot_id] = create_snapshot(@context[:volume_id])
       SnapshotCreated.new(@context)
     end
   end
@@ -149,7 +153,7 @@ class Ami2EbsConversion < Ec2Script
   # Snapshot created. Delete volume.
   class SnapshotCreated < Ami2EbsConversionState
     def enter
-      delete_volume()
+      delete_volume(@context[:volume_id])
       VolumeDeleted.new(@context)
     end
   end
@@ -157,7 +161,9 @@ class Ami2EbsConversion < Ec2Script
   # Volume deleted. Register snapshot.
   class VolumeDeleted < Ami2EbsConversionState
     def enter
-      register_snapshot()
+      @context[:result][:image_id] = register_snapshot(@context[:snapshot_id], @context[:name],
+        @context[:root_device_name], @context[:description], @context[:kernel_id],
+        @context[:ramdisk_id], @context[:architecture])
       SnapshotRegistered.new(@context)
     end
   end
@@ -165,7 +171,7 @@ class Ami2EbsConversion < Ec2Script
   # Snapshot registered. Shutdown instance.
   class SnapshotRegistered < Ami2EbsConversionState
     def enter
-      shut_down_instance()
+      shut_down_instance(@context[:instance_id])
       Done.new(@context)      
     end
   end

data/lib/scripts/ec2/dm_encrypt.rb

@@ -61,7 +61,8 @@ class DmEncrypt < Ec2Script
   # Starting state. Tries to connect via ssh.
   class InitialState < DmEncryptState
     def enter
-      connect()
+      @context[:result][:os] =
+        connect(@context[:dns_name], @context[:ssh_keyfile], @context[:ssh_keydata])
       install_tools()
     end
 

data/lib/scripts/ec2/download_snapshot.rb

@@ -2,6 +2,7 @@ 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"
 
 # Script to download a specific snapshot as ZIP
@@ -31,11 +32,14 @@ class DownloadSnapshot < Ec2Script
   end
 
   def check_input_parameters()
-    if @input_params[:temp_device_name] == nil
-      @input_params[:temp_device_name] = "/dev/sdj"
+    if @input_params[:source_device] == nil
+      @input_params[:source_device] = "/dev/sdj1"
+    end
+    if @input_params[:dest_device] == nil
+      @input_params[:dest_device] = "/dev/sdj2"
     end
     if @input_params[:zip_file_dest] == nil
-      @input_params[:zip_file_dest] = "/var/www/html/"
+      @input_params[:zip_file_dest] = "/var/www/html"
     end
     if @input_params[:zip_file_name] == nil
       @input_params[:zip_file_name] = "download"
@@ -61,11 +65,13 @@ class DownloadSnapshot < Ec2Script
     end
   end
 
-  #Connected.
   # Start state. First thing to do is to launch the instance.
   class InitialState < DownloadSnapshotState
     def enter
-      launch_instance()
+      result = launch_instance(@context[:ami_id], @context[:key_name], @context[:security_group_name])
+      @context[:instance_id] = result.first
+      @context[:dns_name] = result[1]
+      @context[:availability_zone] = result[2]
       InstanceLaunchedState.new(context)
     end
   end
@@ -73,42 +79,46 @@ class DownloadSnapshot < Ec2Script
   # Instance Launched. Create a volume based on the snapshot.
   class InstanceLaunchedState < DownloadSnapshotState
     def enter
-      create_volume_from_snapshot()
-      VolumeCreated.new(@context)
+      @context[:source_volume_id] = create_volume_from_snapshot(@context[:snapshot_id], @context[:availability_zone])
+      ec2_helper = Ec2Helper.new(@context[:ec2_api_handler])
+      size = ec2_helper.volume_prop(@context[:source_volume_id], :size).to_i
+      puts "retrieved volume size of #{size}"
+      @context[:dest_volume_id] = create_volume(@context[:availability_zone], size)
+      VolumesCreated.new(@context)
     end
 
   end
 
-  # Volume created. Attach it.
-  class VolumeCreated < DownloadSnapshotState
-    def enter
-      attach_volume()
-      VolumeAttached.new(@context)
-    end
-  end
-
-  # Volume attached. Create a file-system and mount it.
-  class VolumeAttached < DownloadSnapshotState
+  # Volumes created. Attach it.
+  class VolumesCreated < DownloadSnapshotState
     def enter
-      connect()
-      create_fs()
-      FileSystemCreated.new(@context)
+      @context[:script].post_message("Going to create two volumes. One with the snapshot data, one to store the zipped data for download.")
+      attach_volume(@context[:source_volume_id], @context[:instance_id], @context[:source_device])
+      attach_volume(@context[:dest_volume_id], @context[:instance_id], @context[:dest_device])
+      VolumesAttached.new(@context)
     end
   end
 
-  # File system created. Mount it.
-  class FileSystemCreated < DownloadSnapshotState
+  # Volumes attached. Create a file-system for the destination one, and mount both.
+  class VolumesAttached < DownloadSnapshotState
     def enter
-      mount_fs()
-      FileSystemMounted.new(@context)
+      @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])
+      source_dir = "/mnt/tmp_#{@context[:source_volume_id]}"
+      dest_dir = @context[:zip_file_dest]
+      create_fs(@context[:dns_name], @context[:dest_device])
+      mount_fs(source_dir, @context[:source_device])
+      mount_fs(dest_dir, @context[:dest_device])
+      FileSystemsReady.new(@context)
     end
-
   end
 
   # File System mounted. Zip the complete directory on the EBS.
-  class FileSystemMounted < DownloadSnapshotState
+  class FileSystemsReady < DownloadSnapshotState
     def enter
-      zip_volume()
+      mount_point = "/mnt/tmp_#{@context[:source_volume_id]}"
+      zip_volume(mount_point, @context[:zip_file_dest], @context[:zip_file_name])
       VolumeZippedAndDownloadableState.new(@context)
     end
 
@@ -136,7 +146,7 @@ class DownloadSnapshot < Ec2Script
   # Snapshot can no longer be downloaded. Shut down the instance.
   class DownloadStoppedState < DownloadSnapshotState
     def enter
-      shut_down_instance()
+      shut_down_instance(@context[:instance_id])
       InstanceShutDown.new(@context)
     end
     
@@ -145,7 +155,8 @@ class DownloadSnapshot < Ec2Script
   # Instance is shut down. Delete the volume created.
   class InstanceShutDown < DownloadSnapshotState
     def enter
-      delete_volume()
+      delete_volume(@context[:source_volume_id])
+      delete_volume(@context[:dest_volume_id])
       Done.new(@context)
     end
   end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: CloudyScripts
 version: !ruby/object:Gem::Version 
-  version: 0.0.13
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 14
+  version: 0.0.14
 platform: ruby
 authors: 
 - Matthias Jung
@@ -9,29 +14,33 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-17 00:00:00 +01:00
+date: 2010-03-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: amazon-ec2
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: net-ssh
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: Scripts to facilitate programming for infrastructure clouds.
 email: matthias.jung@gmail.com
 executables: []
@@ -70,18 +79,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: cloudyscripts
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Scripts to facilitate programming for infrastructure clouds.