nifty 0.0.1 → 0.2.2

data/lib/nifty/backends/utils/opennebula/image_handler.rb

@@ -0,0 +1,209 @@
+require 'timeout'
+require 'erb'
+require 'tilt/erb'
+
+# Handler for OpenNebula ImagePool
+#
+# @author Michal Kimle
+class Nifty::Backends::Utils::Opennebula::ImageHandler < Nifty::Backends::Utils::Opennebula::Handler
+
+  IMAGE_STATE_READY = 'READY'
+  IMAGE_STATE_DISABLED = 'DISABLED'
+  IMAGE_STATE_USED = 'USED'
+  IMAGE_STATE_ERROR = 'ERROR'
+  TIME_FORMAT = '%Y%m%d%H%M%S'
+  ATTRIBUTE_EXPIRATION = 'NIFTY_EXPIRATION'
+  ATTRIBUTE_OUTDATED = 'NIFTY_OUTDATED'
+  ATTRIBUTE_APPLIANCE_VERSION = 'NIFTY_APPLIANCE_VERSION'
+
+  # Constructor
+  #
+  # @see Nifty::Backends::Utils::Opennebula::Handler#initialize
+  def initialize(client)
+    super(client)
+    @pool = OpenNebula::ImagePool.new(client)
+  end
+
+  # Returns all images for given appliance id
+  #
+  # @param [String] appliance_id
+  # @return [Array] array of images
+  def images(appliance_id)
+    reload!
+
+    pool.find_all { |image| image["TEMPLATE/#{ATTRIBUTE_APPLIANCE_ID}"] == appliance_id }
+  end
+
+  # Returns all expired images (have attribute NIFTY_EXPIRATION)
+  #
+  # @return [Array] array of expired images
+  def expired_images()
+    reload!
+
+    pool.find_all { |image| image["TEMPLATE/#{ATTRIBUTE_EXPIRATION}"] }
+  end
+
+  def images_by_version(version)
+    reload!
+
+    pool.find_all { |image| image["TEMPLATE/#{ATTRIBUTE_APPLIANCE_VERSION}"] == version }
+  end
+
+  # Returns image with given id if exists
+  #
+  # @param [Fixnum] id
+  # @return [OpenNebula::Image] image with given id
+  def image_exist?(id)
+    reload!
+
+    pool.find { |image| image.id == id }
+  end
+
+  # Deletes image
+  #
+  # @param [OpenNebula::Image] image
+  # @raise [Nifty::Errors::ApiCallTimeoutError] if image isn't deleted within a timeout
+  def delete_image(image)
+    id = image.id
+
+    if image.state_str == IMAGE_STATE_USED
+      logger.warn("Image with id #{id.inspect} cannot be removed, still in use")
+      return
+    end
+
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+    logger.debug("Deleting image with id #{id.inspect}")
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.delete }
+
+    Timeout::timeout(Nifty::API_CALL_TIMEOUT) do
+      while(image_exist?(id))
+        sleep(Nifty::API_POLLING_WAIT)
+      end
+    end
+  rescue Timeout::Error
+    fail Nifty::Errors::ApiCallTimeoutError, "Image with id #{id.inspect} was not deleted within timeout"
+  end
+
+  # Disables image
+  #
+  # @param [OpenNebula::Image] image
+  # @raise [Nifty::Errors::ApiCallTimeoutError] if image isn't disabled within a timeout
+  def disable_image(image)
+    image_state = image.state_str
+    id = image.id
+
+    if image_state == IMAGE_STATE_DISABLED
+      logger.debug("Image with id #{id.inspect} is already disabled, skipping")
+      return
+    end
+
+    unless image_state == IMAGE_STATE_READY || image_state == IMAGE_STATE_ERROR
+      logger.warn("Image with id #{id.inspect} cannot be disabled")
+      return
+    end
+
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.disable }
+
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+    Timeout::timeout(Nifty::API_CALL_TIMEOUT) do
+      until(image.state_str == IMAGE_STATE_DISABLED)
+        sleep(Nifty::API_POLLING_WAIT)
+        Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+      end
+    end
+  end
+
+  # Expires image
+  # Renames image and add attribute NIFTY_EXPIRATION to image with timestamp as a value
+  #
+  # @param [OpenNebula::Image] image
+  def expire_image(image)
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+    id = image.id
+
+    if image["TEMPLATE/#{ATTRIBUTE_EXPIRATION}"]
+      logger.debug("Image with id #{id.inspect} is already expired, skipping")
+      return
+    end
+
+    disable_image(image)
+
+    logger.debug("Expiring image with id #{id.inspect}")
+
+    expiration_time = Time.now.strftime(TIME_FORMAT)
+    expiration_attribute = "#{ATTRIBUTE_EXPIRATION} = \"#{expiration_time}\""
+
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.rename("EXPIRED_#{expiration_time}_#{image.name}") }
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.update(expiration_attribute, true) }
+  end
+
+  # Outdates image
+  # Adds atribute marking the image is outdated
+  #
+  # @param [OpenNebula::Image] image
+  def outdate_image(image)
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+
+    id = image.id
+
+    if image["TEMPLATE/#{ATTRIBUTE_OUTDATED}"]
+      logger.debug("Image with id #{id.inspect} is already outdated, skipping")
+      return
+    end
+
+    logger.debug("Outdating image with id #{id.inspect}")
+
+    outdate_time = Time.now.strftime(TIME_FORMAT)
+    outdate_attribute = "#{ATTRIBUTE_OUTDATED} = \"#{outdate_time}\""
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.update(outdate_attribute, true) }
+  end
+
+  # Registers a new image
+  #
+  # @param [String] template template for image
+  # @param [OpenNebula::Datastore] datastore datastore to register image to
+  # @raise [Nifty::Errors::ApiCallTimeoutError] if image isn't ready within a timeout
+  def register_image(template, datastore)
+    image_alloc = ::OpenNebula::Image.build_xml
+    image = ::OpenNebula::Image.new(image_alloc, client)
+
+    logger.debug("Registering image with template\n#{template}")
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.allocate(template, datastore.id) }
+
+    begin
+      Timeout::timeout(Nifty::API_CALL_TIMEOUT) do
+        Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+
+        until(image.state_str == IMAGE_STATE_READY)
+          sleep(Nifty::API_POLLING_WAIT)
+          Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { image.info! }
+        end
+      end
+
+      image
+    rescue Timeout::Error
+      image.delete
+      fail Nifty::Errors::ApiCallTimeoutError, "Image with id #{image.id.inspect} didn't become ready within timeout"
+    end
+  end
+
+  # Prepares a template for an image
+  #
+  # @param [String] template_dir directory with templates
+  # @param [Hash] data used while populating a template
+  # @return [String] final template for an image
+  def self.prepare_template(template_dir, data)
+    template_location = File.join(template_dir, "image.erb")
+    fail Nifty::Errors::ArgumentError, "Missing file 'image.erb' in template directory '#{template_dir}'" unless File.exist?(template_location)
+
+    template = Tilt::ERBTemplate.new(template_location)
+    template_content = template.render(Object.new, data)
+
+    template = Tilt::ERBTemplate.new(File.join(Nifty::GEM_DIR, 'templates', 'image.erb'))
+    nifty_template_content = template.render(Object.new, data)
+
+    whole_template_content = template_content + nifty_template_content
+    logger.debug "Populated image template:\n#{whole_template_content}"
+    whole_template_content
+  end
+end

data/lib/nifty/backends/utils/opennebula/template_handler.rb

@@ -0,0 +1,91 @@
+require 'timeout'
+require 'erb'
+require 'tilt/erb'
+require 'set'
+
+# Handler for OpenNebula TemplatePool
+#
+# @author Michal Kimle
+class Nifty::Backends::Utils::Opennebula::TemplateHandler < Nifty::Backends::Utils::Opennebula::Handler
+
+  # Constructor
+  #
+  # @see Nifty::Backends::Utils::Opennebula::Handler#initialize
+  def initialize(client)
+    super(client)
+    @pool = OpenNebula::TemplatePool.new(client)
+  end
+
+  # Returns all templates for given appliance id
+  #
+  # @param [String] appliance_id
+  # @return [Array] array of templates
+  def templates(appliance_id)
+    reload!
+
+    pool.find_all{ |template| template["TEMPLATE/#{ATTRIBUTE_APPLIANCE_ID}"] == appliance_id }
+  end
+
+  # Returns template with given id if exists
+  #
+  # @param [Fixnum] id
+  # @return [OpenNebula::Template] template with given id
+  def template_exist?(id)
+    reload!
+
+    pool.find { |template| template.id == id }
+  end
+
+  # Deletes template
+  #
+  # @param [OpenNebula::Template] template
+  # @raise [Nifty::Errors::ApiCallTimeoutError] if template isn't deleted within a timeout
+  def delete_template(template)
+    template.info!
+    id = template.id
+
+    logger.debug("Deleting template with id #{id.inspect}")
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { template.delete }
+
+    Timeout::timeout(Nifty::API_CALL_TIMEOUT) do
+      while(template_exist?(id))
+        sleep(Nifty::API_POLLING_WAIT)
+      end
+    end
+  rescue Timeout::Error
+    fail Nifty::Errors::ApiCallTimeoutError, "Template with id #{template.id.inspect} was not deleted within timeout"
+  end
+
+  # Registers a new template
+  #
+  # @param [String] template_template template for template
+  def register_template(template_template)
+    template_alloc = ::OpenNebula::Template.build_xml
+    template = ::OpenNebula::Template.new(template_alloc, client)
+
+    logger.debug("Registering template with template\n#{template_template}")
+    Nifty::Backends::Utils::Opennebula::Helper.handle_opennebula_error { template.allocate(template_template) }
+
+    template
+  end
+
+  # Prepares a template for a template
+  #
+  # @param [String] template_dir directory with templates
+  # @param [Hash] data used while populating a template
+  # @return [String] final template for a template
+  def self.prepare_template(template_dir, data)
+    template_location = File.join(template_dir, "template.erb")
+    fail Nifty::Errors::ArgumentError, "Missing file 'template.erb' in template directory '#{template_dir}'" unless File.exist?(template_location)
+
+    template = Tilt::ERBTemplate.new(template_location)
+    template_content = template.render(Object.new, data)
+
+    template = Tilt::ERBTemplate.new(File.join(Nifty::GEM_DIR, 'templates', 'template.erb'))
+    nifty_template_content = template.render(Object.new, data)
+
+    whole_template_content = template_content + nifty_template_content
+    logger.debug "Populated template template:\n#{whole_template_content}"
+    whole_template_content
+  end
+end

data/lib/nifty/backends/utils/opennebula.rb

@@ -0,0 +1,9 @@
+# Namespace for OpenNebula's backend utilities
+module Nifty::Backends::Utils::Opennebula; end
+
+require 'nifty/backends/utils/opennebula/helper'
+require 'nifty/backends/utils/opennebula/handler'
+require 'nifty/backends/utils/opennebula/group_handler'
+require 'nifty/backends/utils/opennebula/image_handler'
+require 'nifty/backends/utils/opennebula/template_handler'
+require 'nifty/backends/utils/opennebula/datastore_handler'

data/lib/nifty/backends/utils.rb

@@ -0,0 +1,2 @@
+# Namespace for backends' utilities
+module Nifty::Backends::Utils; end

data/lib/nifty/backends.rb

@@ -0,0 +1,5 @@
+# Namespace for all the backends
+module Nifty::Backends
+  require File.join(File.dirname(__FILE__), self.name.demodulize.underscore, 'utils')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |backend_file| require backend_file.chomp('.rb') }
+end

data/lib/nifty/command_executioner.rb

@@ -0,0 +1,202 @@
+require 'thor'
+require 'yell'
+
+class Nifty::CommandExecutioner < Thor
+  class << self
+    # Force Thor to exit with a non-zero return value on failure (after `exit` is called).
+    #
+    # @return [TrueClass, FalseClass] true if thor fail, false otherwise
+    def exit_on_failure?
+      true
+    end
+
+    # List all available transfer methods for the backend
+    #
+    # @param [Nifty::Backend] backend
+    # @return [Array] array of transfer method classes that support the backend
+    def available_transfer_methods(backend)
+      unless Nifty::TransferMethods.constants.include? backend.camelize.to_sym
+        fail Nifty::CommandExecutionError, "No backend with name '#{backend}'"
+      end
+
+      clazz = "Nifty::TransferMethods::#{backend.camelize}".constantize
+      constants = clazz.constants.map { |sym| sym.to_s.downcase }
+      constants.select! do |constant|
+        unknown = clazz.const_get(constant.camelize)
+
+        unknown.respond_to?('transfer_method?') && unknown.transfer_method?
+      end
+
+      constants.sort
+    end
+
+    # List all available backends
+    #
+    # @return [Array] array of all available backend classes
+    def available_backends
+      constants = Nifty::Backends.constants.map { |sym| sym.to_s.downcase }
+      constants.select! do |constant|
+        unknown = Nifty::Backends.const_get(constant.camelize)
+
+        unknown.respond_to?('backend?') && unknown.backend?
+      end
+
+      constants.sort
+    end
+  end
+
+  # global options
+  class_option :"appliance-dir",
+                :required => true,
+                :default => Nifty::Settings['appliance-dir'],
+                :type => :string,
+                :aliases => '-a',
+                :desc => 'Directory from where appliance descriptors will be loaded'
+  class_option :"transfer-method",
+                :required => true,
+                :default => Nifty::Settings['transfer']['method'],
+                :type => :string,
+                :aliases => '-m',
+                :desc => 'Transfer method for image upload'
+  class_option :"transfer-destination",
+                :default => Nifty::Settings['transfer']['destination'],
+                :type => :string,
+                :aliases => '-t',
+                :desc => 'Image upload destination'
+  class_option :"logging-level",
+                :required => true,
+                :default => Nifty::Settings['logging']['level'],
+                :type => :string,
+                :enum => Yell::Severities
+  class_option :"logging-file",
+                :default => Nifty::Settings['logging']['file'],
+                :type => :string,
+                :desc => 'File to write log to'
+  class_option :debug,
+                :default => Nifty::Settings['debug'],
+                :type => :boolean,
+                :desc => 'Runs nifty in debug mode'
+
+  desc 'version', 'Prints NIFTY\'s version'
+  def version
+    $stdout.puts Nifty::VERSION
+  end
+
+  desc 'backends', 'Lists all available backends with their description'
+  def backends
+    backends = self.class.available_backends
+    longest = backends.map { |backend| backend.length }.sort.last
+    backends.each do |backend|
+      $stdout.puts "%-#{longest + 2}s" % "#{backend}" + "# #{Nifty::Backends.const_get(backend.camelize).description}"
+    end
+  end
+
+  available_backends.each do |backend|
+    backend_clazz = Nifty::Backends.const_get(backend.camelize)
+    options = backend_clazz.options
+    options.each do |name, parameters|
+      parameters[:default] = Nifty::Settings[backend][name.to_s] unless parameters[:default]
+      method_option name, parameters
+    end
+
+    class_eval %Q^
+desc '#{backend}', 'Runs NIFTY with backend #{backend}'
+def #{backend}
+  start('#{backend}', options)
+end
+
+desc '#{backend}-transfer-methods', 'Lists all available transfer methods with their description for #{backend.inspect} backend'
+def #{backend}_transfer_methods
+  methods = self.class.available_transfer_methods '#{backend}'
+  longest = methods.map { |method| method.length }.sort.last
+  methods.each do |method|
+    $stdout.puts "%-\#{longest + 2}s" % "\#{method}" + "# \#{Nifty::TransferMethods::#{backend.camelize}.const_get(method.camelize).description}"
+  end
+end
+^
+  end
+
+  private
+
+  # Starts NIFTY with selected backend
+  #
+  # @param [String] backend backend's name
+  # @param [Hash] options options from command line
+  def start(backend, options)
+    parameters = options.to_hash.deep_symbolize_keys
+    init_log parameters
+
+    backend = Nifty::Backends.const_get(backend.camelize)
+    logger.debug "Selected backend '#{backend.inspect}'"
+
+    transfer_method = construct_transfer_method(backend, parameters)
+    logger.debug "Selected transfer method '#{transfer_method.inspect}'"
+
+    logger.debug "Parameters: #{parameters}"
+
+    processor = Nifty::Event::Processor.new(backend, transfer_method, parameters)
+    exit processor.process_events
+  end
+
+  # Inits logging according to the settings
+  #
+  # @param [Hash] parameters
+  # @option parameters [String] logging-level
+  # @option parameters [String] logging-file file to log to
+  # @option parameters [TrueClass, FalseClass] debug debug mode
+  # @return [Type] description of returned object
+  def init_log(parameters)
+    parameters[:"logging-level"] = 'DEBUG' if parameters[:debug]
+
+    Yell.new :stdout, :name => Object, :level => parameters[:"logging-level"].downcase, :format => Yell::DefaultFormat
+    Object.send :include, Yell::Loggable
+
+    if parameters[:"logging-file"]
+      unless (File.exist?(parameters[:"logging-file"]) && File.writable?(parameters[:"logging-file"])) || (File.writable?(File.dirname(parameters[:"logging-file"])))
+        logger.error "File #{parameters[:"logging-file"]} isn't writable"
+        return
+      end
+
+      logger.adapter :file, parameters[:"logging-file"]
+    end
+  end
+
+  # Returns class representing transfer method of specified name
+  #
+  # @param [Nifty::Backend] backend
+  # @param [String] transfer_method_name name of the transfer method
+  # @return [Nifty::TransferMethod] transfer method class
+  def transfer_method_constant(backend, transfer_method_name)
+    transfer_methods = "Nifty::TransferMethods::#{backend.name.demodulize}".constantize
+    backend_name = backend.name.demodulize.underscore
+    error_msg = "No such transfer method '#{transfer_method_name}' for backend '#{backend_name}'"
+    unless transfer_methods.constants.include?(transfer_method_name.camelize.to_sym)
+      $stdout.puts error_msg
+      exit Nifty::ExitCodes::NO_TRANSFER_METHOD_ERROR_EXIT_CODE
+    end
+
+    transfer_method = transfer_methods.const_get(transfer_method_name.camelize)
+    unless transfer_method.respond_to?('backend') && transfer_method.backend == backend
+      $stdout.puts error_msg
+      exit
+    end
+
+    transfer_method
+  end
+
+  # Returns transfer method according to settings
+  #
+  # @param [Nifty::Backend] backend
+  # @param [Hash] parameters
+  # @option parameters [String] transfer-method name of the transfer method
+  # @option parameters [String] transfer-destination destination fo the transfer method
+  # @return [Nifty::TransferMethod] instance of specified transfer method
+  def construct_transfer_method(backend, parameters)
+    transfer_method_const = transfer_method_constant(backend, parameters[:"transfer-method"])
+
+    transfer_method_const.new(parameters[:"transfer-destination"])
+  rescue Nifty::Errors::TransferMethodError => ex
+    $stdout.puts ex.message
+    exit Nifty::ExitCodes::TRANSFER_METHOD_ERROR_EXIT_CODE
+  end
+end

data/lib/nifty/errors/api_call_timeout_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::ApiCallTimeoutError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/argument_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::ArgumentError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/backend_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::BackendError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/backends/opennebula/authentication_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::Opennebula::AuthenticationError < Nifty::Errors::Backends::OpennebulaError; end

data/lib/nifty/errors/backends/opennebula/resource_not_found_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::Opennebula::ResourceNotFoundError < Nifty::Errors::Backends::OpennebulaError; end

data/lib/nifty/errors/backends/opennebula/resource_retrieval_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::Opennebula::ResourceRetrievalError < Nifty::Errors::Backends::OpennebulaError; end

data/lib/nifty/errors/backends/opennebula/resource_state_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::Opennebula::ResourceStateError < Nifty::Errors::Backends::OpennebulaError; end

data/lib/nifty/errors/backends/opennebula/stub_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::Opennebula::StubError < Nifty::Errors::Backends::OpennebulaError; end

data/lib/nifty/errors/backends/opennebula/user_not_authorized_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::Opennebula::UserNotAuthorizedError < Nifty::Errors::Backends::OpennebulaError; end

data/lib/nifty/errors/backends/opennebula.rb

@@ -0,0 +1,5 @@
+module Nifty::Errors::Backends::Opennebula
+  require File.join(File.dirname(__FILE__), 'opennebula_error')
+  require File.join(File.dirname(__FILE__), self.name.demodulize.underscore, 'authentication_error')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |error_file| require error_file.chomp('.rb') }
+end

data/lib/nifty/errors/backends/opennebula_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Backends::OpennebulaError < Nifty::Errors::BackendError; end

data/lib/nifty/errors/backends.rb

@@ -0,0 +1,4 @@
+module Nifty::Errors::Backends
+  require File.join(File.dirname(__FILE__), 'backend_error')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |error_file| require error_file.chomp('.rb') }
+end

data/lib/nifty/errors/command_execution_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::CommandExecutionError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/event/converter_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Event::ConverterError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/event/loader_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Event::LoaderError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/event.rb

@@ -0,0 +1,5 @@
+module Nifty::Errors::Event
+  require File.join(File.dirname(__FILE__), 'event', 'loader_error')
+  require File.join(File.dirname(__FILE__), 'event', 'converter_error')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |error_file| require error_file.chomp('.rb') }
+end

data/lib/nifty/errors/events/event_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Events::EventError < Nifty::Errors::StandardError; end

data/lib/nifty/errors/events/expiration_event_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Events::ExpirationEventError < Nifty::Errors::Events::EventError; end

data/lib/nifty/errors/events/registration_event_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::Events::RegistrationEventError < Nifty::Errors::Events::EventError; end

data/lib/nifty/errors/events.rb

@@ -0,0 +1,4 @@
+module Nifty::Errors::Events
+  require File.join(File.dirname(__FILE__), 'events', 'event_error')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |error_file| require error_file.chomp('.rb') }  
+end

data/lib/nifty/errors/standard_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::StandardError < ::StandardError; end

data/lib/nifty/errors/transfer_method_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::TransferMethodError < Nifty::Errors::ArgumentError; end

data/lib/nifty/errors/transfer_methods/destination_not_directory_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::TransferMethods::DestinationNotDirectoryError < Nifty::Errors::TransferMethodError; end

data/lib/nifty/errors/transfer_methods/destination_not_writable_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::TransferMethods::DestinationNotWritableError < Nifty::Errors::TransferMethodError; end

data/lib/nifty/errors/transfer_methods/image_file_not_readable_error.rb

@@ -0,0 +1 @@
+class Nifty::Errors::TransferMethods::ImageFileNotReadableError < Nifty::Errors::TransferMethodError; end

data/lib/nifty/errors/transfer_methods.rb

@@ -0,0 +1,4 @@
+module Nifty::Errors::TransferMethods
+  require File.join(File.dirname(__FILE__), 'transfer_method_error')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |error_file| require error_file.chomp('.rb') }
+end

data/lib/nifty/errors.rb

@@ -0,0 +1,10 @@
+# Namespace for all the exceptions
+module Nifty::Errors
+  require File.join(File.dirname(__FILE__), 'errors', 'standard_error')
+  require File.join(File.dirname(__FILE__), 'errors', 'argument_error')
+  require File.join(File.dirname(__FILE__), 'errors', 'event')
+  require File.join(File.dirname(__FILE__), 'errors', 'backends')
+  require File.join(File.dirname(__FILE__), 'errors', 'transfer_methods')
+  require File.join(File.dirname(__FILE__), 'errors', 'events')
+  Dir.glob(File.join(File.dirname(__FILE__), self.name.demodulize.underscore, '*.rb')) { |error_file| require error_file.chomp('.rb') }
+end

data/lib/nifty/event/converter.rb

@@ -0,0 +1,29 @@
+# Converts appliances into events
+#
+# @author Michal Kimle
+class Nifty::Event::Converter
+  # Converts appliance into event
+  #
+  # @param [Cloud::Appliance::Descriptor::Appliance] appliance
+  # @param [Nifty::Backend] backend
+  # @param [Nifty::TransferMethod] transfer_method
+  # @param [Hash] parameters
+  # @raise [Nifty::Errors::Event::ConverterError] when something goes wrong while conversion
+  # @return [Nifty::Event] description of returned object
+  def self.convert_appliance(appliance, backend, transfer_method, parameters)
+    events_module = "Nifty::Events::#{backend.name.demodulize}".constantize
+
+    logger.debug "Converting appliance #{appliance.inspect}"
+    event_type = "#{appliance.action}_event".camelize
+
+    fail Nifty::Errors::Event::ConverterError, "No such event type for action #{appliance.action.inspect}" unless events_module.constants.include?(event_type.to_sym)
+    event_class = events_module.const_get(event_type)
+
+    fail Nifty::Errors::Event::ConverterError, "Class #{event_class.inspect} doesn't represent an event" unless (event_class.respond_to?('event?') && event_class.event? && event_class.public_instance_methods.include?(:run))
+
+    event = backend.create_event(event_class, appliance, transfer_method, parameters)
+    logger.debug "Converted event: #{event.inspect}"
+
+    event
+  end
+end