cloudkeeper-one 1.0.0

data/lib/cloudkeeper/one/errors.rb

@@ -0,0 +1,14 @@
+module Cloudkeeper
+  module One
+    module Errors
+      autoload :StandardError, 'cloudkeeper/one/errors/standard_error'
+      autoload :ArgumentError, 'cloudkeeper/one/errors/argument_error'
+      autoload :NetworkConnectionError, 'cloudkeeper/one/errors/network_connection_error'
+      autoload :MultiError, 'cloudkeeper/one/errors/multi_error'
+      autoload :InvalidConfigurationError, 'cloudkeeper/one/errors/invalid_configuration_error'
+
+      autoload :Opennebula, 'cloudkeeper/one/errors/opennebula'
+      autoload :Actions, 'cloudkeeper/one/errors/actions'
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'timeout'
+
+module Cloudkeeper
+  module One
+    module Opennebula
+      class ApplianceHandler < Handler
+        attr_reader :identifier
+
+        LEAVE_ID_AS_IS = -1
+        ONEADMIN_ID = 0
+
+        def initialize
+          super
+
+          @identifier = Cloudkeeper::One::Settings[:identifier]
+        end
+
+        def find_by_appliance_id(appliance_id)
+          find_all_by "TEMPLATE/#{Tags::APPLIANCE_ID}" => appliance_id
+        end
+
+        def find_by_image_list_id(image_list_id)
+          find_all_by "TEMPLATE/#{Tags::APPLIANCE_IMAGE_LIST_ID}" => image_list_id
+        end
+
+        def delete(element)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'element cannot be nil' unless element
+
+          id = element.id
+          handle_opennebula_error { element.delete }
+
+          timeout { sleep(Cloudkeeper::One::Opennebula::Handler::API_POLLING_WAIT) while exist? id }
+        end
+
+        def chmod(element, permissions)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'element cannot be nil' unless element
+
+          handle_opennebula_error do
+            element.chmod_octet permissions
+            element.info!
+          end
+        end
+
+        def update(element, template)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'element cannot be nil' unless element
+
+          handle_opennebula_error do
+            element.update template, true
+            element.info!
+          end
+        end
+
+        def chgrp(element, group)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'element cannot be nil' unless element
+
+          handle_opennebula_error { element.info! }
+          return if group.id == element.gid
+
+          handle_opennebula_error do
+            element.chown(LEAVE_ID_AS_IS, group.id)
+            element.info!
+          end
+        end
+
+        private
+
+        def find_all_by(attributes)
+          xpaths = attributes.clone
+          xpaths['UNAME'] = Cloudkeeper::One::Settings[:'opennebula-users'] \
+            if Cloudkeeper::One::Settings[:'opennebula-users'] && !Cloudkeeper::One::Settings[:'opennebula-users'].empty?
+
+          find_all xpaths
+        end
+
+        def timeout
+          raise Cloudkeeper::One::Errors::ArgumentError, 'Timeout called without a block!' unless block_given?
+
+          Timeout.timeout(Cloudkeeper::One::Settings[:'opennebula-api-call-timeout']) { yield }
+        rescue Timeout::Error
+          raise Cloudkeeper::One::Errors::Opennebula::ApiCallTimeoutError, 'Operation was not successful within the timeout'
+        end
+
+        def find(method, xpaths = {})
+          reload!
+
+          pool.send(method) { |element| element["TEMPLATE/#{Tags::ID}"] == identifier && evaluate_xpaths(element, xpaths) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      class DatastoreHandler < Handler
+        def initialize
+          super
+          @pool = OpenNebula::DatastorePool.new client
+        end
+
+        def find_by_names(names)
+          names.map { |name| find_by_name name }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      class GroupHandler < Handler
+        def initialize
+          super
+          @pool = OpenNebula::GroupPool.new client
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      class Handler
+        include Helper
+        attr_reader :client
+        attr_accessor :pool
+
+        API_POLLING_WAIT = 5
+
+        def initialize
+          @client = OpenNebula::Client.new Cloudkeeper::One::Settings[:'opennebula-secret'],
+                                           Cloudkeeper::One::Settings[:'opennebula-endpoint']
+        end
+
+        def find_one(xpaths = {})
+          find(:find, xpaths)
+        end
+
+        def find_all(xpaths = {})
+          find(:find_all, xpaths)
+        end
+
+        def find_by_name(name)
+          find_one('NAME' => name)
+        end
+
+        def find_by_id(id)
+          find_one('ID' => id.to_s)
+        end
+
+        def exist?(id)
+          find_by_id id
+        end
+
+        private
+
+        def find(method, xpaths = {})
+          reload!
+
+          pool.send(method) { |element| evaluate_xpaths(element, xpaths) }
+        end
+
+        def evaluate_xpaths(element, xpaths)
+          xpaths.inject(true) do |red, elem|
+            red && (elem.last.is_a?(Array) ? elem.last.include?(element[elem.first]) : element[elem.first] == elem.last)
+          end
+        end
+
+        def reload!
+          raise Cloudkeeper::One::Errors::Opennebula::MissingPoolError, 'Handler is missing an OpenNebula pool' unless pool
+
+          method = pool.respond_to?('info_all!') ? 'info_all!' : 'info!'
+          handle_opennebula_error { pool.send(method.to_sym) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      module Helper
+        ERRORS = Hash.new(Cloudkeeper::One::Errors::Opennebula::ResourceRetrievalError)
+                     .update(::OpenNebula::Error::EAUTHENTICATION => Cloudkeeper::One::Errors::Opennebula::AuthenticationError,
+                             ::OpenNebula::Error::EAUTHORIZATION => Cloudkeeper::One::Errors::Opennebula::UserNotAuthorizedError,
+                             ::OpenNebula::Error::ENO_EXISTS => Cloudkeeper::One::Errors::Opennebula::ResourceNotFoundError,
+                             ::OpenNebula::Error::EACTION => Cloudkeeper::One::Errors::Opennebula::ResourceStateError).freeze
+
+        def handle_opennebula_error
+          raise Cloudkeeper::One::Errors::ArgumentError, 'OpenNebula service-wrapper was called without a block!' \
+            unless block_given?
+
+          return_value = yield
+          return return_value unless OpenNebula.is_error?(return_value)
+
+          raise decode_error(return_value.errno), return_value.message
+        end
+
+        def decode_error(errno)
+          ERRORS[errno]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      class ImageHandler < ApplianceHandler
+        IMAGE_STATES = {
+          ready: 'READY',
+          used: 'USED',
+          disabled: 'DISABLED',
+          error: 'ERROR'
+        }.freeze
+
+        EXPIRED_PERMISSIONS = '600'.freeze
+
+        def initialize
+          super
+          @pool = OpenNebula::ImagePool.new client
+        end
+
+        def expired
+          xpaths = { "TEMPLATE/#{Tags::EXPIRED}" => 'yes' }
+          xpaths['UNAME'] = Cloudkeeper::One::Settings[:'opennebula-users'] \
+            if Cloudkeeper::One::Settings[:'opennebula-users'] && !Cloudkeeper::One::Settings[:'opennebula-users'].empty?
+
+          find_all xpaths
+        end
+
+        def delete(image)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'image cannot be nil' unless image
+
+          id = image.id
+
+          if used? image
+            logger.warn "Image with id #{id.inspect} cannot be removed, still in use"
+            return
+          end
+
+          super image
+        end
+
+        def disable(image)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'image cannot be nil' unless image
+
+          id = image.id
+
+          if disabled? image
+            logger.info "Image with id #{id.inspect} is already disabled, skipping"
+            return
+          end
+
+          unless free? image
+            logger.warn "Image with id #{id.inspect} cannot be disabled"
+            return
+          end
+
+          handle_opennebula_error { image.disable }
+
+          timeout { sleep(Cloudkeeper::One::Opennebula::Handler::API_POLLING_WAIT) until disabled? image }
+        end
+
+        def expire(image)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'image cannot be nil' unless image
+
+          id = image.id
+
+          if expired? image
+            logger.debug("Image with id #{id.inspect} is already expired, skipping")
+            return
+          end
+
+          chmod image, EXPIRED_PERMISSIONS
+          disable image
+
+          expiration_attribute = "#{Tags::EXPIRED} = \"yes\""
+
+          handle_opennebula_error { image.rename("EXPIRED_#{Time.now.to_i}_#{image.name}") }
+          handle_opennebula_error { image.update(expiration_attribute, true) }
+        end
+
+        def register(image_template, datastore, group)
+          image_alloc = OpenNebula::Image.build_xml
+          image = OpenNebula::Image.new(image_alloc, client)
+
+          handle_opennebula_error { image.allocate(image_template, datastore.id) }
+
+          timeout do
+            until ready? image
+              raise Cloudkeeper::One::Errors::Opennebula::ResourceStateError, image['TEMPLATE/ERROR'] if error? image
+              sleep(Cloudkeeper::One::Opennebula::Handler::API_POLLING_WAIT)
+            end
+          end
+
+          chmod image, Cloudkeeper::One::Settings[:'appliances-permissions']
+          chgrp image, group
+
+          image
+        end
+
+        def expired?(image)
+          is?(image) { image["TEMPLATE/#{Tags::EXPIRED}"] == 'yes' }
+        end
+
+        def disabled?(image)
+          is?(image) { image.state_str == IMAGE_STATES[:disabled] }
+        end
+
+        def ready?(image)
+          is?(image) { image.state_str == IMAGE_STATES[:ready] }
+        end
+
+        def used?(image)
+          is?(image) { image.state_str == IMAGE_STATES[:used] }
+        end
+
+        def free?(image)
+          is?(image) { image.state_str == IMAGE_STATES[:ready] || image.state_str == IMAGE_STATES[:error] }
+        end
+
+        def error?(image)
+          is?(image) { image.state_str == IMAGE_STATES[:error] }
+        end
+
+        private
+
+        def is?(image)
+          raise Cloudkeeper::One::Errors::ArgumentError, 'image cannot be nil' unless image
+
+          handle_opennebula_error { image.info! }
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      module Tags
+        BASE = 'CLOUDKEEPER'.freeze
+        APPLIANCE = "#{BASE}_APPLIANCE".freeze
+        IMAGE = "#{BASE}_IMAGE".freeze
+
+        ID = "#{BASE}_ID".freeze
+        EXPIRED = "#{BASE}_EXPIRED".freeze
+
+        APPLIANCE_ID = "#{APPLIANCE}_ID".freeze
+        APPLIANCE_TITLE = "#{APPLIANCE}_TITLE".freeze
+        APPLIANCE_DESCRIPTION = "#{APPLIANCE}_DESCRIPTION".freeze
+        APPLIANCE_MPURI = "#{APPLIANCE}_MPURI".freeze
+        APPLIANCE_GROUP = "#{APPLIANCE}_GROUP".freeze
+        APPLIANCE_RAM = "#{APPLIANCE}_RAM".freeze
+        APPLIANCE_CORE = "#{APPLIANCE}_CORE".freeze
+        APPLIANCE_VERSION = "#{APPLIANCE}_VERSION".freeze
+        APPLIANCE_ARCHITECTURE = "#{APPLIANCE}_ARCHITECTURE".freeze
+        APPLIANCE_OPERATING_SYSTEM = "#{APPLIANCE}_OPERATING_SYSTEM".freeze
+        APPLIANCE_VO = "#{APPLIANCE}_VO".freeze
+        APPLIANCE_EXPIRATION_DATE = "#{APPLIANCE}_EXPIRATION_DATE".freeze
+        APPLIANCE_IMAGE_LIST_ID = "#{APPLIANCE}_IMAGE_LIST_ID".freeze
+        APPLIANCE_ATTRIBUTES = "#{APPLIANCE}_ATTRIBUTES".freeze
+
+        IMAGE_URI = "#{IMAGE}_URI".freeze
+        IMAGE_CHECKSUM = "#{IMAGE}_CHECKSUM".freeze
+        IMAGE_SIZE = "#{IMAGE}_SIZE".freeze
+        IMAGE_FORMAT = "#{IMAGE}_FORMAT".freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      class TemplateHandler < ApplianceHandler
+        def initialize
+          super
+          @pool = OpenNebula::TemplatePool.new client
+        end
+
+        def register(template_template, group)
+          template_alloc = OpenNebula::Template.build_xml
+          template = OpenNebula::Template.new(template_alloc, client)
+
+          handle_opennebula_error { template.allocate template_template }
+
+          chmod template, Cloudkeeper::One::Settings[:'appliances-permissions']
+          chgrp template, group
+
+          template
+        end
+      end
+    end
+  end
+end

data/lib/cloudkeeper/one/opennebula.rb

@@ -0,0 +1,14 @@
+module Cloudkeeper
+  module One
+    module Opennebula
+      autoload :Helper, 'cloudkeeper/one/opennebula/helper'
+      autoload :Tags, 'cloudkeeper/one/opennebula/tags'
+      autoload :Handler, 'cloudkeeper/one/opennebula/handler'
+      autoload :DatastoreHandler, 'cloudkeeper/one/opennebula/datastore_handler'
+      autoload :GroupHandler, 'cloudkeeper/one/opennebula/group_handler'
+      autoload :ApplianceHandler, 'cloudkeeper/one/opennebula/appliance_handler'
+      autoload :ImageHandler, 'cloudkeeper/one/opennebula/image_handler'
+      autoload :TemplateHandler, 'cloudkeeper/one/opennebula/template_handler'
+    end
+  end
+end

data/lib/cloudkeeper/one/settings.rb

@@ -0,0 +1,21 @@
+require 'settingslogic'
+
+module Cloudkeeper
+  module One
+    class Settings < Settingslogic
+      CONFIGURATION = 'cloudkeeper-one.yml'.freeze
+
+      # three possible configuration file locations in order by preference
+      # if configuration file is found rest of the locations are ignored
+      source "#{ENV['HOME']}/.cloudkeeper-one/#{CONFIGURATION}"\
+      if File.exist?("#{ENV['HOME']}/.cloudkeeper-one/#{CONFIGURATION}")
+
+      source "/etc/cloudkeeper-one/#{CONFIGURATION}"\
+      if File.exist?("/etc/cloudkeeper-one/#{CONFIGURATION}")
+
+      source "#{File.dirname(__FILE__)}/../../../config/#{CONFIGURATION}"
+
+      namespace 'cloudkeeper-one'
+    end
+  end
+end

data/lib/cloudkeeper/one/version.rb

@@ -0,0 +1,5 @@
+module Cloudkeeper
+  module One
+    VERSION = '1.0.0'.freeze
+  end
+end

data/lib/cloudkeeper/one.rb

@@ -0,0 +1,19 @@
+require 'active_support/all'
+require 'opennebula'
+require 'json'
+require 'base64'
+require 'tempfile'
+
+module Cloudkeeper
+  module One
+    autoload :Errors, 'cloudkeeper/one/errors'
+    autoload :Opennebula, 'cloudkeeper/one/opennebula'
+    autoload :ApplianceActions, 'cloudkeeper/one/appliance_actions'
+
+    autoload :CLI, 'cloudkeeper/one/cli'
+    autoload :Settings, 'cloudkeeper/one/settings'
+    autoload :CoreConnector, 'cloudkeeper/one/core_connector'
+  end
+end
+
+require 'cloudkeeper/one/version'

data/lib/cloudkeeper_grpc.rb

@@ -0,0 +1,5 @@
+module CloudkeeperGrpc
+  require 'cloudkeeper_grpc/cloudkeeper_pb'
+  require 'cloudkeeper_grpc/cloudkeeper_services_pb'
+  require 'cloudkeeper_grpc/constants'
+end