cloudkeeper-one 1.0.0

data/lib/cloudkeeper/one/appliance_actions/utils/image_download.rb

@@ -0,0 +1,43 @@
+require 'securerandom'
+
+module Cloudkeeper
+  module One
+    module ApplianceActions
+      module Utils
+        module ImageDownload
+          def download_image(uri, username, password)
+            logger.debug "Downloading image from #{uri.inspect} (username: #{username}, password: #{password})"
+            filename = generate_filename
+            retrieve_image URI.parse(uri), username, password, filename
+
+            logger.debug "Image stored into #{filename}"
+            filename
+          rescue URI::InvalidURIError => ex
+            raise Cloudkeeper::One::Errors::NetworkConnectionError, ex
+          end
+
+          private
+
+          def retrieve_image(uri, username, password, filename)
+            Net::HTTP.start(uri.host, uri.port) do |http|
+              request = Net::HTTP::Get.new(uri)
+              request.basic_auth username, password
+
+              http.request(request) do |response|
+                response.value
+                open(filename, 'w') { |file| response.read_body { |chunk| file.write(chunk) } }
+              end
+            end
+          rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
+                 Net::HTTPServerException, Net::HTTPHeaderSyntaxError, Net::ProtocolError => ex
+            raise Cloudkeeper::One::Errors::NetworkConnectionError, ex
+          end
+
+          def generate_filename
+            File.join(Cloudkeeper::One::Settings[:'appliances-tmp-dir'], SecureRandom.uuid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/appliance_actions/utils/template_preparation.rb

@@ -0,0 +1,36 @@
+require 'erb'
+require 'tilt/erb'
+
+module Cloudkeeper
+  module One
+    module ApplianceActions
+      module Utils
+        module TemplatePreparation
+          def prepare_template(filename, data)
+            template_file = File.join(Cloudkeeper::One::Settings[:'appliances-template-dir'], filename)
+            raise Cloudkeeper::One::Errors::ArgumentError, "Missing file #{filename.inspect} in template directory" \
+              unless File.exist?(template_file)
+
+            logger.debug "Populating template from #{template_file}"
+            templates = [template_file, File.join(File.dirname(__FILE__), 'templates', 'attributes.erb')]
+
+            data[:image] ||= nil
+            rendered = render_templates templates, data
+            logger.debug "Template:\n#{rendered}"
+            rendered
+          end
+
+          def render_templates(templates, data)
+            Tempfile.open 'cloudkeeper-template' do |tmp|
+              templates.each { |template| tmp.write(File.read(template)) }
+              tmp.flush
+
+              template = Tilt::ERBTemplate.new tmp
+              template.render Object.new, data
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/appliance_actions/utils/templates/attributes.erb

@@ -0,0 +1,23 @@
+<%= Cloudkeeper::One::Opennebula::Tags::ID %> = "<%= Cloudkeeper::One::Settings[:identifier] %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_ID %> = "<%= appliance.identifier %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_TITLE %> = "<%= appliance.title %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_DESCRIPTION %> = "<%= appliance.description %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_MPURI %> = "<%= appliance.mpuri %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_GROUP %> = "<%= appliance.group %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_RAM %> = "<%= appliance.ram %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_CORE %> = "<%= appliance.core %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_VERSION %> = "<%= appliance.version %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_ARCHITECTURE %> = "<%= appliance.architecture %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_OPERATING_SYSTEM %> = "<%= appliance.operating_system %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_VO %> = "<%= appliance.vo %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_EXPIRATION_DATE %> = "<%= appliance.expiration_date %>"
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_IMAGE_LIST_ID %> = "<%= appliance.image_list_identifier %>"
+
+<% if image %>
+<%= Cloudkeeper::One::Opennebula::Tags::IMAGE_URI %> = "<%= image.uri %>"
+<%= Cloudkeeper::One::Opennebula::Tags::IMAGE_CHECKSUM %> = "<%= image.checksum %>"
+<%= Cloudkeeper::One::Opennebula::Tags::IMAGE_SIZE %> = "<%= image.size %>"
+<%= Cloudkeeper::One::Opennebula::Tags::IMAGE_FORMAT %> = "<%= image.format %>"
+<% end %>
+
+<%= Cloudkeeper::One::Opennebula::Tags::APPLIANCE_ATTRIBUTES %> = "<%= Base64.strict_encode64 appliance.attributes.to_h.to_json %>"

data/lib/cloudkeeper/one/appliance_actions/utils.rb

@@ -0,0 +1,10 @@
+module Cloudkeeper
+  module One
+    module ApplianceActions
+      module Utils
+        autoload :ImageDownload, 'cloudkeeper/one/appliance_actions/utils/image_download'
+        autoload :TemplatePreparation, 'cloudkeeper/one/appliance_actions/utils/template_preparation'
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/appliance_actions.rb

@@ -0,0 +1,11 @@
+module Cloudkeeper
+  module One
+    module ApplianceActions
+      autoload :Registration, 'cloudkeeper/one/appliance_actions/registration'
+      autoload :Removal, 'cloudkeeper/one/appliance_actions/removal'
+      autoload :Update, 'cloudkeeper/one/appliance_actions/update'
+      autoload :List, 'cloudkeeper/one/appliance_actions/list'
+      autoload :Utils, 'cloudkeeper/one/appliance_actions/utils'
+    end
+  end
+end

data/lib/cloudkeeper/one/cli.rb

@@ -0,0 +1,185 @@
+require 'thor'
+require 'yell'
+require 'chronic_duration'
+
+module Cloudkeeper
+  module One
+    class CLI < Thor
+      class_option :'logging-level',
+                   required: true,
+                   default: Cloudkeeper::One::Settings['logging']['level'],
+                   type: :string,
+                   enum: Yell::Severities
+      class_option :'logging-file',
+                   default: Cloudkeeper::One::Settings['logging']['file'],
+                   type: :string,
+                   desc: 'File to write logs to'
+      class_option :debug,
+                   default: Cloudkeeper::One::Settings['debug'],
+                   type: :boolean,
+                   desc: 'Runs cloudkeeper in debug mode'
+
+      method_option :'listen-address',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['listen-address'],
+                    type: :string,
+                    desc: 'IP address gRPC server will listen on'
+      method_option :authentication,
+                    default: Cloudkeeper::One::Settings['authentication'],
+                    type: :boolean,
+                    desc: 'Client <-> server authentication'
+      method_option :certificate,
+                    required: false,
+                    default: Cloudkeeper::One::Settings['certificate'],
+                    type: :string,
+                    desc: "Backend's host certificate"
+      method_option :key,
+                    required: false,
+                    default: Cloudkeeper::One::Settings['key'],
+                    type: :string,
+                    desc: "Backend's host key"
+      method_option :identifier,
+                    required: true,
+                    default: Cloudkeeper::One::Settings['identifier'],
+                    type: :string,
+                    desc: 'Instance identifier'
+      method_option :'core-certificate',
+                    required: false,
+                    default: Cloudkeeper::One::Settings['core']['certificate'],
+                    type: :string,
+                    desc: "Core's certificate"
+      method_option :'appliances-tmp-dir',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['appliances']['tmp-dir'],
+                    type: :string,
+                    desc: 'Directory where to temporarily store appliances'
+      method_option :'appliances-template-dir',
+                    required: false,
+                    default: Cloudkeeper::One::Settings['appliances']['template-dir'],
+                    type: :string,
+                    desc: 'If set, templates within this directory are used to construct images and templates in OpenNebula'
+      method_option :'appliances-permissions',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['appliances']['permissions'],
+                    type: :string,
+                    desc: 'UNIX-like permissions appliances will have within OpenNebula'
+      method_option :'opennebula-secret',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['opennebula']['secret'],
+                    type: :string,
+                    desc: 'OpenNebula authentication secret'
+      method_option :'opennebula-endpoint',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['opennebula']['endpoint'],
+                    type: :string,
+                    desc: 'OpenNebula XML-RPC endpoint'
+      method_option :'opennebula-datastores',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['opennebula']['datastores'],
+                    type: :array,
+                    desc: 'OpenNebula datastores images will be uploaded to'
+      method_option :'opennebula-users',
+                    required: false,
+                    default: Cloudkeeper::One::Settings['opennebula']['users'],
+                    type: :array,
+                    desc: 'Handle only images/templates of specified users'
+      method_option :'opennebula-api-call-timeout',
+                    required: true,
+                    default: Cloudkeeper::One::Settings['opennebula']['api-call-timeout'],
+                    type: :string,
+                    desc: 'How long will cloudkeeper-one wait for image/template operations to finish in OpenNebula'
+
+      desc 'sync', 'Runs synchronization process'
+      def sync
+        initialize_sync options
+        grpc_server = GRPC::RpcServer.new
+        grpc_server.add_http2_port Cloudkeeper::One::Settings[:'listen-address'], credentials
+        grpc_server.handle Cloudkeeper::One::CoreConnector
+        grpc_server.run_till_terminated
+      rescue Interrupt
+        grpc_server.stop
+      rescue Cloudkeeper::One::Errors::InvalidConfigurationError => ex
+        abort ex.message
+      end
+
+      desc 'version', 'Prints cloudkeeper version'
+      def version
+        $stdout.puts Cloudkeeper::One::VERSION
+      end
+
+      default_task :sync
+
+      private
+
+      def initialize_sync(options)
+        initialize_configuration options
+        validate_configuration!
+        initialize_logger
+        logger.debug "cloudkeeper-one 'sync' called with parameters: #{Cloudkeeper::One::Settings.to_hash.inspect}"
+      end
+
+      def validate_configuration!
+        validate_configuration_group! :authentication,
+                                      [:certificate, :key, :'core-certificate'],
+                                      'Authentication configuration missing'
+      end
+
+      def validate_configuration_group!(flag, required_options, error_message)
+        return unless Cloudkeeper::One::Settings[flag]
+
+        raise Cloudkeeper::One::Errors::InvalidConfigurationError, error_message unless all_options_available(required_options)
+      end
+
+      def all_options_available(required_options)
+        required_options.reduce(true) { |acc, elem| Cloudkeeper::One::Settings[elem] && acc }
+      end
+
+      def credentials
+        return :this_port_is_insecure unless Cloudkeeper::One::Settings[:authentication]
+
+        GRPC::Core::ServerCredentials.new(
+          File.read(Cloudkeeper::One::Settings[:'core-certificate']),
+          [
+            private_key: File.read(Cloudkeeper::One::Settings[:key]),
+            cert_chain: File.read(Cloudkeeper::One::Settings[:certificate])
+          ],
+          true
+        )
+      end
+
+      def initialize_configuration(options)
+        Cloudkeeper::One::Settings.clear
+        Cloudkeeper::One::Settings.merge! options.to_hash
+
+        gem_dir = File.realdirpath(File.join(File.dirname(__FILE__), '..', '..', '..'))
+        Cloudkeeper::One::Settings[:'appliances-template-dir'] = File.join(gem_dir, 'config', 'templates') \
+          unless Cloudkeeper::One::Settings[:'appliances-template-dir']
+        Cloudkeeper::One::Settings[:'opennebula-api-call-timeout'] = \
+          ChronicDuration.parse Cloudkeeper::One::Settings[:'opennebula-api-call-timeout'], keep_zero: true
+      end
+
+      def initialize_logger
+        Cloudkeeper::One::Settings[:'logging-level'] = 'DEBUG' if Cloudkeeper::One::Settings[:debug]
+
+        logging_file = Cloudkeeper::One::Settings[:'logging-file']
+        logging_level = Cloudkeeper::One::Settings[:'logging-level']
+
+        Yell.new :stdout, name: Object, level: logging_level.downcase, format: Yell::DefaultFormat
+        Object.send :include, Yell::Loggable
+
+        setup_file_logger(logging_file) if logging_file
+
+        logger.debug 'Running in debug mode...'
+      end
+
+      def setup_file_logger(logging_file)
+        unless (File.exist?(logging_file) && File.writable?(logging_file)) || File.writable?(File.dirname(logging_file))
+          logger.error "File #{logging_file} isn't writable"
+          return
+        end
+
+        logger.adapter :file, logging_file
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/core_connector.rb

@@ -0,0 +1,106 @@
+module Cloudkeeper
+  module One
+    class CoreConnector < CloudkeeperGrpc::Communicator::Service
+      attr_reader :image_handler, :template_handler, :datastore_handler, :group_handler
+
+      include Cloudkeeper::One::ApplianceActions::Registration
+      include Cloudkeeper::One::ApplianceActions::Removal
+      include Cloudkeeper::One::ApplianceActions::Update
+      include Cloudkeeper::One::ApplianceActions::List
+
+      ERRORS = Hash.new(CloudkeeperGrpc::Constants::STATUS_ERROR).update(
+        Cloudkeeper::One::Errors::Actions::ListingError => CloudkeeperGrpc::Constants::STATUS_ERROR_APPLIANCE_NOT_FOUND,
+        Cloudkeeper::One::Errors::Actions::UpdateError => CloudkeeperGrpc::Constants::STATUS_ERROR_APPLIANCE_NOT_FOUND,
+        Cloudkeeper::One::Errors::NetworkConnectionError => CloudkeeperGrpc::Constants::STATUS_ERROR_APPLIANCE_TRANSFER,
+        Cloudkeeper::One::Errors::Opennebula::AuthenticationError => CloudkeeperGrpc::Constants::STATUS_ERROR_AUTHENTICATION,
+        Cloudkeeper::One::Errors::Opennebula::UserNotAuthorizedError => CloudkeeperGrpc::Constants::STATUS_ERROR_USER_NOT_AUTHORIZED,
+        Cloudkeeper::One::Errors::Opennebula::ResourceNotFoundError => CloudkeeperGrpc::Constants::STATUS_ERROR_RESOURCE_NOT_FOUND,
+        Cloudkeeper::One::Errors::Actions::RegistrationError => CloudkeeperGrpc::Constants::STATUS_ERROR_RESOURCE_NOT_FOUND,
+        Cloudkeeper::One::Errors::Opennebula::ResourceRetrievalError => CloudkeeperGrpc::Constants::STATUS_ERROR_RESOURCE_RETRIEVAL,
+        Cloudkeeper::One::Errors::Opennebula::ResourceStateError => CloudkeeperGrpc::Constants::STATUS_ERROR_RESOURCE_STATE,
+        Cloudkeeper::One::Errors::Opennebula::ApiCallTimeoutError => CloudkeeperGrpc::Constants::STATUS_ERROR_RESOURCE_STATE
+      ).freeze
+
+      def initialize
+        super
+
+        @image_handler = Cloudkeeper::One::Opennebula::ImageHandler.new
+        @template_handler = Cloudkeeper::One::Opennebula::TemplateHandler.new
+        @datastore_handler = Cloudkeeper::One::Opennebula::DatastoreHandler.new
+        @group_handler = Cloudkeeper::One::Opennebula::GroupHandler.new
+      end
+
+      def pre_action(_empty, call)
+        logger.debug 'Running \'pre-action\'...'
+        call_backend(call) { remove_expired }
+      end
+
+      def post_action(_empty, call)
+        logger.debug 'Running \'post-action\'...'
+        call.output_metadata['status'] = 'SUCCESS'
+        Google::Protobuf::Empty.new
+      end
+
+      def add_appliance(appliance, call)
+        logger.debug "Registering appliance #{appliance.identifier.inspect}"
+        call_backend(call) { register_or_update_appliance appliance }
+      end
+
+      def update_appliance(appliance, call)
+        logger.debug "Updating appliance #{appliance.identifier.inspect}"
+        call_backend(call) { appliance.image ? register_or_update_appliance(appliance) : update_appliance_metadata(appliance) }
+      end
+
+      def remove_appliance(appliance, call)
+        logger.debug "Removing appliance #{appliance.identifier.inspect}"
+        call_backend(call) { remove_appliance appliance }
+      end
+
+      def remove_image_list(image_list_identifier, call)
+        logger.debug "Removing appliances from image list #{image_list_identifier.image_list_identifier.inspect}"
+        call_backend(call) { remove_image_list image_list_identifier.image_list_identifier }
+      end
+
+      def image_lists(_empty, call)
+        logger.debug 'Retrieving image lists registered in OpenNebula'
+        call_backend(call, default_return_value: [], use_return_value: true) { list_image_lists.each }
+      end
+
+      def appliances(image_list_identifier, call)
+        logger.debug "Retrieving appliances from image list #{image_list_identifier.image_list_identifier.inspect} " \
+                     'registered in OpenNebula'
+        call_backend(call, default_return_value: [], use_return_value: true) do
+          list_appliances(image_list_identifier.image_list_identifier).each
+        end
+      end
+
+      private
+
+      def call_backend(call, default_return_value: Google::Protobuf::Empty.new, use_return_value: false)
+        raise Cloudkeeper::One::Errors::ArgumentError, 'Error handler was called without a block!' unless block_given?
+
+        return_value = handle_errors(call) { yield }
+        finalize_return_value(return_value, default_return_value, use_return_value)
+      end
+
+      def handle_errors(call)
+        return_value = yield
+        call.output_metadata[CloudkeeperGrpc::Constants::KEY_STATUS] = CloudkeeperGrpc::Constants::STATUS_SUCCESS
+
+        return_value
+      rescue Cloudkeeper::One::Errors::StandardError => ex
+        logger.error "#{ex.class.inspect}: #{ex.message}"
+        call.output_metadata[CloudkeeperGrpc::Constants::KEY_STATUS] = ERRORS[ex.class]
+        call.output_metadata[CloudkeeperGrpc::Constants::KEY_MESSAGE] = ex.message
+
+        return_value
+      end
+
+      def finalize_return_value(return_value, default_return_value, use_return_value)
+        return_value = use_return_value ? return_value : default_return_value
+
+        return_value
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/actions/action_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Actions
+        class ActionError < Cloudkeeper::One::Errors::StandardError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/actions/listing_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Actions
+        class ListingError < ActionError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/actions/registration_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Actions
+        class RegistrationError < ActionError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/actions/update_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Actions
+        class UpdateError < ActionError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/actions.rb

@@ -0,0 +1,12 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Actions
+        autoload :ActionError, 'cloudkeeper/one/errors/actions/action_error'
+        autoload :RegistrationError, 'cloudkeeper/one/errors/actions/registration_error'
+        autoload :ListingError, 'cloudkeeper/one/errors/actions/listing_error'
+        autoload :UpdateError, 'cloudkeeper/one/errors/actions/update_error'
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/argument_error.rb

@@ -0,0 +1,7 @@
+module Cloudkeeper
+  module One
+    module Errors
+      class ArgumentError < StandardError; end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/invalid_configuration_error.rb

@@ -0,0 +1,7 @@
+module Cloudkeeper
+  module One
+    module Errors
+      class InvalidConfigurationError < StandardError; end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/multi_error.rb

@@ -0,0 +1,25 @@
+module Cloudkeeper
+  module One
+    module Errors
+      class MultiError < StandardError
+        attr_accessor :errors
+
+        def initialize
+          @errors = []
+        end
+
+        def <<(error)
+          @errors << error
+        end
+
+        def message
+          errors.map(&:message).join('|')
+        end
+
+        def count
+          errors.count
+        end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/network_connection_error.rb

@@ -0,0 +1,7 @@
+module Cloudkeeper
+  module One
+    module Errors
+      class NetworkConnectionError < StandardError; end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/api_call_timeout_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class ApiCallTimeoutError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/authentication_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class AuthenticationError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/missing_pool_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class MissingPoolError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/opennebula_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class OpennebulaError < Cloudkeeper::One::Errors::StandardError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/resource_not_found_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class ResourceNotFoundError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/resource_retrieval_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class ResourceRetrievalError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/resource_state_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class ResourceStateError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/stub_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class StubError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula/user_not_authorized_error.rb

@@ -0,0 +1,9 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        class UserNotAuthorizedError < OpennebulaError; end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/opennebula.rb

@@ -0,0 +1,17 @@
+module Cloudkeeper
+  module One
+    module Errors
+      module Opennebula
+        autoload :OpennebulaError, 'cloudkeeper/one/errors/opennebula/opennebula_error'
+        autoload :StubError, 'cloudkeeper/one/errors/opennebula/stub_error'
+        autoload :MissingPoolError, 'cloudkeeper/one/errors/opennebula/missing_pool_error'
+        autoload :ApiCallTimeoutError, 'cloudkeeper/one/errors/opennebula/api_call_timeout_error'
+        autoload :AuthenticationError, 'cloudkeeper/one/errors/opennebula/authentication_error'
+        autoload :ResourceNotFoundError, 'cloudkeeper/one/errors/opennebula/resource_not_found_error'
+        autoload :ResourceRetrievalError, 'cloudkeeper/one/errors/opennebula/resource_retrieval_error'
+        autoload :ResourceStateError, 'cloudkeeper/one/errors/opennebula/resource_state_error'
+        autoload :UserNotAuthorizedError, 'cloudkeeper/one/errors/opennebula/user_not_authorized_error'
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/errors/standard_error.rb

@@ -0,0 +1,7 @@
+module Cloudkeeper
+  module One
+    module Errors
+      class StandardError < ::StandardError; end
+    end
+  end
+end