CloudyScripts 0.0.11 → 0.0.12

data/LICENSE

@@ -1,7 +1,7 @@
-Copyright (c) 2010 Matthias Jung
-
-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:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (c) 2010 Matthias Jung
+
+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:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,27 +1,27 @@
-# =About
-# CloudyScripts is a library that implements tasks that support common
-# usecases on Cloud Computing Infrastructures (such as Amazon EC2 or Rackspace).
-# It aims to facilitate the implementation of usecases that are not directly
-# available via the providers' API (e.g. like encrypting storage,
-# migrating instances betweem accounts, activating HTTPS). The scripts typically
-# use the provider APIs plus remote access to command-line tools installed on
-# the instances themselves.
-#
-# =Installation and Usage
-# ==Installation
-# <tt>gem install CloudyScripts</tt>
-#
-# ==Usage
-# All scripts are available under /lib/scripts/<provider>
-# They are initialized with a set of parameters and return a well-define
-# set of return values.
-#
-# =Scripts
-# Here are the scripts implemented so far:
-# * #DmEncrypt (encrypt Amazon EBS Storage using dm-encrypt)
-#
-# =Questions and Suggestions
-# Matthias Jung
-# matthias.jung@gmail.com
-# http://elastic-security.com
-
+# =About
+# CloudyScripts is a library that implements tasks that support common
+# usecases on Cloud Computing Infrastructures (such as Amazon EC2 or Rackspace).
+# It aims to facilitate the implementation of usecases that are not directly
+# available via the providers' API (e.g. like encrypting storage,
+# migrating instances betweem accounts, activating HTTPS). The scripts typically
+# use the provider APIs plus remote access to command-line tools installed on
+# the instances themselves.
+#
+# =Installation and Usage
+# ==Installation
+# <tt>gem install CloudyScripts</tt>
+#
+# ==Usage
+# All scripts are available under /lib/scripts/<provider>
+# They are initialized with a set of parameters and return a well-define
+# set of return values.
+#
+# =Scripts
+# Here are the scripts implemented so far:
+# * #DmEncrypt (encrypt Amazon EBS Storage using dm-encrypt)
+#
+# =Questions and Suggestions
+# Matthias Jung
+# matthias.jung@gmail.com
+# http://elastic-security.com
+

data/Rakefile

@@ -1,50 +1,50 @@
-# 
-# To change this template, choose Tools | Templates
-# and open the template in the editor.
- 
-
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/testtask'
-
-spec = Gem::Specification.new do |s|
-  s.name = 'CloudyScripts'
-  s.version = '0.0.11'
-  s.has_rdoc = true
-  s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
-  s.summary = 'Scripts to facilitate programming for infrastructure clouds.'
-  s.description = s.summary
-  s.homepage = "http://elastic-security.com"
-  s.rubyforge_project = "cloudyscripts"
-  s.author = 'Matthias Jung'
-  s.email = 'matthias.jung@gmail.com'
-  # s.executables = ['your_executable_here']
-  s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
-  s.require_path = "lib"
-  s.bindir = "bin"
-  s.has_rdoc = true
-  s.add_dependency("amazon-ec2")
-  s.add_dependency("net-ssh")
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-  p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
-end
-
-Rake::RDocTask.new do |rdoc|
-  files =['README', 'LICENSE', 'lib/**/*.rb']
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README" # page to start on
-  rdoc.title = "CloudyScripts Docs"
-  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
-  rdoc.options << '--line-numbers'
-end
-
-Rake::TestTask.new do |t|
-  t.test_files = FileList['test/**/*.rb']
-end
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'CloudyScripts'
+  s.version = '0.0.12'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
+  s.summary = 'Scripts to facilitate programming for infrastructure clouds.'
+  s.description = s.summary
+  s.homepage = "http://elastic-security.com"
+  s.rubyforge_project = "cloudyscripts"
+  s.author = 'Matthias Jung'
+  s.email = 'matthias.jung@gmail.com'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+  s.has_rdoc = true
+  s.add_dependency("amazon-ec2")
+  s.add_dependency("net-ssh")
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "CloudyScripts Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/cloudyscripts.rb

@@ -1,26 +1,26 @@
-require 'rubygems'
-require 'net/ssh'
-require 'AWS'
-
-# =About
-# CloudyScripts is a library that implements tasks that support common
-# usecases on Cloud Computing Infrastructures (such as Amazon EC2 or Rackspace).
-# It aims to facilitate the implementation of usecases that are not directly
-# available via the providers' API (e.g. like encrypting storage,
-# migrating instances betweem accounts, activating HTTPS). The scripts typically
-# use the provider APIs plus remote access to command-line tools installed on
-# the instances themselves.
-#
-# =Installation and Usage
-# ===Installation
-# <tt>gem install CloudyScripts</tt>
-#
-# ===Usage
-# All scripts are available under /lib/scripts/<em>provider</em>>
-#
-# ===Scripts
-# Here are the scripts implemented so far:
-# * #Scripts::EC2::DmEncrypt (encrypt Amazon EBS Storage using dm-encrypt)
-#
-class CloudyScripts
-end
+require 'rubygems'
+require 'net/ssh'
+require 'AWS'
+
+# =About
+# CloudyScripts is a library that implements tasks that support common
+# usecases on Cloud Computing Infrastructures (such as Amazon EC2 or Rackspace).
+# It aims to facilitate the implementation of usecases that are not directly
+# available via the providers' API (e.g. like encrypting storage,
+# migrating instances betweem accounts, activating HTTPS). The scripts typically
+# use the provider APIs plus remote access to command-line tools installed on
+# the instances themselves.
+#
+# =Installation and Usage
+# ===Installation
+# <tt>gem install CloudyScripts</tt>
+#
+# ===Usage
+# All scripts are available under /lib/scripts/<em>provider</em>>
+#
+# ===Scripts
+# Here are the scripts implemented so far:
+# * #Scripts::EC2::DmEncrypt (encrypt Amazon EBS Storage using dm-encrypt)
+#
+class CloudyScripts
+end

data/lib/help/dm_crypt_helper.rb

@@ -1,54 +1,53 @@
-require 'help/remote_command_handler'
-
-# This class implements helper methods for Dm Encryption
-# (see #Scripts::EC2::DmEncrypt)
-
-class DmCryptHelper < RemoteCommandHandler
-
-  # Encrypts the device and mounting it using dm-crypt tools.
-  # Params
-  # * name: name of the virtual volume
-  # * password: paraphrase to be used for encryption
-  # * device: device to be encrypted
-  # * path: path to which the encrypted device is mounted
-  def encrypt_storage(name, password, device, path)
-    if file_exists?(device)
-      if !file_exists?("/dev/mapper/#{name}")
-        @logger.debug("mapper device #{name} not yet existing")
-        #device not configured, go ahead
-        remote_execute("cryptsetup luksFormat  -q #{device}", password)
-        @logger.debug("device #{device} formatted as #{name}")
-        remote_execute("cryptsetup luksOpen #{device} #{name}",password)
-        @logger.debug("device #{device} / #{name} opened")
-        self.create_filesystem("ext3", "/dev/mapper/#{name}")
-        @logger.debug("filesystem created on /dev/mapper/#{name}")
-        self.mkdir(path)
-        self.mount("/dev/mapper/#{name}", path)
-        #TODO: make a final check that everything worked? ?
-      else
-        #device already exists, just re-activate it
-        @logger.debug("mapper device #{name} is existing")
-        remote_execute("cryptsetup luksOpen #{device} #{name}")
-        @logger.debug("device #{device} /dev/mapper/#{name} opened")
-        self.mkdir(path) unless file_exists?(path)
-        self.mount("/dev/mapper/#{name}", path) unless drive_mounted_as?("/dev/mapper/#{name}", path)
-      end
-    else
-      #device does not even exist
-      raise Exception.new("device #{device} does not exist")
-    end
-
-  end
-
-  # Check if the storage is encrypted (not yet implemented).
-  def test_storage_encryption(password, mount_point, path)
-  end
-
-  def undo_encryption(name, path)
-    remote_execute("umount #{path}", nil, true)
-    @logger.debug("drive #{path} unmounted")
-    remote_execute("cryptsetup luksClose /dev/mapper/#{name}", nil, true)
-    @logger.debug("closed /dev/mapper/#{name} unmounted")
-  end
-
-end
+require 'help/remote_command_handler'
+
+# This class implements helper methods for Dm Encryption
+# (see #Scripts::EC2::DmEncrypt)
+
+class DmCryptHelper < RemoteCommandHandler
+  # Encrypts the device and mounting it using dm-crypt tools.
+  # Params
+  # * name: name of the virtual volume
+  # * password: paraphrase to be used for encryption
+  # * device: device to be encrypted
+  # * path: path to which the encrypted device is mounted
+  def encrypt_storage(name, password, device, path)
+    if file_exists?(device)
+      if !file_exists?("/dev/mapper/#{name}")
+        @logger.debug("mapper device #{name} not yet existing")
+        #device not configured, go ahead
+        remote_execute("cryptsetup luksFormat  -q #{device}", password)
+        @logger.debug("device #{device} formatted as #{name}")
+        remote_execute("cryptsetup luksOpen #{device} #{name}",password)
+        @logger.debug("device #{device} / #{name} opened")
+        self.create_filesystem("ext3", "/dev/mapper/#{name}")
+        @logger.debug("filesystem created on /dev/mapper/#{name}")
+        self.mkdir(path)
+        self.mount("/dev/mapper/#{name}", path)
+        #TODO: make a final check that everything worked? ?
+      else
+        #device already exists, just re-activate it
+        @logger.debug("mapper device #{name} is existing")
+        remote_execute("cryptsetup luksOpen #{device} #{name}")
+        @logger.debug("device #{device} /dev/mapper/#{name} opened")
+        self.mkdir(path) unless file_exists?(path)
+        self.mount("/dev/mapper/#{name}", path) unless drive_mounted_as?("/dev/mapper/#{name}", path)
+      end
+    else
+      #device does not even exist
+      raise Exception.new("device #{device} does not exist")
+    end
+
+  end
+
+  # Check if the storage is encrypted (not yet implemented).
+  def test_storage_encryption(password, mount_point, path)
+  end
+
+  def undo_encryption(name, path)
+    remote_execute("umount #{path}", nil, true)
+    @logger.debug("drive #{path} unmounted")
+    remote_execute("cryptsetup luksClose /dev/mapper/#{name}", nil, true)
+    @logger.debug("closed /dev/mapper/#{name} unmounted")
+  end
+
+end

data/lib/help/ec2_helper.rb

@@ -1,54 +1,54 @@
-require "AWS"
-
-# Implements some helper methods around the EC2 API and methods that are
-# not yet implemented in the amazon-ec2 gem
-
-class AWS::EC2::Base
-  def describe_instance_attribute(options)
-    params = {}
-    params["InstanceId"] = options[:instance_id].to_s
-    params["Attribute"] = "rootDeviceName" unless options[:attributes][:rootDeviceName] == nil
-    return response_generator(:action => "DescribeInstanceAttribute", :params => params)
-  end
-end
-
-class Ec2Helper
-  # expects an instance of AWS::EC2::Base from the amazon-ec2 gem
-  def initialize(ec2_api)
-    @ec2_api = ec2_api
-  end
-
-  # Checks if the specified volume is acting as a root-device for the instance
-  # to which it is attached. It therefore first calls ec2_describe_volumes() to
-  # retrieve the instance linked to the volume specified, then calls
-  # ec2_describe_instance_attribute() to retrieve the rootDeviceName of that
-  # instance, and finally calls describe_instances() to retrieve all volumes
-  # to check against volume_id and rootDeviceName.
-  def is_root_device?(volume_id)
-    vols = @ec2_api.describe_volumes(:volume_id => volume_id)
-    if vols['volumeSet']['item'][0]['attachmentSet'] == nil || vols['volumeSet']['item'][0]['attachmentSet']['item'].size == 0
-      #not linked to any instance, cannot be a root-device
-      return false
-    end
-    instance_id = vols['volumeSet']['item'][0]['attachmentSet']['item'][0]['instanceId']
-    res = @ec2_api.describe_instance_attribute(:instance_id => instance_id, :attributes => {:rootDeviceName => true})
-    if res["rootDeviceName"] == nil
-      return false
-    end
-    rdn = res['rootDeviceName']['value']
-    res = @ec2_api.describe_instances(:instance_id => instance_id)
-    if res['reservationSet']['item'][0]['instancesSet']['item'][0]['blockDeviceMapping']['item'].size == 0
-      # volume unattached in the meantime
-      return false
-    end
-    attached = res['reservationSet']['item'][0]['instancesSet']['item'][0]['blockDeviceMapping']['item']
-    attached.each() {|ebs|
-      volume = ebs['ebs']['volumeId']
-      device_name = ebs['deviceName']
-      if volume == volume_id && rdn == device_name
-        return true
-      end
-    }
-    return false
-  end
-end
+require "AWS"
+
+# Implements some helper methods around the EC2 API and methods that are
+# not yet implemented in the amazon-ec2 gem
+
+class AWS::EC2::Base
+  def describe_instance_attribute(options)
+    params = {}
+    params["InstanceId"] = options[:instance_id].to_s
+    params["Attribute"] = "rootDeviceName" unless options[:attributes][:rootDeviceName] == nil
+    return response_generator(:action => "DescribeInstanceAttribute", :params => params)
+  end
+end
+
+class Ec2Helper
+  # expects an instance of AWS::EC2::Base from the amazon-ec2 gem
+  def initialize(ec2_api)
+    @ec2_api = ec2_api
+  end
+
+  # Checks if the specified volume is acting as a root-device for the instance
+  # to which it is attached. It therefore first calls ec2_describe_volumes() to
+  # retrieve the instance linked to the volume specified, then calls
+  # ec2_describe_instance_attribute() to retrieve the rootDeviceName of that
+  # instance, and finally calls describe_instances() to retrieve all volumes
+  # to check against volume_id and rootDeviceName.
+  def is_root_device?(volume_id)
+    vols = @ec2_api.describe_volumes(:volume_id => volume_id)
+    if vols['volumeSet']['item'][0]['attachmentSet'] == nil || vols['volumeSet']['item'][0]['attachmentSet']['item'].size == 0
+      #not linked to any instance, cannot be a root-device
+      return false
+    end
+    instance_id = vols['volumeSet']['item'][0]['attachmentSet']['item'][0]['instanceId']
+    res = @ec2_api.describe_instance_attribute(:instance_id => instance_id, :attributes => {:rootDeviceName => true})
+    if res["rootDeviceName"] == nil
+      return false
+    end
+    rdn = res['rootDeviceName']['value']
+    res = @ec2_api.describe_instances(:instance_id => instance_id)
+    if res['reservationSet']['item'][0]['instancesSet']['item'][0]['blockDeviceMapping']['item'].size == 0
+      # volume unattached in the meantime
+      return false
+    end
+    attached = res['reservationSet']['item'][0]['instancesSet']['item'][0]['blockDeviceMapping']['item']
+    attached.each() {|ebs|
+      volume = ebs['ebs']['volumeId']
+      device_name = ebs['deviceName']
+      if volume == volume_id && rdn == device_name
+        return true
+      end
+    }
+    return false
+  end
+end

data/lib/help/remote_command_handler.rb

@@ -1,203 +1,213 @@
-require 'rubygems'
-require 'net/ssh'
-
-# Provides methods to be executed via ssh to remote instances.
-class RemoteCommandHandler
-  attr_accessor :logger, :ssh_session
-  def initialize
-    @logger = Logger.new(STDOUT)
-  end
-
-  # Connect to the machine as root using a keyfile.
-  # 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])
-  end
-
-  # Connect to the machine as root using keydata from a keyfile.
-  # Params:
-  # * 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])
-  end
-
-  # Disconnect the current handler
-  def disconnect
-    @ssh_session.close
-  end
-
-  # Check if the path/file specified exists
-  def file_exists?(path)
-    remote_execute("ls #{path}")
-  end
-
-  # Returns the result of uname -a (Linux)
-  def retrieve_os()
-    get_output("uname -r").strip
-  end
-  
-  # Installs the software package specified.
-  def install(software_package)
-    e = "yum -yq install #{software_package}"
-    yum = remote_execute(e)
-    if !yum
-      @logger.info("yum installation failed; try apt-get")
-      e = "apt-get -yq install #{software_package}"
-      apt = remote_execute(e)
-      @logger.info("apt=get installation? #{apt}")
-    end
-  end
-
-  # Checks if the software package specified is installed.
-  def tools_installed?(software_package)
-    exec_string = "which #{software_package}"
-    stdout = []
-    stderr = []
-    result = remote_exec_helper(exec_string, stdout, stderr)
-    return result == true && stdout.size > 0
-  end
-
-  def create_filesystem(fs_type, volume)
-    e = "mkfs -t #{fs_type} #{volume}"
-    remote_execute(e, "y") #TODO: quiet mode?
-  end
-
-  def mkdir(path)
-    e = "mkdir #{path}"
-    remote_execute(e, nil, true)
-  end
-
-  def mount(device, path)
-    e = "mount #{device} #{path}"
-    remote_execute(e, nil, true)
-  end
-
-  # Checks if the drive on path is mounted
-  def drive_mounted?(path)
-    #check if drive mounted
-    drive_found = stdout_contains?("mount", "on #{path} type")
-    if drive_found
-      return file_exists?(path)
-    else
-      @logger.debug "not mounted (since #{path} non-existing)"
-      false
-    end
-  end
-
-  # Checks if the drive on path is mounted with the specific device
-  def drive_mounted_as?(device, path)
-    #check if drive mounted
-    stdout_contains?("mount", "#{device} on #{path} type")
-  end
-
-  # Unmount the specified path.
-  def umount(path)
-    exec_string = "umount #{path}"
-    remote_execute(exec_string)
-    !drive_mounted?(path)
-  end
-
-  # Copy directory using options -avHx
-  def rsync(source_path, dest_path, exclude_path = nil)
-    exclude = ""
-    if exclude_path != nil
-      exclude = "--exclude #{exclude_path}"
-    end
-    e = "rsync -avHx #{exclude} #{source_path} #{dest_path}"
-    @logger.debug "going to execute #{e}"
-    remote_exec_helper(e, nil, nil, false)
-  end
-
-  # Executes the specified #exec_string on a remote session specified.
-  # When #push_data is specified, the data will be used as input for the
-  # command and thus allow to respond in advance to commands that ask the user
-  # something.
-  # The method will return true if nothing was written into stderr, otherwise false.
-  # When #raise_exception is set, an exception will be raised instead of
-  # returning false.
-  def remote_execute(exec_string, push_data = nil, raise_exception = false)
-    exec_string = "echo #{push_data} >tmp.txt; #{exec_string} <tmp.txt; rm -f tmp.txt" unless push_data == nil
-    stdout = []
-    stderr = []
-    result = remote_exec_helper(exec_string, stdout, stderr)
-    em = "RemoteCommandHandler: #{exec_string} lead to stderr message: #{stderr.join().strip}"
-    @logger.info(em) unless stderr.size == 0
-    raise Exception.new(em) unless result == true || raise_exception == false
-    result
-  end
-
-  # Executes the specified #exec_string on a remote session specified as #ssh_session
-  # and logs the command-output into the specified #logger. When #push_data is
-  # specified, the data will be used as input for the command and thus allows
-  # to respond in advance to commands that ask the user something. If the output
-  # in stdout contains the specified #search_string, the method returns true
-  # otherwise false. Output to stderr will be logged.
-  def stdout_contains?(exec_string, search_string = "", push_data = nil)
-    exec_string = "echo #{push_data} >tmp.txt; #{exec_string} <tmp.txt; rm -f tmp.txt" unless push_data == nil
-    stdout = []
-    stderr = []
-    remote_exec_helper(exec_string, stdout, stderr)
-    @logger.info("RemoteCommandHandler: #{exec_string} lead to stderr message: #{stderr.join().strip}") unless stderr.size == 0
-    stdout.join().include?(search_string)
-  end
-
-  # Executes the specified #exec_string on a remote session specified as #ssh_session.
-  # When #push_data is specified, the data will be used as input for the command and thus allows
-  # to respond in advance to commands that ask the user something. It returns
-  # stdout. When #stdout or #stderr is specified as arrays, the respective output is
-  # also written into those arrays.
-  def get_output(exec_string, push_data = nil, stdout = [], stderr = [])
-    exec_string = "echo #{push_data} >tmp.txt; #{exec_string} <tmp.txt; rm -f tmp.txt" unless push_data == nil
-    stdout = []
-    stderr = []
-    remote_exec_helper(exec_string, stdout, stderr)
-    stdout.join()
-  end
-
-  private
-
-  # Executes the specified #exec_string on the opened remote session.
-  # The method will return true if nothing was written into stderr, otherwise false.
-  # All stdout-data is written into #stdout, all stderr-data is written into #stderr
-  def remote_exec_helper(exec_string, stdout = [], stderr = [], debug = false)
-    result = true
-    the_channel = @ssh_session.open_channel do |channel|
-      channel.exec(exec_string) do |ch, success|
-        if success
-          @logger.debug("RemoteCommandHandler: starts executing #{exec_string}") if debug
-          ch.on_data() do |ch, data|
-            stdout << data unless data == nil || stdout == nil
-          end
-          ch.on_extended_data do |ch, type, data|
-            stderr << data unless data == nil || stderr == nil
-            result = false
-          end
-          ch.on_eof do |ch|
-            @logger.debug("RemoteCommandHandler.on_eof:remote end is done sending data") if debug
-          end
-          ch.on_close do |ch|
-            @logger.debug("RemoteCommandHandler.on_close:remote end is closing!") if debug
-          end
-          ch.on_open_failed do |ch, code, desc|
-            @logger.debug("RemoteCommandHandler.on_open_failed: code=#{code} desc=#{desc}") if debug
-          end
-          ch.on_process do |ch|
-            @logger.debug("RemoteCommandHandler.on_process; send line-feed/sleep") if debug
-            sleep(1)
-            ch.send_data("\n")
-          end
-        else
-          stderr << "the remote command could not be invoked!" unless stderr == nil
-          result = false
-        end
-      end
-    end
-    the_channel.wait
-    result
-  end
-
-end
+require 'rubygems'
+require 'net/ssh'
+
+# Provides methods to be executed via ssh to remote instances.
+class RemoteCommandHandler
+  attr_accessor :logger, :ssh_session
+  def initialize
+    @logger = Logger.new(STDOUT)
+  end
+
+  # Connect to the machine as root using a keyfile.
+  # 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])
+  end
+
+  # Connect to the machine as root using keydata from a keyfile.
+  # Params:
+  # * 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])
+  end
+
+  # Disconnect the current handler
+  def disconnect
+    @ssh_session.close
+  end
+
+  # Check if the path/file specified exists
+  def file_exists?(path)
+    remote_execute("ls #{path}")
+  end
+
+  # Returns the result of uname -a (Linux)
+  def retrieve_os()
+    get_output("uname -r").strip
+  end
+  
+  # Installs the software package specified.
+  def install(software_package)
+    e = "yum -yq install #{software_package}"
+    yum = remote_execute(e)
+    if !yum
+      @logger.info("yum installation failed; try apt-get")
+      e = "apt-get -yq install #{software_package}"
+      apt = remote_execute(e)
+      @logger.info("apt=get installation? #{apt}")
+    end
+  end
+
+  # Checks if the software package specified is installed.
+  def tools_installed?(software_package)
+    exec_string = "which #{software_package}"
+    stdout = []
+    stderr = []
+    result = remote_exec_helper(exec_string, stdout, stderr)
+    return result == true && stdout.size > 0
+  end
+
+  def create_filesystem(fs_type, volume)
+    e = "mkfs -t #{fs_type} #{volume}"
+    remote_execute(e, "y") #TODO: quiet mode?
+  end
+
+  def mkdir(path)
+    e = "mkdir #{path}"
+    remote_execute(e, nil, true)
+  end
+
+  def mount(device, path)
+    e = "mount #{device} #{path}"
+    remote_execute(e, nil, true)
+  end
+
+  # Checks if the drive on path is mounted
+  def drive_mounted?(path)
+    #check if drive mounted
+    drive_found = stdout_contains?("mount", "on #{path} type")
+    if drive_found
+      return file_exists?(path)
+    else
+      @logger.debug "not mounted (since #{path} non-existing)"
+      false
+    end
+  end
+
+  # Checks if the drive on path is mounted with the specific device
+  def drive_mounted_as?(device, path)
+    #check if drive mounted
+    stdout_contains?("mount", "#{device} on #{path} type")
+  end
+
+  # Unmount the specified path.
+  def umount(path)
+    exec_string = "umount #{path}"
+    remote_execute(exec_string)
+    !drive_mounted?(path)
+  end
+
+  # Copy directory using options -avHx
+  def rsync(source_path, dest_path, exclude_path = nil)
+    exclude = ""
+    if exclude_path != nil
+      exclude = "--exclude #{exclude_path}"
+    end
+    e = "rsync -avHx #{exclude} #{source_path} #{dest_path}"
+    @logger.debug "going to execute #{e}"
+    remote_exec_helper(e, nil, nil, false)
+  end
+
+  # 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} *"
+      remote_execute(exec, nil, true)
+    rescue Exception => e
+      raise Exception.new("zip failed due to #{e.message}")
+    end
+  end
+
+  # Executes the specified #exec_string on a remote session specified.
+  # When #push_data is specified, the data will be used as input for the
+  # command and thus allow to respond in advance to commands that ask the user
+  # something.
+  # The method will return true if nothing was written into stderr, otherwise false.
+  # When #raise_exception is set, an exception will be raised instead of
+  # returning false.
+  def remote_execute(exec_string, push_data = nil, raise_exception = false)
+    exec_string = "echo #{push_data} >tmp.txt; #{exec_string} <tmp.txt; rm -f tmp.txt" unless push_data == nil
+    stdout = []
+    stderr = []
+    result = remote_exec_helper(exec_string, stdout, stderr)
+    em = "RemoteCommandHandler: #{exec_string} lead to stderr message: #{stderr.join().strip}"
+    @logger.info(em) unless stderr.size == 0
+    raise Exception.new(em) unless result == true || raise_exception == false
+    result
+  end
+
+  # Executes the specified #exec_string on a remote session specified as #ssh_session
+  # and logs the command-output into the specified #logger. When #push_data is
+  # specified, the data will be used as input for the command and thus allows
+  # to respond in advance to commands that ask the user something. If the output
+  # in stdout contains the specified #search_string, the method returns true
+  # otherwise false. Output to stderr will be logged.
+  def stdout_contains?(exec_string, search_string = "", push_data = nil)
+    exec_string = "echo #{push_data} >tmp.txt; #{exec_string} <tmp.txt; rm -f tmp.txt" unless push_data == nil
+    stdout = []
+    stderr = []
+    remote_exec_helper(exec_string, stdout, stderr)
+    @logger.info("RemoteCommandHandler: #{exec_string} lead to stderr message: #{stderr.join().strip}") unless stderr.size == 0
+    stdout.join().include?(search_string)
+  end
+
+  # Executes the specified #exec_string on a remote session specified as #ssh_session.
+  # When #push_data is specified, the data will be used as input for the command and thus allows
+  # to respond in advance to commands that ask the user something. It returns
+  # stdout. When #stdout or #stderr is specified as arrays, the respective output is
+  # also written into those arrays.
+  def get_output(exec_string, push_data = nil, stdout = [], stderr = [])
+    exec_string = "echo #{push_data} >tmp.txt; #{exec_string} <tmp.txt; rm -f tmp.txt" unless push_data == nil
+    stdout = []
+    stderr = []
+    remote_exec_helper(exec_string, stdout, stderr)
+    stdout.join()
+  end
+
+  private
+
+  # Executes the specified #exec_string on the opened remote session.
+  # The method will return true if nothing was written into stderr, otherwise false.
+  # All stdout-data is written into #stdout, all stderr-data is written into #stderr
+  def remote_exec_helper(exec_string, stdout = [], stderr = [], debug = false)
+    result = true
+    the_channel = @ssh_session.open_channel do |channel|
+      channel.exec(exec_string) do |ch, success|
+        if success
+          @logger.debug("RemoteCommandHandler: starts executing #{exec_string}") if debug
+          ch.on_data() do |ch, data|
+            stdout << data unless data == nil || stdout == nil
+          end
+          ch.on_extended_data do |ch, type, data|
+            stderr << data unless data == nil || stderr == nil
+            result = false
+          end
+          ch.on_eof do |ch|
+            @logger.debug("RemoteCommandHandler.on_eof:remote end is done sending data") if debug
+          end
+          ch.on_close do |ch|
+            @logger.debug("RemoteCommandHandler.on_close:remote end is closing!") if debug
+          end
+          ch.on_open_failed do |ch, code, desc|
+            @logger.debug("RemoteCommandHandler.on_open_failed: code=#{code} desc=#{desc}") if debug
+          end
+          ch.on_process do |ch|
+            @logger.debug("RemoteCommandHandler.on_process; send line-feed/sleep") if debug
+            sleep(1)
+            ch.send_data("\n")
+          end
+        else
+          stderr << "the remote command could not be invoked!" unless stderr == nil
+          result = false
+        end
+      end
+    end
+    the_channel.wait
+    result
+  end
+
+end