berta 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b948acea2bb242909ad1d4f48c7a63955fb26e4
-  data.tar.gz: 33ab8c9275003edea5335835ca89f680dd0fd2ed
+  metadata.gz: 1ce1338b8020499e9cae1605ddf66c0dad404aae
+  data.tar.gz: dea58173ca736a372e9b6a30f3b08a29efa282b7
 SHA512:
-  metadata.gz: d897e5502b897611794beb1e6ddbc29ca028171954ecf1ce8c548261c7055a0040550f925124a4cb6a1087138ca747abd715c948fcb46b9d4efa018d3e5e37d0
-  data.tar.gz: f3b22ce6b6eb4763503bbfe70476668bb100187a187da5facb82933da986f2b1bb41dc54c4b5bf72f5a49e7506cc71aa054e9b7d66b9acdfb290c7d5fc241040
+  metadata.gz: db63fd0e325e176bd390db3481f48b063077d21e5b0edd6db0d00498cd48a9b0b65a46fc4b205da9e59a2c189994fe39450809be103e4bd60247d4be0fc1fba5
+  data.tar.gz: 6e12df6f7cec8f294ed0893528208a317ac40695e51d12d765fdf7e70961234ab081e9449e08c8da4bade3f2314e86c2bb642dd81dc44ddb8e05711f94daf326

data/lib/berta/cli.rb

@@ -14,54 +14,54 @@ module Berta
     end
 
     class_option :'opennebula-secret',
-                 default: safe_fetch(%w(opennebula secret)),
+                 default: safe_fetch(%w[opennebula secret]),
                  type: :string
     class_option :'opennebula-endpoint',
-                 default: safe_fetch(%w(opennebula endpoint)),
+                 default: safe_fetch(%w[opennebula endpoint]),
                  type: :string
     class_option :'expiration-offset',
                  required: true,
-                 default: safe_fetch(%w(expiration offset)),
+                 default: safe_fetch(%w[expiration offset]),
                  type: :string
     class_option :'expiration-action',
                  required: true,
-                 default: safe_fetch(%w(expiration action)),
+                 default: safe_fetch(%w[expiration action]),
                  type: :string
     class_option :'notification-deadline',
                  required: true,
-                 default: safe_fetch(%w(notification deadline)),
+                 default: safe_fetch(%w[notification deadline]),
                  type: :string
     class_option :'exclude-ids',
-                 default: safe_fetch(%w(exclude ids)),
+                 default: safe_fetch(%w[exclude ids]),
                  type: :array
     class_option :'exclude-users',
-                 default: safe_fetch(%w(exclude users)),
+                 default: safe_fetch(%w[exclude users]),
                  type: :array
     class_option :'exclude-groups',
-                 default: safe_fetch(%w(exclude groups)),
+                 default: safe_fetch(%w[exclude groups]),
                  type: :array
     class_option :'exclude-clusters',
-                 default: safe_fetch(%w(exclude clusters)),
+                 default: safe_fetch(%w[exclude clusters]),
                  type: :array
     class_option :'dry-run',
-                 default: safe_fetch(%w(dry-run)),
+                 default: safe_fetch(%w[dry-run]),
                  type: :boolean
     class_option :'logging-file',
-                 default: safe_fetch(%w(logging file)),
+                 default: safe_fetch(%w[logging file]),
                  type: :string
     class_option :'logging-level',
                  required: true,
-                 default: safe_fetch(%w(logging level)),
+                 default: safe_fetch(%w[logging level]),
                  type: :string
     class_option :debug,
-                 default: safe_fetch(%w(debug)),
+                 default: safe_fetch(%w[debug]),
                  type: :boolean
 
     desc 'cleanup', 'Task that sets all expiration to all vms and notifies users'
     def cleanup
       initialize_configuration(options)
       initialize_logger(options)
-      Berta::CommandExecutor.cleanup
+      Berta::CommandExecutor.new.cleanup
     end
 
     desc 'version', 'Prints berta version'

data/lib/berta/command_executor.rb

@@ -1,16 +1,31 @@
+require 'erb'
+require 'tilt'
+
 module Berta
   # Class for executing main berta commands
   class CommandExecutor
+    def initialize
+      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
+
     # Function that performs clean up operation.
     # Connects to opennebula database,
     # runs expiration update process and
     # notifies users about upcoming expirations.
-    def self.cleanup
+    def cleanup
       service = Berta::Service.new(Berta::Settings['opennebula']['secret'],
                                    Berta::Settings['opennebula']['endpoint'])
       vms = service.running_vms
-      Berta::ExpirationManager.new.update_expirations(vms)
-      Berta::NotificationManager.new(service).notify_users(vms)
+      users = service.users
+      vms.each(&:update)
+      Mail.defaults { delivery_method :sendmail }
+      users.each { |user| user.notify(service.user_vms(user), @email_template) }
     rescue Berta::Errors::BackendError => e
       logger.error e.message
     end

data/lib/berta/entities/expiration.rb

@@ -20,9 +20,9 @@ module Berta
       # @raise [Berta::Errors::Entities::InvalidEntityXMLError] If xml is not in correct format
       def self.check_xml!(xml)
         raise Berta::Errors::Entities::InvalidEntityXMLError, 'wrong enxpiration xml recieved' \
-          unless %w(ID
+          unless %w[ID
                     ACTION
-                    TIME).all? { |path| xml.has_elements? path }
+                    TIME].all? { |path| xml.has_elements? path }
       end
 
       # Creates expiration class instance from given arguments.
@@ -77,6 +77,11 @@ module Berta
       def default_action?
         action == Berta::Settings.expiration.action
       end
+
+      # TODO: doc
+      def ==(other)
+        id == other.id && action == other.action && time == other.time
+      end
     end
   end
 end

data/lib/berta/exclusions.rb

@@ -2,11 +2,11 @@ module Berta
   # Class for Handeling berta exclusions
   class Exclusions
     # VM states that take resources
-    RESOURCE_STATES = %w(SUSPENDED POWEROFF CLONING).freeze
+    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
+    NON_RESOURCE_ACTIVE_LCM_STATES = %w[EPILOG SHUTDOWN STOP UNDEPLOY FAILURE].freeze
 
     # Constructs Exclusions object.
     #

data/lib/berta/service.rb

@@ -20,7 +20,7 @@ module Berta
     # Fetch running vms from OpenNebula and filter out vms that
     # take no resources.
     #
-    # @return [Berta::VirtualMachineHandler] Virtual machines
+    # @return [Array<Berta::VirtualMachineHandler>] Virtual machines
     #   running on OpenNebula
     # @raise [Berta::Errors::OpenNebula::AuthenticationError]
     # @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError]
@@ -28,18 +28,20 @@ module Berta
     # @raise [Berta::Errors::OpenNebula::ResourceStateError]
     # @raise [Berta::Errors::OpenNebula::ResourceRetrievalError]
     def running_vms
+      return @cached_vms if @cached_vms
       vm_pool = OpenNebula::VirtualMachinePool.new(client)
       Berta::Utils::OpenNebula::Helper.handle_error { vm_pool.info_all }
       logger.debug "Fetched vms: #{vm_pool.map(&:id)}"
-      Berta::Exclusions.new(Berta::Settings.exclude.ids,
-                            Berta::Settings.exclude.users,
-                            Berta::Settings.exclude.groups,
-                            excluded_clusters).filter!(vm_pool.map { |vm| Berta::VirtualMachineHandler.new(vm) })
+      @cached_vms = Berta::Exclusions.new(Berta::Settings.exclude.ids,
+                                          Berta::Settings.exclude.users,
+                                          Berta::Settings.exclude.groups,
+                                          excluded_clusters).filter!(vm_pool.map { |vm| Berta::VirtualMachineHandler.new(vm) })
+      @cached_vms
     end
 
     # Fetch users from OpenNebula
     #
-    # @return [OpenNebula::UserPool] Users on OpenNebula
+    # @return [Array<OpenNebula::UserHandler>] Users on OpenNebula
     # @raise [Berta::Errors::OpenNebula::AuthenticationError]
     # @raise [Berta::Errors::OpenNebula::UserNotAuthorizedError]
     # @raise [Berta::Errors::OpenNebula::ResourceNotFoundError]
@@ -49,7 +51,16 @@ module Berta
       user_pool = OpenNebula::UserPool.new(client)
       Berta::Utils::OpenNebula::Helper.handle_error { user_pool.info }
       logger.debug "Fetched users: #{user_pool.map(&:id)}"
-      user_pool
+      user_pool.map { |user| Berta::UserHandler.new(user) }
+    end
+
+    # Return vms that belong to given user
+    #
+    # @note calls running_vms
+    # @param user [Berta::UserHandler] User to find vms for
+    # @return [Array<Berta::VirtualMachineHandler>] VMs that belong to given user
+    def user_vms(user)
+      running_vms.keep_if { |vm| vm.handle['UID'] == user.handle['ID'] }
     end
 
     # Fetch clusters from OpenNebula

data/lib/berta/user_handler.rb

@@ -0,0 +1,52 @@
+require 'mail'
+require 'erb'
+require 'tilt'
+
+module Berta
+  # Class for handeling user methods
+  class UserHandler
+    attr_reader :handle
+
+    # Initializes UserHandler object
+    #
+    # @param user [OpenNebula::User] User that will this
+    #   handle use
+    def initialize(user)
+      @handle = user
+    end
+
+    # Notifies user about all vms that are in notification interval
+    #
+    # @param user_vms [Array<Berta::VirtualMachineHandler>] All vms that belong to
+    #   this user
+    # @param email_template [Tilt::ERBTemplate] Email template
+    def notify(user_vms, email_template)
+      to_notify = user_vms.keep_if(&:should_notify?)
+      return if to_notify.empty?
+      send_notification(to_notify, email_template)
+      user_vms.each(&:update_notified)
+    rescue ArgumentError, Berta::Errors::Entities::NoUserEmailError => e
+      logger.error e.message
+    end
+
+    def send_notification(user_vms, email_template)
+      user_email = handle['TEMPLATE/EMAIL']
+      user_name = handle['NAME']
+      raise Berta::Errors::Entities::NoUserEmailError, "User: #{user_name} with id: #{handle['ID']} has no email set" \
+        unless user_email
+      email_text = email_template.render(Hash, user_email: user_email, user_name: user_name, vms: vms_data(user_vms))
+      logger.debug "Sending mail to user: #{user_name} with email: #{user_email}:\n#{email_text}"
+      Mail.new(email_text).deliver unless Berta::Settings['dry-run']
+    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/version.rb

@@ -1,3 +1,3 @@
 module Berta
-  VERSION = '1.4.0'.freeze
+  VERSION = '1.4.1'.freeze
 end

data/lib/berta/virtual_machine_handler.rb

@@ -7,12 +7,24 @@ module Berta
 
     # Constructs Virtual machine handler from given vm.
     #
-    # @param vm [Berta::VirtualMachineHandler] VM that will
+    # @param vm [OpenNebula::VirtualMachine] VM that will
     #   this handler use.
     def initialize(vm)
       @handle = vm
     end
 
+    # Updates vms expirations. That means it adds default
+    # expiration if vm has no default expiration. If VM has
+    # invalid expiration it will be deleted. Other expirations
+    # are kept.
+    def update
+      exps = expirations.keep_if(&:in_expiration_interval?)
+      exps << next_expiration unless default_expiration
+      update_expirations(exps) unless exps == expirations
+    rescue Berta::Errors::BackendError => e
+      logger.error "#{e.message} on vm with id #{vm.handle['ID']}"
+    end
+
     # Sets notified flag value in USER_TEMPLATE to default expiration
     # time as integer. If VM has no default expiration nothing will
     # be updated. After updating notified value
@@ -36,15 +48,6 @@ module Berta
       end
     end
 
-    # Return notified flag value from USER_TEMPLATE if it is set
-    # else nil.
-    #
-    # @return [Numeric] Time of expiration that VM was notified about
-    def notified
-      time = handle["USER_TEMPLATE/#{NOTIFIED_FLAG}"]
-      time.to_i if time
-    end
-
     # Determines if VM meets criteria to be notified.
     # To be notified, VM musn't have the same notification
     # time as default expiration time and must be in
@@ -59,6 +62,39 @@ module Berta
       expiration.in_notification_interval?
     end
 
+    # Return default expiration, that means expiration with
+    # default expiration action that is in expiration offset interval
+    # and is closes to current date.
+    #
+    # @return [Berta::Entities::Expiration] Nearest default expiration else nil
+    def default_expiration
+      expirations
+        .find_all { |exp| exp.default_action? && exp.in_expiration_interval? }
+        .min { |exp| exp.time.to_i }
+    end
+
+    # Returns array of expirations on vm. Expirations are
+    # classes from USER_TEMPLATE/SCHED_ACTION.
+    #
+    # @return [Array<Berta::Entities::Expiration>] All expirations on vm
+    def expirations
+      exps = []
+      handle.each('USER_TEMPLATE/SCHED_ACTION') \
+        { |saxml| exps.push(Berta::Entities::Expiration.from_xml(saxml)) }
+      exps
+    end
+
+    # Return notified flag value from USER_TEMPLATE if it is set
+    # else nil.
+    #
+    # @return [Numeric] Time of expiration that VM was notified about
+    def notified
+      time = handle["USER_TEMPLATE/#{NOTIFIED_FLAG}"]
+      time.to_i if time
+    end
+
+    private
+
     # Sets array of expirations to vm, rewrites all old ones.
     # Receiving empty array wont change anything.
     #
@@ -77,28 +113,6 @@ module Berta
       end
     end
 
-    # Returns array of expirations on vm. Expirations are
-    # classes from USER_TEMPLATE/SCHED_ACTION.
-    #
-    # @return [Array<Berta::Entities::Expiration>] All expirations on vm
-    def expirations
-      exps = []
-      handle.each('USER_TEMPLATE/SCHED_ACTION') \
-        { |saxml| exps.push(Berta::Entities::Expiration.from_xml(saxml)) }
-      exps
-    end
-
-    # Return default expiration, that means expiration with
-    # default expiration action that is in expiration offset interval
-    # and is closes to current date.
-    #
-    # @return [Berta::Entities::Expiration] Nearest default expiration else nil
-    def default_expiration
-      expirations
-        .find_all { |exp| exp.default_action? && exp.in_expiration_interval? }
-        .min { |exp| exp.time.to_i }
-    end
-
     # Return first available SCHED_ACTION/ID
     #
     # @return [Numeric] Next sched action id
@@ -107,5 +121,14 @@ module Berta
       return 0 unless elems
       elems.to_a.max.to_i + 1
     end
+
+    # Return default expiration that would be next for this vm
+    #
+    # @return [Berta::Entities::Expiration] Next expiration for this vm
+    def next_expiration
+      Berta::Entities::Expiration.new(next_expiration_id,
+                                      Time.now.to_i + Berta::Settings.expiration_offset,
+                                      Berta::Settings.expiration.action)
+    end
   end
 end

data/lib/berta.rb

@@ -3,8 +3,7 @@ module Berta
   autoload :Service, 'berta/service'
   autoload :Exclusions, 'berta/exclusions'
   autoload :VirtualMachineHandler, 'berta/virtual_machine_handler'
-  autoload :ExpirationManager, 'berta/expiration_manager'
-  autoload :NotificationManager, 'berta/notification_manager'
+  autoload :UserHandler, 'berta/user_handler'
   autoload :CommandExecutor, 'berta/command_executor'
   autoload :CLI, 'berta/cli'
   autoload :Errors, 'berta/errors'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berta
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Dusan Baran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-27 00:00:00.000000000 Z
+date: 2017-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -272,10 +272,9 @@ files:
 - lib/berta/errors/opennebula/user_not_authorized_error.rb
 - lib/berta/errors/standard_error.rb
 - lib/berta/exclusions.rb
-- lib/berta/expiration_manager.rb
-- lib/berta/notification_manager.rb
 - lib/berta/service.rb
 - lib/berta/settings.rb
+- lib/berta/user_handler.rb
 - lib/berta/utils.rb
 - lib/berta/utils/opennebula.rb
 - lib/berta/utils/opennebula/helper.rb
@@ -301,7 +300,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Berta VM expiration tool

data/lib/berta/expiration_manager.rb

@@ -1,43 +0,0 @@
-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|
-        begin
-          vm.update_expirations(add_default_expiration(vm, remove_invalid_expirations(vm.expirations)))
-        rescue Berta::Errors::BackendError => e
-          logger.error "#{e.message}\n\tOn vm with id #{vm.handle['ID']}"
-        end
-      end
-    end
-
-    # Removes invalid expirations from array of expirations.
-    # Invalid expirations are expirations that are planned
-    # later than expiration offset value.
-    #
-    # @param exps [Array<Berta::Entities::Expiration>] Expirations to filter
-    # @return [Array<Berta::Entities::Expiration>] Filtered expirations
-    def remove_invalid_expirations(exps)
-      exps.keep_if(&:in_expiration_interval?)
-    end
-
-    # Adds default vm expiration into given array of expirations
-    # assuming that array of expirations are expirations of given vm.
-    # If vm already has default expiration nothing will be changed.
-    #
-    # @param vm [Berta::VirtualMachineHandler] VM with or without default expiration
-    # @param exps [Array<Berta::Entities::Expiration>] VMs expirations to modify
-    # @return Expirations with default expiration
-    def add_default_expiration(vm, exps)
-      return [] if vm.default_expiration
-      exps << Berta::Entities::Expiration.new(vm.next_expiration_id,
-                                              Time.now.to_i + Berta::Settings.expiration_offset,
-                                              Berta::Settings.expiration.action)
-    end
-  end
-end

data/lib/berta/notification_manager.rb

@@ -1,100 +0,0 @@
-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
-      email_text = email_template.render(Hash, user_email: user_email, user_name: user_name, vms: vms_data(vms))
-      logger.debug "Sending mail to user: #{user_name} with email: #{user_email}:\n#{email_text}"
-      return if Berta::Settings['dry-run']
-      mail = Mail.new(email_text)
-      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