CloudyScripts 0.0.11 → 0.0.12

data/lib/scripts/ec2/dm_encrypt.rb

@@ -1,206 +1,148 @@
-require "help/script_execution_state"
-require "scripts/ec2/ec2_script"
-require "help/remote_command_handler"
-require "help/dm_crypt_helper"
-require "AWS"
-
-# Script to Encrypt an EC2 Storage (aka Elastic Block Storage)
-# 
-class DmEncrypt < Ec2Script
-  # dependencies: tools that need to be installed to make things work
-  TOOLS = ["cryptsetup"]
-  # the parameters for which
-  CHECK = ["cryptsetup"]
-
-  # Input parameters
-  # * aws_access_key => the Amazon AWS Access Key (see Your Account -> Security Credentials)
-  # * aws_secret_key => the Amazon AWS Secret Key
-  # * ip_address => IP Address of the machine to connect to
-  # * ssh_key_file => Path of the keyfile used to connect to the machine (optional, otherwise: ssh_key_data)
-  # * ssh_key_data => Key information (optional, otherwise: ssh_key_file)
-  # * device => Path of the device to encrypt
-  # * device_name => Name of the Device to encrypt
-  # * storage_path => Path on which the encrypted device is mounted
-  # * paraphrase => paraphrase used for encryption
-  # * 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)
-  #
-
-  def initialize(input_params)
-    super(input_params)
-  end
-
-  # Executes the script.
-  def start_script
-    begin
-      # optional parameters and initialization
-      if @input_params[:ec2_api_server] == nil
-        @input_params[:ec2_api_server] = "us-east-1.ec2.amazonaws.com"
-      end
-      if @input_params[:remote_command_handler] == nil
-        @input_params[:remote_command_handler] = RemoteCommandHandler.new
-      end
-      if @input_params[:ec2_api_handler] == nil
-        @input_params[:ec2_api_handler] = AWS::EC2::Base.new(:access_key_id => @input_params[:aws_access_key],
-        :secret_access_key => @input_params[:aws_secret_key], :server => @input_params[:ec2_api_server])
-      end
-      @input_params[:script] = self
-      # start state machine
-      current_state = DmEncryptState.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.info 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 DmEncryptState < ScriptExecutionState
-
-    def self.load_state(context)
-      InitialState.new(context)
-    end
-  end
-
-  # Starting state. Tries to connect via ssh.
-  class InitialState < DmEncryptState
-    def enter
-      connect()
-    end
-
-    private
-
-    def connect()
-      @context[:script].post_message("going to connect to #{@context[:ip_address]}...")
-      @logger.debug "InitialState.connect"
-      if @context[:ssh_key_file] != nil
-        @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
-        raise Exception.new("no key information specified")
-      end
-      @context[:result][:os] = @context[:remote_command_handler].retrieve_os()
-      @context[:script].post_message("connection successful, OS = #{@context[:result][:os]}")
-      ConnectedState.new(@context)
-    end
-  end
-
-  # Connected via SSH. Tries to install dm-encrypt.#TODO: depends on OS
-  class ConnectedState < DmEncryptState
-    def enter
-      install_tools()
-    end
-
-    private
-    def install_tools
-      @context[:script].post_message("check if the system has the cryptset-package installed")
-      @logger.debug "ConnectedState.install_tools"
-      if !tools_installed?
-        @context[:script].post_message("cryptset-package not installed. Going to install it...")
-        TOOLS.each() {|tool|
-          @context[:remote_command_handler].install(tool)
-        }
-      end
-      if !@context[:remote_command_handler].remote_execute("modprobe dm_crypt")
-        raise Exception.new("dm-crypt module missing")
-      end
-      if tools_installed?
-        @context[:script].post_message("cryptset-package is available")
-        @logger.debug "system says that tools are installed"
-        ToolInstalledState.new(@context)
-      else
-        FailedState.new(@context, "Installation of Tools failed", ConnectedState.new(@context))
-      end
-    end
-
-    def tools_installed?
-      CHECK.each() {|tool|
-        if !@context[:remote_command_handler].tools_installed?(tool)
-          return false
-        end
-      }
-      true
-    end
-  end
-
-  # Connected and Tools installed. Start encryption.
-  class ToolInstalledState < DmEncryptState
-    def enter
-      create_encrypted_volume()
-    end
-
-    private
-    def create_encrypted_volume
-      @context[:script].post_message("going to encrypt device #{@context[:device]} "+
-        "named '#{@context[:device_name]}' and mount it as #{@context[:storage_path]}...")
-      @logger.debug "ToolInstalledState.create_encrypted_volume"
-      @context[:remote_command_handler].encrypt_storage(@context[:device_name],
-      @context[:paraphrase], @context[:device], @context[:storage_path])
-      @context[:script].post_message("device #{@context[:device]} is encrypted and mounted")
-      MountedAndActivatedState.new(@context)
-    end
-
-    def calc_device_name
-      dev = @context[:device_name].gsub(/[-]/,"--")
-      "/dev/mapper/vg--#{dev}-lv--#{dev}"
-    end
-
-  end
-
-  # The encrypted storages is mounted and activated. Cleanup and done.
-  class MountedAndActivatedState < DmEncryptState
-    def enter
-      cleanup()
-    end
-
-    private
-    def cleanup()
-      @context[:script].post_message("disconnecting...")
-      @logger.debug "MountedAndActivatedState.cleanup"
-      @context[:remote_command_handler].disconnect()
-      @context[:script].post_message("done")
-      DoneState.new(@context)
-    end
-
-  end
-
-  class DoneState < DmEncryptState
-    def done?
-      true
-    end
-  end
-
+require "help/script_execution_state"
+require "scripts/ec2/ec2_script"
+require "help/remote_command_handler"
+require "help/dm_crypt_helper"
+require "AWS"
+
+# Script to Encrypt an EC2 Storage (aka Elastic Block Storage)
+# 
+class DmEncrypt < Ec2Script
+  # dependencies: tools that need to be installed to make things work
+  TOOLS = ["cryptsetup"]
+  # the parameters for which
+  CHECK = ["cryptsetup"]
+
+  # Input parameters
+  # * aws_access_key => the Amazon AWS Access Key (see Your Account -> Security Credentials)
+  # * aws_secret_key => the Amazon AWS Secret Key
+  # * ip_address => IP Address of the machine to connect to
+  # * ssh_key_file => Path of the keyfile used to connect to the machine (optional, otherwise: ssh_key_data)
+  # * ssh_key_data => Key information (optional, otherwise: ssh_key_file)
+  # * device => Path of the device to encrypt
+  # * device_name => Name of the Device to encrypt
+  # * storage_path => Path on which the encrypted device is mounted
+  # * paraphrase => paraphrase used for encryption
+  # * 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)
+  #
+
+  def initialize(input_params)
+    super(input_params)
+  end
+
+  def check_input_parameters()
+    if @input_params[:ec2_api_server] == nil
+      @input_params[:ec2_api_server] = "us-east-1.ec2.amazonaws.com"
+    end
+    if @input_params[:remote_command_handler] == nil
+      @input_params[:remote_command_handler] = RemoteCommandHandler.new
+    end
+    if @input_params[:ec2_api_handler] == nil
+      @input_params[:ec2_api_handler] = AWS::EC2::Base.new(:access_key_id => @input_params[:aws_access_key],
+      :secret_access_key => @input_params[:aws_secret_key], :server => @input_params[:ec2_api_server])
+    end
+  end
+
+  def load_initial_state()
+    DmEncryptState.load_state(@input_params)
+  end
+
+  private
+
+  # Here begins the state machine implementation
+  class DmEncryptState < ScriptExecutionState
+
+    def self.load_state(context)
+      InitialState.new(context)
+    end
+  end
+
+  # Starting state. Tries to connect via ssh.
+  class InitialState < DmEncryptState
+    def enter
+      connect()
+      install_tools()
+    end
+
+    private
+
+    def install_tools
+      @context[:script].post_message("check if the system has the cryptset-package installed")
+      @logger.debug "ConnectedState.install_tools"
+      if !tools_installed?
+        @context[:script].post_message("cryptset-package not installed. Going to install it...")
+        TOOLS.each() {|tool|
+          @context[:remote_command_handler].install(tool)
+        }
+      end
+      if !@context[:remote_command_handler].remote_execute("modprobe dm_crypt")
+        raise Exception.new("dm-crypt module missing")
+      end
+      if tools_installed?
+        @context[:script].post_message("cryptset-package is available")
+        @logger.debug "system says that tools are installed"
+        ToolInstalledState.new(@context)
+      else
+        FailedState.new(@context, "Installation of Tools failed", ConnectedState.new(@context))
+      end
+    end
+
+    def tools_installed?
+      CHECK.each() {|tool|
+        if !@context[:remote_command_handler].tools_installed?(tool)
+          return false
+        end
+      }
+      true
+    end
+  end
+
+  # Connected and Tools installed. Start encryption.
+  class ToolInstalledState < DmEncryptState
+    def enter
+      create_encrypted_volume()
+    end
+
+    private
+    def create_encrypted_volume
+      @context[:script].post_message("going to encrypt device #{@context[:device]} "+
+        "named '#{@context[:device_name]}' and mount it as #{@context[:storage_path]}...")
+      @logger.debug "ToolInstalledState.create_encrypted_volume"
+      @context[:remote_command_handler].encrypt_storage(@context[:device_name],
+      @context[:paraphrase], @context[:device], @context[:storage_path])
+      @context[:script].post_message("device #{@context[:device]} is encrypted and mounted")
+      MountedAndActivatedState.new(@context)
+    end
+
+    def calc_device_name
+      dev = @context[:device_name].gsub(/[-]/,"--")
+      "/dev/mapper/vg--#{dev}-lv--#{dev}"
+    end
+
+  end
+
+  # The encrypted storages is mounted and activated. Cleanup and done.
+  class MountedAndActivatedState < DmEncryptState
+    def enter
+      cleanup()
+    end
+
+    private
+    def cleanup()
+      @context[:script].post_message("disconnecting...")
+      @logger.debug "MountedAndActivatedState.cleanup"
+      @context[:remote_command_handler].disconnect()
+      @context[:script].post_message("done")
+      DoneState.new(@context)
+    end
+
+  end
+
+  class DoneState < DmEncryptState
+    def done?
+      true
+    end
+  end
+
 end

data/lib/scripts/ec2/download_snapshot.rb

@@ -0,0 +1,153 @@
+require "help/script_execution_state"
+require "scripts/ec2/ec2_script"
+require "help/remote_command_handler"
+require "help/dm_crypt_helper"
+require "AWS"
+
+# Script to download a specific snapshot as ZIP
+# * create a specific instance (with Apache Server),
+# * create a volume based on the snapshot
+# * attach the volume
+# * create a XSF-file-system
+# * freeze the file-system
+# * zip the file-system and copy it to the apache folder
+# * wait 5 minutes (now the zip-file can be downloaded)
+#   * alternatively: copy it to S3 and make it downloadable
+#   * alternatively: copy it to an FTP server
+# 
+class DownloadSnapshot < Ec2Script
+  # context information needed
+  # * the EC2 credentials (see #Ec2Script)
+  # * ami_id: the ID of the AMI to be started to perform the operations and to run the web-server for download
+  # * security_group_name => name of the security group used to start the AMI (should open ports for SSH and HTTP)
+  # * ssh_key_data => Key information for the security group that starts the AMI [if not set, use ssh_key_files]
+  # * ssh_key_files => Key information for the security group that starts the AMI
+  # * snapshot_id => The ID of the snapshot to be downloaded
+  # * wait_time (optional, default = 300) => time in sec during which the zipped snapshot is downloadable
+  # * zip_file_dest (optional, default = '/var/www/html') => path of directory where the zipped volume is copied to
+  # * zip_file_name (option, default = 'download') => name of the zip-file to download
+  def initialize(input_params)
+    super(input_params)
+  end
+
+  def check_input_parameters()
+    if @input_params[:temp_device_name] == nil
+      @input_params[:temp_device_name] = "/dev/sdj"
+    end
+    if @input_params[:zip_file_dest] == nil
+      @input_params[:zip_file_dest] = "/var/www/html/"
+    end
+    if @input_params[:zip_file_name] == nil
+      @input_params[:zip_file_name] = "download"
+    end
+    if @input_params[:wait_time] == nil
+      @input_params[:wait_time] = 300
+    end
+  end
+
+  # Load the initial state for the script.
+  # Abstract method to be implemented by extending classes.
+  def load_initial_state()
+    DownloadSnapshotState.load_state(@input_params)
+  end
+
+  private
+
+  # Here begins the state machine implementation
+  class DownloadSnapshotState < ScriptExecutionState
+
+    def self.load_state(context)
+      InitialState.new(context)
+    end
+  end
+
+  #Connected.
+  # Start state. First thing to do is to launch the instance.
+  class InitialState < DownloadSnapshotState
+    def enter
+      launch_instance()
+      InstanceLaunchedState.new(context)
+    end
+  end
+
+  # Instance Launched. Create a volume based on the snapshot.
+  class InstanceLaunchedState < DownloadSnapshotState
+    def enter
+      create_volume_from_snapshot()
+      VolumeCreated.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
+    def enter
+      connect()
+      create_fs()
+      FileSystemCreated.new(@context)
+    end
+  end
+
+  # File system created. Mount it.
+  class FileSystemCreated < DownloadSnapshotState
+    def enter
+      mount_fs()
+      FileSystemMounted.new(@context)
+    end
+
+  end
+
+  # File System mounted. Zip the complete directory on the EBS.
+  class FileSystemMounted < DownloadSnapshotState
+    def enter
+      zip_volume()
+      VolumeZippedAndDownloadableState.new(@context)
+    end
+
+  end
+
+  # Volume is zipped and downloadable. Wait 5 minutes.
+  class VolumeZippedAndDownloadableState < DownloadSnapshotState
+    def enter
+      wait_some_time()
+    end
+
+    def get_link
+      "http://#{@context[:dns_name]}/#{@context[:zip_file_name]}.zip"
+    end
+
+    private
+    
+    def wait_some_time
+      @context[:script].post_message("The snapshot can be downloaded during #{@context[:wait_time]} seconds from link: #{get_link()}")
+      sleep(@context[:wait_time])
+      DownloadStoppedState.new(@context)
+    end
+  end
+
+  # Snapshot can no longer be downloaded. Shut down the instance.
+  class DownloadStoppedState < DownloadSnapshotState
+    def enter
+      shut_down_instance()
+      InstanceShutDown.new(@context)
+    end
+    
+  end
+
+  # Instance is shut down. Delete the volume created.
+  class InstanceShutDown < DownloadSnapshotState
+    def enter
+      delete_volume()
+      Done.new(@context)
+    end
+  end
+
+end