berta 1.0.0

data/lib/berta/errors.rb

@@ -0,0 +1,9 @@
+module Berta
+  # Module for Berta error classes
+  module Errors
+    autoload :StandardError, 'berta/errors/standard_error'
+    autoload :BackendError, 'berta/errors/backend_error'
+    autoload :OpenNebula, 'berta/errors/opennebula'
+    autoload :Entities, 'berta/errors/entities'
+  end
+end

data/lib/berta/errors/backend_error.rb

@@ -0,0 +1,5 @@
+module Berta
+  module Errors
+    class BackendError < StandardError; end
+  end
+end

data/lib/berta/errors/entities.rb

@@ -0,0 +1,9 @@
+module Berta
+  module Errors
+    # Module for entity errors
+    module Entities
+      autoload :InvalidEntityXMLError, 'berta/errors/entities/invalid_entity_xml_error'
+      autoload :NoUserEmailError, 'berta/errors/entities/no_user_email_error'
+    end
+  end
+end

data/lib/berta/errors/entities/invalid_entity_xml_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module Entities
+      class InvalidEntityXMLError < Berta::Errors::StandardError; end
+    end
+  end
+end

data/lib/berta/errors/entities/no_user_email_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module Entities
+      class NoUserEmailError < Berta::Errors::StandardError; end
+    end
+  end
+end

data/lib/berta/errors/opennebula.rb

@@ -0,0 +1,13 @@
+module Berta
+  module Errors
+    # Module for OpenNebula error classes
+    module OpenNebula
+      autoload :StubError, 'berta/errors/opennebula/stub_error'
+      autoload :AuthenticationError, 'berta/errors/opennebula/authentication_error'
+      autoload :UserNotAuthorizedError, 'berta/errors/opennebula/user_not_authorized_error'
+      autoload :ResourceNotFoundError, 'berta/errors/opennebula/resource_not_found_error'
+      autoload :ResourceStateError, 'berta/errors/opennebula/resource_state_error'
+      autoload :ResourceRetrievalError, 'berta/errors/opennebula/resource_retrieval_error'
+    end
+  end
+end

data/lib/berta/errors/opennebula/authentication_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module OpenNebula
+      class AuthenticationError < Berta::Errors::BackendError; end
+    end
+  end
+end

data/lib/berta/errors/opennebula/resource_not_found_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module OpenNebula
+      class ResourceNotFoundError < Berta::Errors::BackendError; end
+    end
+  end
+end

data/lib/berta/errors/opennebula/resource_retrieval_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module OpenNebula
+      class ResourceRetrievalError < Berta::Errors::BackendError; end
+    end
+  end
+end

data/lib/berta/errors/opennebula/resource_state_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module OpenNebula
+      class ResourceStateError < Berta::Errors::BackendError; end
+    end
+  end
+end

data/lib/berta/errors/opennebula/stub_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module OpenNebula
+      class StubError < Berta::Errors::BackendError; end
+    end
+  end
+end

data/lib/berta/errors/opennebula/user_not_authorized_error.rb

@@ -0,0 +1,7 @@
+module Berta
+  module Errors
+    module OpenNebula
+      class UserNotAuthorizedError < Berta::Errors::BackendError; end
+    end
+  end
+end

data/lib/berta/errors/standard_error.rb

@@ -0,0 +1,5 @@
+module Berta
+  module Errors
+    class StandardError < ::StandardError; end
+  end
+end

data/lib/berta/expiration_manager.rb

@@ -0,0 +1,42 @@
+module Berta
+  # Class for managing expiration dates on vms
+  class ExpirationManager
+    # Update all expirations on vm, removes invalid expirations
+    # and if needed will set default expiration date.
+    #
+    # @param vms [Array<Berta::VirtualMachineHandler>] Virtual machines
+    #   to update expiration on.
+    def update_expirations(vms)
+      vms.each do |vm|
+        remove_invalid_expirations(vm)
+        add_default_expiration(vm)
+      end
+    end
+
+    # Removes invalid expirations on vm. That are schelude actions
+    # with expiration time later than expiration offset.
+    #
+    # @param vm [Berta::VirtualMachineHandler] Virtual machine to
+    #   remove invalid expirations on.
+    def remove_invalid_expirations(vm)
+      exps = vm.expirations
+      exps.keep_if(&:in_expiration_interval?)
+      vm.update_expirations(exps) if exps.length != vm.expirations.length
+    rescue Berta::Errors::BackendError => e
+      logger.error "#{e.message}\n\tOn vm with id #{vm.handle['ID']}"
+    end
+
+    # Adds default expiration if no valid expiration with
+    # right expiration action is set.
+    #
+    # @param vm [Berta::VirtualMachineHandler] Virtual machine
+    #   to set default expiration on.
+    def add_default_expiration(vm)
+      return if vm.default_expiration
+      vm.add_expiration(Time.now.to_i + Berta::Settings.expiration_offset,
+                        Berta::Settings.expiration.action)
+    rescue Berta::Errors::BackendError => e
+      logger.error "#{e.message}\n\tOn vm with id #{vm.handle['ID']}"
+    end
+  end
+end

data/lib/berta/notification_manager.rb

@@ -0,0 +1,100 @@
+require 'mail'
+require 'erb'
+require 'tilt'
+
+module Berta
+  # Class for managing notifications, setting and sending them
+  class NotificationManager
+    attr_reader :service, :email_template
+
+    # Creates NotificationManager object with given service.
+    # Notification manager needs service for fetching user
+    # data from opennebula database. Also initializes
+    # email template object.
+    #
+    # @param service [Berta::Service] Service that will be used
+    #   for fetching data.
+    def initialize(service)
+      @service = service
+      email_file = 'email.erb'.freeze
+      email_template_path = "#{File.dirname(__FILE__)}/../../config/#{email_file}"
+      email_template_path = "etc/berta/#{email_file}" \
+        if File.exist?("etc/berta/#{email_file}")
+      email_template_path = "#{ENV['HOME']}/.berta/#{email_file}" \
+        if File.exist?("#{ENV['HOME']}/.berta/#{email_file}")
+      @email_template = Tilt.new(email_template_path)
+    end
+
+    # Notifies users. Finds all users that should be notified
+    # and sends email to each of them. Email is generated
+    # from template.
+    #
+    # @param vms [Array<Berta::VirtualMachineHandler>] Virtual machines
+    #   to check for notifications.
+    def notify_users(vms)
+      begin
+        users = service.users
+      rescue Berta::Errors::BackendError => e
+        logger.error e.message
+        return
+      end
+      uids_to_notify(vms).each do |uid, uvms|
+        user = users.find { |usr| usr['ID'] == uid }
+        notify_user(user, uvms) if user
+      end
+    end
+
+    # Notifies given user about given vms.
+    #
+    # @param user [OpenNebula::User] User to notify
+    # @param user_vms [Array<Berta::VirtualMachineHandler>] VMs to notify about
+    def notify_user(user, user_vms)
+      send_notification(user, user_vms)
+    rescue ArgumentError, Berta::Errors::Entities::NoUserEmailError => e
+      logger.error e.message
+    else
+      user_vms.each(&:update_notified)
+    end
+
+    # Finds and return uids of users from vms that should be notified.
+    #
+    # @param vms [Array<VirtualMachineHandler>] VMs to check for notification
+    # @return [Hash<String, Array<VirtualMachineHandler>>] Hash of user ids to
+    #   vms that user with key id should be notified about
+    def uids_to_notify(vms)
+      notif = vms.keep_if(&:should_notify?)
+      uidsvm = Hash.new([])
+      notif.each { |vm| uidsvm[vm.handle['UID']] += [vm] }
+      uidsvm
+    end
+
+    # Sends email to given user about given vms using sendmail. Email
+    # is generated from email template.
+    #
+    # @param user [OpenNebula::User] User to notify
+    # @param vms [Array<Berta::VirtualMachineHandler>] VMs to notify user about
+    # @raise [Berta::Errors::Entities::NoUserEmailError] If user has no email set
+    def send_notification(user, vms)
+      user_email = user['TEMPLATE/EMAIL']
+      user_name = user['NAME']
+      raise Berta::Errors::Entities::NoUserEmailError, "User: #{user_name} with id: #{user['ID']} has no email set" \
+        unless user_email
+      mail = Mail.new(email_template.render(Hash,
+                                            user_email: user_email,
+                                            user_name: user_name,
+                                            vms: vms_data(vms)))
+      mail.delivery_method :sendmail
+      mail.deliver
+    end
+
+    private
+
+    def vms_data(vms)
+      vms.map do |vm|
+        { id: vm.handle['ID'],
+          name: vm.handle['NAME'],
+          expiration: vm.default_expiration.time.to_i }
+      end
+    end
+  end
+end

data/lib/berta/service.rb

@@ -0,0 +1,118 @@
+require 'opennebula'
+
+module Berta
+  # Berta service for communication with OpenNebula
+  class Service
+    # VM states that take resources
+    RESOURCE_STATES = %w(SUSPENDED POWEROFF CLONING).freeze
+    # Active state has some lcm states that should not expire
+    ACTIVE_STATE = 'ACTIVE'.freeze
+    # LCM states in which active state shouldn't expire
+    NON_RESOURCE_ACTIVE_LCM_STATES = %w(EPILOG SHUTDOWN STOP UNDEPLOY FAILURE).freeze
+
+    attr_reader :endpoint
+    attr_reader :client
+
+    # Initializes service object and connects to opennebula
+    # backend. If both arguments are nil default ONE_AUTH
+    # will be used.
+    #
+    # @param secret [String] Opennebula secret
+    # @param endpoint [String] Endpoint of OpenNebula
+    def initialize(secret, endpoint)
+      @endpoint = endpoint
+      @client = OpenNebula::Client.new(secret, endpoint)
+    end
+
+    # Fetch running vms from OpenNebula and filter out vms that
+    # take no resources.
+    #
+    # @return [Berta::VirtualMachineHandler] Virtual machines
+    #   running on OpenNebula
+    # @raise [Berta::Errors::OpenNebula::AuthenticationError]
+    # @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError]
+    # @raise [Berta::Errors::OpenNebula::ResourceNotFoundError]
+    # @raise [Berta::Errors::OpenNebula::ResourceStateError]
+    # @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]
+    def running_vms
+      logger.debug 'Fetching vms'
+      vm_pool = OpenNebula::VirtualMachinePool.new(client)
+      Berta::Utils::OpenNebula::Helper.handle_error { vm_pool.info_all }
+      vm_pool.map { |vm| Berta::VirtualMachineHandler.new(vm) }
+             .delete_if { |vmh| excluded?(vmh) || !takes_resources?(vmh) }
+    end
+
+    # Fetch users from OpenNebula
+    #
+    # @return [OpenNebula::UserPool] Users on OpenNebula
+    # @raise [Berta::Errors::OpenNebula::AuthenticationError]
+    # @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError]
+    # @raise [Berta::Errors::OpenNebula::ResourceNotFoundError]
+    # @raise [Berta::Errors::OpenNebula::ResourceStateError]
+    # @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]
+    def users
+      logger.debug 'Fetching users'
+      user_pool = OpenNebula::UserPool.new(client)
+      Berta::Utils::OpenNebula::Helper.handle_error { user_pool.info }
+      user_pool
+    end
+
+    # Fetch clusters from OpenNebula
+    #
+    # @return [OpenNebula::ClusterPool] Clusters on OpenNebula
+    # @raise [Berta::Errors::OpenNebula::AuthenticationError]
+    # @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError]
+    # @raise [Berta::Errors::OpenNebula::ResourceNotFoundError]
+    # @raise [Berta::Errors::OpenNebula::ResourceStateError]
+    # @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]
+    def clusters
+      logger.debug 'Fetching clusters'
+      cluster_pool = OpenNebula::ClusterPool.new(client)
+      Berta::Utils::OpenNebula::Helper.handle_error { cluster_pool.info }
+      cluster_pool
+    end
+
+    private
+
+    def excluded?(vmh)
+      excluded_id?(vmh) ||
+        excluded_user?(vmh) ||
+        excluded_group?(vmh) ||
+        excluded_cluster?(vmh)
+    end
+
+    def excluded_id?(vmh)
+      Berta::Settings.exclude.ids.find { |id| vmh.handle.id == id } \
+        if vmh.handle.id && Berta::Settings.exclude.ids
+    end
+
+    def excluded_user?(vmh)
+      Berta::Settings.exclude.users.find { |user| vmh.handle['UNAME'] == user } \
+        if vmh.handle['UNAME'] && Berta::Settings.exclude.users
+    end
+
+    def excluded_group?(vmh)
+      Berta::Settings.exclude.groups.find { |group| vmh.handle['GNAME'] == group } \
+        if vmh.handle['GNAME'] && Berta::Settings.exclude.groups
+    end
+
+    def excluded_cluster?(vmh)
+      return unless Berta::Settings.exclude.clusters
+      vmcid = latest_cluster_id(vmh)
+      vmcluster = clusters.find { |cluster| cluster['ID'] == vmcid }
+      return unless vmcluster
+      Berta::Settings.exclude.clusters.find { |name| vmcluster['NAME'] == name } \
+        if vmcluster['NAME']
+    end
+
+    def latest_cluster_id(vmh)
+      vmh.handle['HISTORY_RECORDS/HISTORY[last()]/CID']
+    end
+
+    def takes_resources?(vmh)
+      return true if RESOURCE_STATES.any? { |state| vmh.handle.state_str == state }
+      return true if vmh.handle.state_str == ACTIVE_STATE &&
+                     NON_RESOURCE_ACTIVE_LCM_STATES.none? { |state| vmh.handle.lcm_state_str.include? state }
+    end
+  end
+end

data/lib/berta/settings.rb

@@ -0,0 +1,37 @@
+require 'settingslogic'
+require 'chronic_duration'
+
+module Berta
+  # Class for storing setting for Berta
+  class Settings < Settingslogic
+    CONFIGURATION = 'berta.yml'.freeze
+
+    source "#{ENV['HOME']}/.berta/#{CONFIGURATION}"\
+    if File.exist?("#{ENV['HOME']}/.berta/#{CONFIGURATION}")
+
+    source "/etc/berta/#{CONFIGURATION}"\
+    if File.exist?("/etc/berta/#{CONFIGURATION}")
+
+    source "#{File.dirname(__FILE__)}/../../config/#{CONFIGURATION}"
+
+    namespace 'berta'
+
+    # Notification deadline can be written in settings file in human
+    # readable form. This function will return notification deadline
+    # value as integer.
+    #
+    # @return [Numeric] Notification deadline
+    def self.notification_deadline
+      ChronicDuration.parse(get('notification.deadline'))
+    end
+
+    # Expiration offset can be written in settings file in human
+    # readable form. This function will return expiration offset
+    # value as integer.
+    #
+    # @return [Numeric] Expiration offset
+    def self.expiration_offset
+      ChronicDuration.parse(get('expiration.offset'))
+    end
+  end
+end

data/lib/berta/utils.rb

@@ -0,0 +1,6 @@
+module Berta
+  # Utility classes
+  module Utils
+    autoload :OpenNebula, 'berta/utils/opennebula'
+  end
+end

data/lib/berta/utils/opennebula.rb

@@ -0,0 +1,8 @@
+module Berta
+  module Utils
+    # Module for OpenNebula util classes
+    module OpenNebula
+      autoload :Helper, 'berta/utils/opennebula/helper'
+    end
+  end
+end