nagios-promoo 1.1.0 → 1.2.0

data/lib/nagios/promoo/occi/probes/kinds_probe.rb

@@ -1,68 +1,99 @@
 # Internal deps
 require File.join(File.dirname(__FILE__), 'base_probe')
 
-class Nagios::Promoo::Occi::Probes::KindsProbe < Nagios::Promoo::Occi::Probes::BaseProbe
-  class << self
-    def description
-      ['kinds', 'Run a probe checking for mandatory OCCI kind definitions']
-    end
+module Nagios
+  module Promoo
+    module Occi
+      module Probes
+        # Probe for checking OCCI kinds declared by sites.
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class KindsProbe < Nagios::Promoo::Occi::Probes::BaseProbe
+          class << self
+            def description
+              ['kinds', 'Run a probe checking for mandatory OCCI kind definitions']
+            end
 
-    def options
-      [
-        [:kinds, { type: :string, enum: %w(core infra all), default: 'all', desc: 'Collection of mandatory kinds to check' }],
-        [:optional, { type: :array, default: [], desc: 'Identifiers of optional kinds (optional by force)' }],
-        [:check_location, { type: :boolean, default: false, desc: 'Verify declared REST locations for INFRA resources' }],
-      ]
-    end
+            def options
+              [
+                [
+                  :kinds,
+                  {
+                    type: :string, enum: %w[core infra all], default: 'all',
+                    desc: 'Collection of mandatory kinds to check'
+                  }
+                ],
+                [
+                  :optional,
+                  {
+                    type: :array, default: [],
+                    desc: 'Identifiers of optional kinds (optional by force)'
+                  }
+                ],
+                [
+                  :check_location,
+                  {
+                    type: :boolean, default: false,
+                    desc: 'Verify declared REST locations for INFRA resources'
+                  }
+                ]
+              ]
+            end
 
-    def declaration
-      "kinds"
-    end
+            def declaration
+              'kinds'
+            end
 
-    def runnable?; true; end
-  end
+            def runnable?
+              true
+            end
+          end
+
+          CORE_KINDS = %w[
+            http://schemas.ogf.org/occi/core#entity
+            http://schemas.ogf.org/occi/core#resource
+            http://schemas.ogf.org/occi/core#link
+          ].freeze
 
-  CORE_KINDS = %w(
-    http://schemas.ogf.org/occi/core#entity
-    http://schemas.ogf.org/occi/core#resource
-    http://schemas.ogf.org/occi/core#link
-  )
+          INFRA_KINDS = %w[
+            http://schemas.ogf.org/occi/infrastructure#compute
+            http://schemas.ogf.org/occi/infrastructure#storage
+            http://schemas.ogf.org/occi/infrastructure#network
+            http://schemas.ogf.org/occi/infrastructure#storagelink
+            http://schemas.ogf.org/occi/infrastructure#networkinterface
+          ].freeze
 
-  INFRA_KINDS = %w(
-    http://schemas.ogf.org/occi/infrastructure#compute
-    http://schemas.ogf.org/occi/infrastructure#storage
-    http://schemas.ogf.org/occi/infrastructure#network
-    http://schemas.ogf.org/occi/infrastructure#storagelink
-    http://schemas.ogf.org/occi/infrastructure#networkinterface
-  )
+          def run(_args = [])
+            kinds = []
+            kinds += CORE_KINDS if %w[core all].include?(options[:kinds])
+            kinds += INFRA_KINDS if %w[infra all].include?(options[:kinds])
+            kinds -= options[:optional] if options[:optional]
 
-  def run(args = [])
-    kinds = []
-    kinds += CORE_KINDS if %w(core all).include?(options[:kinds])
-    kinds += INFRA_KINDS if %w(infra all).include?(options[:kinds])
-    kinds -= options[:optional] if options[:optional]
+            Timeout.timeout(options[:timeout]) do
+              kinds.each do |kind|
+                raise "#{kind.inspect} is missing" unless client.model.get_by_id(kind, true)
+                next unless options[:check_location] && INFRA_KINDS.include?(kind)
 
-    Timeout::timeout(options[:timeout]) do
-      kinds.each do |kind|
-        fail "#{kind.inspect} is missing" unless client.model.get_by_id(kind, true)
-        next unless options[:check_location] && INFRA_KINDS.include?(kind)
+                # Make sure declared locations are actually available as REST
+                # endpoints. Failure will raise an exception, no need to do
+                # anything here. To keep requirements reasonable, only INFRA
+                # kinds are considered relevant for this part of the check.
+                begin
+                  client.list(kind)
+                rescue => err
+                  raise "Failed to verify declared REST location for #{kind.inspect} (#{err.message})"
+                end
+              end
+            end
 
-        # Make sure declared locations are actually available as REST
-        # endpoints. Failure will raise an exception, no need to do
-        # anything here. To keep requirements reasonable, only INFRA
-        # kinds are considered relevant for this part of the check.
-        begin
-          client.list(kind)
-        rescue => err
-          fail "Failed to verify declared REST location for #{kind.inspect} (#{err.message})"
+            puts 'KINDS OK - All specified OCCI kinds were found'
+          rescue => ex
+            puts "KINDS CRITICAL - #{ex.message}"
+            puts ex.backtrace if options[:debug]
+            exit 2
+          end
         end
       end
     end
-
-    puts 'KINDS OK - All specified OCCI kinds were found'
-  rescue => ex
-    puts "KINDS CRITICAL - #{ex.message}"
-    puts ex.backtrace if options[:debug]
-    exit 2
   end
 end

data/lib/nagios/promoo/occi/probes/mixins_probe.rb

@@ -1,50 +1,75 @@
 # Internal deps
 require File.join(File.dirname(__FILE__), 'base_probe')
 
-class Nagios::Promoo::Occi::Probes::MixinsProbe < Nagios::Promoo::Occi::Probes::BaseProbe
-  class << self
-    def description
-      ['mixins', 'Run a probe checking for mandatory OCCI mixin definitions']
-    end
+module Nagios
+  module Promoo
+    module Occi
+      module Probes
+        # Probe for checking OCCI mixins declared by sites.
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class MixinsProbe < Nagios::Promoo::Occi::Probes::BaseProbe
+          class << self
+            def description
+              ['mixins', 'Run a probe checking for mandatory OCCI mixin definitions']
+            end
 
-    def options
-      [
-        [:mixins, { type: :string, enum: %w(infra context all), default: 'all', desc: 'Collection of mandatory mixins to check' }],
-        [:optional, { type: :array, default: [], desc: 'Identifiers of optional mixins (optional by force)' }]
-      ]
-    end
+            def options
+              [
+                [
+                  :mixins,
+                  {
+                    type: :string, enum: %w[infra context all],
+                    default: 'all', desc: 'Collection of mandatory mixins to check'
+                  }
+                ],
+                [
+                  :optional,
+                  {
+                    type: :array, default: [],
+                    desc: 'Identifiers of optional mixins (optional by force)'
+                  }
+                ]
+              ]
+            end
 
-    def declaration
-      "mixins"
-    end
+            def declaration
+              'mixins'
+            end
 
-    def runnable?; true; end
-  end
+            def runnable?
+              true
+            end
+          end
 
-  INFRA_MIXINS = %w(
-    http://schemas.ogf.org/occi/infrastructure#os_tpl
-    http://schemas.ogf.org/occi/infrastructure#resource_tpl
-  )
+          INFRA_MIXINS = %w[
+            http://schemas.ogf.org/occi/infrastructure#os_tpl
+            http://schemas.ogf.org/occi/infrastructure#resource_tpl
+          ].freeze
 
-  CONTEXT_MIXINS = %w(
-    http://schemas.openstack.org/instance/credentials#public_key
-    http://schemas.openstack.org/compute/instance#user_data
-  )
+          CONTEXT_MIXINS = %w[
+            http://schemas.openstack.org/instance/credentials#public_key
+            http://schemas.openstack.org/compute/instance#user_data
+          ].freeze
 
-  def run(args = [])
-    mixins = []
-    mixins += INFRA_MIXINS if %w(infra all).include?(options[:mixins])
-    mixins += CONTEXT_MIXINS if %w(context all).include?(options[:mixins])
-    mixins -= options[:optional] if options[:optional]
+          def run(_args = [])
+            mixins = []
+            mixins += INFRA_MIXINS if %w[infra all].include?(options[:mixins])
+            mixins += CONTEXT_MIXINS if %w[context all].include?(options[:mixins])
+            mixins -= options[:optional] if options[:optional]
 
-    Timeout::timeout(options[:timeout]) do
-      mixins.each { |mixin| fail "#{mixin.inspect} is missing" unless client.model.get_by_id(mixin, true) }
-    end
+            Timeout.timeout(options[:timeout]) do
+              mixins.each { |mixin| raise "#{mixin.inspect} is missing" unless client.model.get_by_id(mixin, true) }
+            end
 
-    puts 'MIXINS OK - All specified OCCI mixins were found'
-  rescue => ex
-    puts "MIXINS CRITICAL - #{ex.message}"
-    puts ex.backtrace if options[:debug]
-    exit 2
+            puts 'MIXINS OK - All specified OCCI mixins were found'
+          rescue => ex
+            puts "MIXINS CRITICAL - #{ex.message}"
+            puts ex.backtrace if options[:debug]
+            exit 2
+          end
+        end
+      end
+    end
   end
 end

data/lib/nagios/promoo/occi/version.rb

@@ -1,7 +1,7 @@
 module Nagios
   module Promoo
     module Occi
-      VERSION = "1.0.0"
+      VERSION = '1.1.0'.freeze
     end
   end
 end

data/lib/nagios/promoo/opennebula/master.rb

@@ -4,41 +4,70 @@ require 'opennebula'
 # Internal deps
 require File.join(File.dirname(__FILE__), 'version')
 
-# Define modules
-module Nagios::Promoo::Opennebula; end
-module Nagios::Promoo::Opennebula::Probes; end
+module Nagios
+  module Promoo
+    # Namespace for ONe-related code.
+    #
+    # @author Boris Parak <parak@cesnet.cz>
+    module Opennebula
+      # Namespace for ONe-related probes.
+      #
+      # @author Boris Parak <parak@cesnet.cz>
+      module Probes; end
+    end
+  end
+end
+
 Dir.glob(File.join(File.dirname(__FILE__), 'probes', '*.rb')) { |probe| require probe.chomp('.rb') }
 
-class Nagios::Promoo::Opennebula::Master < ::Thor
-  class << self
-    # Hack to override the help message produced by Thor.
-    # https://github.com/wycats/thor/issues/261#issuecomment-16880836
-    def banner(command, namespace = nil, subcommand = nil)
-      "#{basename} opennebula #{command.usage}"
-    end
+module Nagios
+  module Promoo
+    module Opennebula
+      # Master class for all OpenNebula probes.
+      #
+      # @author Boris Parak <parak@cesnet.cz>
+      class Master < ::Thor
+        class << self
+          # Hack to override the help message produced by Thor.
+          # https://github.com/wycats/thor/issues/261#issuecomment-16880836
+          def banner(command, _namespace = nil, _subcommand = nil)
+            "#{basename} opennebula #{command.usage}"
+          end
 
-    def available_probes
-      Nagios::Promoo::Opennebula::Probes.constants.collect { |probe| Nagios::Promoo::Opennebula::Probes.const_get(probe) }.reject { |probe| !probe.runnable? }
-    end
-  end
+          def available_probes
+            probes = Nagios::Promoo::Opennebula::Probes.constants.collect do |probe|
+              Nagios::Promoo::Opennebula::Probes.const_get(probe)
+            end
+            probes.select(&:runnable?)
+          end
+        end
 
-  class_option :endpoint, type: :string, desc: 'OpenNebula XML-RPC endpoint', default: 'http://localhost:2633/RPC2'
-  class_option :token, type: :string, desc: 'Authentication token', default: "file://#{ENV['HOME']}/.one/one_auth"
+        class_option :endpoint,
+                     type: :string,
+                     desc: 'OpenNebula XML-RPC endpoint',
+                     default: 'http://localhost:2633/RPC2'
+        class_option :token,
+                     type: :string,
+                     desc: 'Authentication token',
+                     default: "file://#{ENV['HOME']}/.one/one_auth"
 
-  available_probes.each do |probe|
-    desc *probe.description
-    probe.options.each do |opt|
-      option opt.first, opt.last
-    end
-    class_eval %Q^
+        available_probes.each do |probe|
+          desc(*probe.description)
+          probe.options.each do |opt|
+            option opt.first, opt.last
+          end
+          class_eval %^
 def #{probe.declaration}(*args)
   #{probe}.new(options).run(args)
 end
 ^
-  end
+        end
 
-  desc 'version', 'Print version of the OpenNebula probe set'
-  def version
-    puts Nagios::Promoo::Opennebula::VERSION
+        desc 'version', 'Print version of the OpenNebula probe set'
+        def version
+          puts Nagios::Promoo::Opennebula::VERSION
+        end
+      end
+    end
   end
 end

data/lib/nagios/promoo/opennebula/probes/base_probe.rb

@@ -1,18 +1,41 @@
-class Nagios::Promoo::Opennebula::Probes::BaseProbe
-  class << self
-    def runnable?; false; end
-  end
+module Nagios
+  module Promoo
+    module Opennebula
+      module Probes
+        # Base probe for all ONe-related probes.
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class BaseProbe
+          class << self
+            def runnable?
+              false
+            end
+          end
 
-  attr_reader :options
+          attr_reader :options
 
-  def initialize(options)
-    @options = options
-  end
+          def initialize(options)
+            @options = options
+          end
+
+          def client
+            return @_client if @_client
+
+            token = token_file? ? read_token : options[:token]
+            @_client = OpenNebula::Client.new(token.to_s, options[:endpoint])
+          end
+
+          private
 
-  def client
-    return @_client if @_client
+          def token_file?
+            options[:token].start_with?('file://')
+          end
 
-    token = options[:token].start_with?('file://') ? File.read(options[:token].gsub('file://', '')) : options[:token]
-    @_client = OpenNebula::Client.new("#{token}", options[:endpoint])
+          def read_token
+            File.read(options[:token].gsub('file://', ''))
+          end
+        end
+      end
+    end
   end
 end

data/lib/nagios/promoo/opennebula/probes/virtual_machine_probe.rb

@@ -1,106 +1,144 @@
 # Internal deps
 require File.join(File.dirname(__FILE__), 'base_probe')
 
-class Nagios::Promoo::Opennebula::Probes::VirtualMachineProbe < Nagios::Promoo::Opennebula::Probes::BaseProbe
-  class << self
-    def description
-      ['virtual-machine', 'Run a probe instantiating a test instance in OpenNebula']
-    end
-
-    def options
-      [
-        [:template, { type: :string, default: 'monitoring', desc: 'Name referencing a template used for monitoring purposes' }],
-        [:vm_timeout, { type: :numeric, default: 180, desc: 'Timeout for VM instantiation (in seconds)' }],
-        [:cleanup, { type: :boolean, default: true, desc: 'Perform clean-up before launching a new instance' }],
-      ]
-    end
-
-    def declaration
-      "virtual_machine"
-    end
-
-    def runnable?; true; end
-  end
-
-  VM_NAME_PREFIX = "nagios-promoo"
-
-  def run(args = [])
-    fail "Timeout (#{options[:timeout]}) must be higher than "\
-         "vm-timeout (#{options[:vm_timeout]}) " if options[:timeout] <= options[:vm_timeout]
-
-    @_virtual_machine = nil
-
-    Timeout::timeout(options[:timeout]) {
-      cleanup if options[:cleanup]
-      create
-      wait4running
-    }
-
-    puts "VirtualMachine OK - Instance #{@_virtual_machine.id.inspect} of template "\
-         "#{options[:template].inspect} successfully created & cleaned up"
-  rescue => ex
-    puts "VirtualMachine CRITICAL - #{ex.message}"
-    puts ex.backtrace if options[:debug]
-    exit 2
-  ensure
-    begin
-      cleanup @_virtual_machine unless @_virtual_machine.blank?
-    rescue => ex
-      ## ignoring
-    end
-  end
-
-  private
-
-  def cleanup(virtual_machine = nil)
-    virtual_machine ? shutdown_or_delete(virtual_machine) : search_and_destroy
-  end
-
-  def create
-    template_pool = OpenNebula::TemplatePool.new(client)
-    rc = template_pool.info_all
-    fail rc.message if OpenNebula.is_error?(rc)
-
-    template = template_pool.select { |tpl| tpl.name == options[:template] }.first
-    fail "Template #{options[:template].inspect} could not be found" unless template
-
-    vm_id = template.instantiate("#{VM_NAME_PREFIX}-#{Time.now.to_i}")
-    fail vm_id.message if OpenNebula.is_error?(vm_id)
-
-    virtual_machine = OpenNebula::VirtualMachine.new(OpenNebula::VirtualMachine.build_xml(vm_id), client)
-    rc = virtual_machine.info
-    fail rc.message if OpenNebula.is_error?(rc)
-
-    @_virtual_machine = virtual_machine
-  end
-
-  def wait4running
-    Timeout::timeout(options[:vm_timeout]) {
-      while @_virtual_machine.lcm_state_str != 'RUNNING' do
-        fail 'Instance deployment failed (resulting state is "*_FAILED")' if @_virtual_machine.lcm_state_str.include?('FAILURE')
-        rc = @_virtual_machine.info
-        fail rc.message if OpenNebula.is_error?(rc)
+module Nagios
+  module Promoo
+    module Opennebula
+      module Probes
+        # Probe for checking VM instantiation via ONe RPC2.
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class VirtualMachineProbe < Nagios::Promoo::Opennebula::Probes::BaseProbe
+          class << self
+            def description
+              ['virtual-machine', 'Run a probe instantiating a test instance in OpenNebula']
+            end
+
+            def options
+              [
+                [
+                  :template,
+                  {
+                    type: :string, default: 'monitoring',
+                    desc: 'Name referencing a template used for monitoring purposes'
+                  }
+                ],
+                [
+                  :vm_timeout,
+                  {
+                    type: :numeric, default: 180,
+                    desc: 'Timeout for VM instantiation (in seconds)'
+                  }
+                ],
+                [
+                  :cleanup,
+                  {
+                    type: :boolean, default: true,
+                    desc: 'Perform clean-up before launching a new instance'
+                  }
+                ]
+              ]
+            end
+
+            def declaration
+              'virtual_machine'
+            end
+
+            def runnable?
+              true
+            end
+          end
+
+          VM_NAME_PREFIX = 'nagios-promoo'.freeze
+
+          def run(_args = [])
+            if options[:timeout] <= options[:vm_timeout]
+              raise "Timeout (#{options[:timeout]}) must be higher than "\
+                   "vm-timeout (#{options[:vm_timeout]}) "
+            end
+
+            @_virtual_machine = nil
+
+            Timeout.timeout(options[:timeout]) do
+              cleanup if options[:cleanup]
+              create
+              wait4running
+            end
+
+            puts "VirtualMachine OK - Instance #{@_virtual_machine.id.inspect} of template "\
+                 "#{options[:template].inspect} successfully created & cleaned up"
+          rescue => ex
+            puts "VirtualMachine CRITICAL - #{ex.message}"
+            puts ex.backtrace if options[:debug]
+            exit 2
+          ensure
+            begin
+              cleanup @_virtual_machine unless @_virtual_machine.blank?
+            rescue => ex
+              puts "VirtualMachine CRITICAL - #{ex.message}"
+              puts ex.backtrace if options[:debug]
+              exit 2
+            end
+          end
+
+          private
+
+          def cleanup(virtual_machine = nil)
+            virtual_machine ? shutdown_or_delete(virtual_machine) : search_and_destroy
+          end
+
+          def create
+            template_pool = OpenNebula::TemplatePool.new(client)
+            rc = template_pool.info_all
+            raise rc.message if OpenNebula.is_error?(rc)
+
+            template = template_pool.select { |tpl| tpl.name == options[:template] }.first
+            raise "Template #{options[:template].inspect} could not be found" unless template
+
+            vm_id = template.instantiate("#{VM_NAME_PREFIX}-#{Time.now.to_i}")
+            raise vm_id.message if OpenNebula.is_error?(vm_id)
+
+            virtual_machine = OpenNebula::VirtualMachine.new(OpenNebula::VirtualMachine.build_xml(vm_id), client)
+            rc = virtual_machine.info
+            raise rc.message if OpenNebula.is_error?(rc)
+
+            @_virtual_machine = virtual_machine
+          end
+
+          def wait4running
+            Timeout.timeout(options[:vm_timeout]) do
+              while @_virtual_machine.lcm_state_str != 'RUNNING'
+                if @_virtual_machine.lcm_state_str.include?('FAILURE')
+                  raise 'Instance deployment failed (resulting state is "*_FAILED")'
+                end
+
+                rc = @_virtual_machine.info
+                raise rc.message if OpenNebula.is_error?(rc)
+              end
+            end
+          rescue Timeout::Error
+            puts 'VirtualMachine WARNING - Execution timed out while waiting for ' \
+                 "the instance to become active [#{options[:vm_timeout]}s]"
+            exit 1
+          end
+
+          def search_and_destroy
+            vm_pool = OpenNebula::VirtualMachinePool.new(client)
+            rc = vm_pool.info_mine
+            raise rc.message if OpenNebula.is_error?(rc)
+
+            candidates = vm_pool.select { |vm| vm.name.start_with?(VM_NAME_PREFIX) }
+            candidates.each { |vm| shutdown_or_delete(vm) }
+
+            candidates.count
+          end
+
+          def shutdown_or_delete(virtual_machine)
+            rc = virtual_machine.terminate true
+            raise rc.message if OpenNebula.is_error?(rc)
+          end
+        end
       end
-    }
-  rescue Timeout::Error => ex
-    puts "VirtualMachine WARNING - Execution timed out while waiting for " \
-         "the instance to become active [#{options[:vm_timeout]}s]"
-    exit 1
-  end
-
-  def search_and_destroy
-    vm_pool = OpenNebula::VirtualMachinePool.new(client)
-    rc = vm_pool.info_mine
-    fail rc.message if OpenNebula.is_error?(rc)
-
-    candidates = vm_pool.select { |vm| vm.name.start_with?(VM_NAME_PREFIX) }
-    candidates.each { |vm| shutdown_or_delete(vm) }
-
-    candidates.count
-  end
-
-  def shutdown_or_delete(virtual_machine)
-    rc = virtual_machine.terminate true
-    fail rc.message if OpenNebula.is_error?(rc)
+    end
   end
 end