choria-mcorpc-support 2.20.3 → 2.20.4

data/lib/mcollective/data.rb

@@ -12,8 +12,8 @@ module MCollective
             Log.debug("Disabling data plugin %s due to plugin activation policy" % plugin)
             PluginManager.delete(plugin)
           end
-        rescue Exception => e
-          Log.debug("Disabling data plugin %s due to exception #{e.class}: #{e}" % plugin)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Log.debug("Disabling data plugin %s due to exception %s: %s" % [plugin, e.class, e])
           PluginManager.delete(plugin)
         end
       end
@@ -28,7 +28,7 @@ module MCollective
     end
 
     # Data.package("httpd").architecture
-    def self.method_missing(method, *args)
+    def self.method_missing(method, *args) # rubocop:disable Style/MethodMissing:
       super unless PluginManager.include?(pluginname(method))
 
       PluginManager[pluginname(method)].lookup(args.first)
@@ -76,16 +76,16 @@ module MCollective
         type = ddl.entities[:data][:input][:query][:type]
 
         case type
-          when :boolean
-            return DDL.string_to_boolean(input)
+        when :boolean
+          return DDL.string_to_boolean(input)
 
-          when :number, :integer, :float
-            return DDL.string_to_number(input)
+        when :number, :integer, :float
+          return DDL.string_to_number(input)
         end
-      rescue
+      rescue # rubocop:disable Lint/HandleExceptions
       end
 
-      return input
+      input
     end
   end
 end

data/lib/mcollective/ddl.rb

@@ -85,7 +85,7 @@ module MCollective
         ddl = Cache.write(:ddl, path, klass.new(*args))
       end
 
-      return ddl
+      ddl
     end
 
     # As we're taking arguments on the command line we need a

data/lib/mcollective/discovery.rb

@@ -33,7 +33,7 @@ module MCollective
         raise "Custom discovery methods require direct addressing mode" unless Config.instance.direct_addressing
       end
 
-      return method
+      method
     end
 
     def discovery_class
@@ -53,7 +53,7 @@ module MCollective
         @ddl = DDL.new(discovery_method, :discovery)
       end
 
-      return @ddl
+      @ddl
     end
 
     # Agent filters are always present no matter what, so we cant raise an error if the capabilities
@@ -90,7 +90,7 @@ module MCollective
         end
       end
 
-      return false
+      false
     end
 
     # if a compound filter is specified and it has any function
@@ -103,11 +103,11 @@ module MCollective
 
       compound_filter.each do |filter|
         filter.each do |statement|
-          if statement["fstatement"]
-            pluginname = Data.pluginname(statement["fstatement"]["name"])
-            ddl = DDL.new(pluginname, :data)
-            timeout += ddl.meta[:timeout]
-          end
+          next unless statement["fstatement"]
+
+          pluginname = Data.pluginname(statement["fstatement"]["name"])
+          ddl = DDL.new(pluginname, :data)
+          timeout += ddl.meta[:timeout]
         end
       end
 
@@ -115,12 +115,12 @@ module MCollective
     end
 
     def discovery_timeout(timeout, filter)
-      timeout = ddl.meta[:timeout] unless timeout
+      timeout ||= ddl.meta[:timeout]
 
-      unless (filter["compound"] && filter["compound"].empty?)
-        timeout + timeout_for_compound_filter(filter["compound"])
-      else
+      if filter["compound"] && filter["compound"].empty?
         timeout
+      else
+        timeout + timeout_for_compound_filter(filter["compound"])
       end
     end
 
@@ -134,7 +134,7 @@ module MCollective
       discovered = discovery_class.discover(filter, discovery_timeout(timeout, filter), limit, @client)
 
       if limit > 0
-        return discovered[0,limit]
+        return discovered[0, limit]
       else
         return discovered
       end

data/lib/mcollective/exceptions.rb

@@ -1,28 +1,28 @@
 module MCollective
-# Exceptions for the RPC system
-  class DDLValidationError<RuntimeError;end
-  class ValidatorError<RuntimeError; end
-  class ClientTimeoutError<RuntimeError; end
+  # Exceptions for the RPC system
+  class DDLValidationError < RuntimeError; end
+  class ValidatorError < RuntimeError; end
+  class ClientTimeoutError < RuntimeError; end
   class MsgDoesNotMatchRequestID < RuntimeError; end
-  class MsgTTLExpired<RuntimeError;end
-  class NotTargettedAtUs<RuntimeError;end
-  class RPCError<StandardError;end
-  class SecurityValidationFailed<RuntimeError;end
+  class MsgTTLExpired < RuntimeError; end
+  class NotTargettedAtUs < RuntimeError; end
+  class RPCError < StandardError; end
+  class SecurityValidationFailed < RuntimeError; end
 
-  class BackoffSuggestion<StandardError
+  class BackoffSuggestion < StandardError
     attr_reader :backoff
 
-    def initialize(backoff = nil)
+    def initialize(backoff=nil)
       @backoff = backoff
     end
   end
 
-  class MessageNotReceived<BackoffSuggestion; end
-  class UnexpectedMessageType<BackoffSuggestion; end
+  class MessageNotReceived < BackoffSuggestion; end
+  class UnexpectedMessageType < BackoffSuggestion; end
 
-  class InvalidRPCData<RPCError;end
-  class MissingRPCData<RPCError;end
-  class RPCAborted<RPCError;end
-  class UnknownRPCAction<RPCError;end
-  class UnknownRPCError<RPCError;end
+  class InvalidRPCData < RPCError; end
+  class MissingRPCData < RPCError; end
+  class RPCAborted < RPCError; end
+  class UnknownRPCAction < RPCError; end
+  class UnknownRPCError < RPCError; end
 end

data/lib/mcollective/facts.rb

@@ -19,11 +19,11 @@ module MCollective
   module Facts
     require "mcollective/facts/base"
 
-    @@config = nil
+    @@config = nil # rubocop:disable Style/ClassVars
 
     # True if we know of a specific fact else false
     def self.has_fact?(fact, value)
-      PluginManager["facts_plugin"].get_fact(fact) == value ? true : false
+      PluginManager["facts_plugin"].get_fact(fact) == value
     end
 
     # Get the value of a fact

data/lib/mcollective/log.rb

@@ -46,9 +46,7 @@ module MCollective
 
       # reopen log files
       def reopen
-        if @configured
-          @logger.reopen
-        end
+        @logger.reopen if @configured
       end
 
       # logs a message at a certain level
@@ -67,7 +65,7 @@ module MCollective
       end
 
       # sets the logger class to use
-      def set_logger(logger)
+      def set_logger(logger) # rubocop:disable Naming/AccessorMethodName
         @logger = logger
       end
 
@@ -77,7 +75,10 @@ module MCollective
       # the logger till we eventually get a logging preference from the config
       # module
       def configure(logger=nil)
-        unless logger
+        if logger
+          set_logger(logger)
+          @configured = true
+        else
           logger_type = "console"
 
           config = Config.instance
@@ -92,13 +93,10 @@ module MCollective
           logger_class = MCollective::Logger.const_get("#{logger_type.capitalize}_logger")
 
           set_logger(logger_class.new)
-        else
-          set_logger(logger)
-          @configured = true
         end
 
         @logger.start
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         @configured = false
         STDERR.puts "Could not start logger: #{e.class} #{e}"
       end

data/lib/mcollective/matcher.rb

@@ -23,7 +23,7 @@ module MCollective
       func = func_parts.join
 
       # Deal with dots in function parameters and functions without dot values
-      if func.match(/^.+\(.*\)$/)
+      if func =~ /^.+\(.*\)$/
         f = func
       else
         func_parts = func.split(".")
@@ -55,14 +55,14 @@ module MCollective
         func_quotes = func_hash["params"].split(/('|")/)
 
         func_quotes.each_with_index do |item, i|
-          if item.match(/'|"/)
+          if item =~ /'|"/
             func_quotes.delete_at(i)
             break
           end
         end
 
-        func_quotes.reverse.each_with_index do |item,i|
-          if item.match(/'|"/)
+        func_quotes.reverse.each_with_index do |item, i|
+          if item =~ /'|"/
             func_quotes.delete_at(func_quotes.size - i - 1)
             break
           end
@@ -107,47 +107,43 @@ module MCollective
         return result
       end
     rescue NoMethodError
-      Log.debug("cannot execute discovery function '#{function_hash["name"]}'. data plugin not found")
+      Log.debug("cannot execute discovery function '#{function_hash['name']}'. data plugin not found")
       raise DDLValidationError
     end
 
     # Evaluates a compound statement
     def self.eval_compound_statement(expression)
       if expression.values.first =~ /^\//
-        return Util.has_cf_class?(expression.values.first)
+        Util.has_cf_class?(expression.values.first)
       elsif expression.values.first =~ />=|<=|=|<|>/
         optype = expression.values.first.match(/>=|<=|=|<|>/)
         name, value = expression.values.first.split(optype[0])
-        unless value.split("")[0] == "/"
-          optype[0] == "=" ? optype = "==" : optype = optype[0]
-        else
+        if value.split("")[0] == "/"
           optype = "=~"
+        else
+          optype[0] == "=" ? optype = "==" : optype = optype[0]
         end
 
-        return Util.has_fact?(name,value, optype).to_s
+        Util.has_fact?(name, value, optype).to_s
       else
-        return Util.has_cf_class?(expression.values.first)
+        Util.has_cf_class?(expression.values.first)
       end
     end
 
     # Returns the result of an evaluated compound statement that
     # includes a function
-    def self.eval_compound_fstatement(function_hash)
+    def self.eval_compound_fstatement(function_hash) # rubocop:disable Metrics/MethodLength
       l_compare = execute_function(function_hash)
       r_compare = function_hash["r_compare"]
       operator = function_hash["operator"]
 
       # Break out early and return false if the function returns nil
-      if l_compare.nil?
-        return false
-      end
+      return false if l_compare.nil?
 
       # Prevent unwanted discovery by limiting comparison operators
       # on Strings and Booleans
-      if((l_compare.is_a?(String) || l_compare.is_a?(TrueClass) ||
-          l_compare.is_a?(FalseClass)) && function_hash["operator"].match(/<|>/))
-        Log.debug("Cannot do > and < comparison on Booleans and Strings " +
-                  "'#{l_compare} #{function_hash["operator"]} #{function_hash["r_compare"]}'")
+      if (l_compare.is_a?(String) || l_compare.is_a?(TrueClass) || l_compare.is_a?(FalseClass)) && function_hash["operator"].match(/<|>/)
+        Log.debug("Cannot do > and < comparison on Booleans and Strings '#{l_compare} #{function_hash['operator']} #{function_hash['r_compare']}'")
         return false
       end
 
@@ -158,12 +154,9 @@ module MCollective
       end
 
       # Do a regex comparison if right compare string is a regex
-      if operator=~ /(=~|!=~)/
+      if operator =~ /(=~|!=~)/
         # Fail if left compare value isn't a string
-        unless l_compare.is_a?(String)
-          Log.debug("Cannot do a regex check on a non string value.")
-          return false
-        else
+        if l_compare.is_a?(String)
           result = l_compare.match(r_compare)
           # Flip return value for != operator
           if function_hash["operator"] == "!=~"
@@ -171,6 +164,9 @@ module MCollective
           else
             return !!result
           end
+        else
+          Log.debug("Cannot do a regex check on a non string value.")
+          return false
         end
         # Otherwise do a normal comparison while taking the type into account
       else
@@ -181,21 +177,21 @@ module MCollective
             r_compare = r_compare.strip
             begin
               r_compare = Integer(r_compare)
-            rescue ArgumentError
+            rescue ArgumentError # rubocop:disable Metrics/BlockNesting
               begin
                 r_compare = Float(r_compare)
-              rescue ArgumentError
-                raise ArgumentError, "invalid numeric value: #{r_compare}"
+              rescue ArgumentError # rubocop:disable Metrics/BlockNesting
+                raise(ArgumentError, "invalid numeric value: #{r_compare}")
               end
             end
-          elsif l_compare.is_a? TrueClass or l_compare.is_a? FalseClass
+          elsif l_compare.is_a?(TrueClass) || l_compare.is_a?(FalseClass)
             r_compare = r_compare.strip
-            if r_compare == true.to_s
+            if r_compare == true.to_s # rubocop:disable Metrics/BlockNesting
               r_compare = true
-            elsif r_compare == false.to_s
+            elsif r_compare == false.to_s # rubocop:disable Metrics/BlockNesting
               r_compare = false
             else
-              raise ArgumentError, "invalid boolean value: #{r_compare}"
+              raise(ArgumentError, "invalid boolean value: #{r_compare}")
             end
           end
         end
@@ -203,7 +199,7 @@ module MCollective
         if operator =~ /(?:(!=|<=|>=|<|>)|==?)/
           operator = $1 ? $1.to_sym : :==
         else
-          raise ArgumentError, "invalid operator: #{operator}"
+          raise(ArgumentError, "invalid operator: #{operator}")
         end
         result = l_compare.send(operator, r_compare)
         return result

data/lib/mcollective/message.rb

@@ -5,7 +5,7 @@ module MCollective
     attr_accessor :headers, :agent, :collective, :filter
     attr_accessor :requestid, :discovered_hosts, :options, :ttl
 
-    VALIDTYPES = [:message, :request, :direct_request, :reply]
+    VALIDTYPES = [:message, :request, :direct_request, :reply].freeze
 
     # payload                  - the message body without headers etc, just the text
     # message                  - the original message received from the middleware
@@ -20,7 +20,7 @@ module MCollective
     # options[:ttl]            - the maximum amount of seconds this message can be valid for
     # options[:expected_msgid] - in the case of replies this is the msgid it is expecting in the replies
     # options[:requestid]      - specific request id to use else one will be generated
-    def initialize(payload, message, options = {})
+    def initialize(payload, message, options={})
       options = {:base64 => false,
                  :agent => nil,
                  :headers => {},
@@ -140,41 +140,43 @@ module MCollective
 
     def encode!
       case type
-        when :reply
-          raise "Cannot encode a reply message if no request has been associated with it" unless request
-          raise 'callerid in original request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(request.payload[:callerid])
+      when :reply
+        raise "Cannot encode a reply message if no request has been associated with it" unless request
 
-          @requestid = request.payload[:requestid]
-          @payload = PluginManager["security_plugin"].encodereply(agent, payload, requestid, request.payload[:callerid])
-        when :request, :direct_request
-          validate_compound_filter(@filter["compound"]) unless @filter["compound"].empty?
+        unless PluginManager["security_plugin"].valid_callerid?(request.payload[:callerid])
+          raise "callerid in original request is not valid, surpressing reply to potentially forged request"
+        end
 
-          @requestid = create_reqid unless @requestid
-          @payload = PluginManager["security_plugin"].encoderequest(Config.instance.identity, payload, requestid, filter, agent, collective, ttl)
-        else
-          raise "Cannot encode #{type} messages"
+        @requestid = request.payload[:requestid]
+        @payload = PluginManager["security_plugin"].encodereply(agent, payload, requestid, request.payload[:callerid])
+      when :request, :direct_request
+        validate_compound_filter(@filter["compound"]) unless @filter["compound"].empty?
+
+        @requestid ||= create_reqid
+        @payload = PluginManager["security_plugin"].encoderequest(Config.instance.identity, payload, requestid, filter, agent, collective, ttl)
+      else
+        raise "Cannot encode #{type} messages"
       end
     end
 
     def validate_compound_filter(compound_filter)
       compound_filter.each do |filter|
         filter.each do |statement|
-          if statement["fstatement"]
-            functionname = statement["fstatement"]["name"]
-            pluginname = Data.pluginname(functionname)
-            value = statement["fstatement"]["value"]
+          next unless statement["fstatement"]
+          functionname = statement["fstatement"]["name"]
+          pluginname = Data.pluginname(functionname)
+          value = statement["fstatement"]["value"]
 
-            ddl = DDL.new(pluginname, :data)
+          ddl = DDL.new(pluginname, :data)
 
-            # parses numbers and booleans entered as strings into proper
-            # types of data so that DDL validation will pass
-            statement["fstatement"]["params"] = Data.ddl_transform_input(ddl, statement["fstatement"]["params"])
+          # parses numbers and booleans entered as strings into proper
+          # types of data so that DDL validation will pass
+          statement["fstatement"]["params"] = Data.ddl_transform_input(ddl, statement["fstatement"]["params"])
 
-            Data.ddl_validate(ddl, statement["fstatement"]["params"])
+          Data.ddl_validate(ddl, statement["fstatement"]["params"])
 
-            unless value && Data.ddl_has_output?(ddl, value)
-              DDL.validation_fail!(:PLMC41, "Data plugin '%{functionname}()' does not return a '%{value}' value", :error, {:functionname => functionname, :value => value})
-            end
+          unless value && Data.ddl_has_output?(ddl, value)
+            raise(DDLValidationError, "Data plugin '%s()' does not return a '%s' value" % [functionname, value])
           end
         end
       end
@@ -185,7 +187,7 @@ module MCollective
 
       begin
         @payload = PluginManager["security_plugin"].decodemsg(self)
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         if type == :request
           # If we're a server receiving a request, reraise
           raise(e)
@@ -194,13 +196,13 @@ module MCollective
 
           # Note: mc_sender is unverified.  The verified identity is in the
           # payload we just failed to decode
-          Log.warn("Failed to decode a message from '#{headers["mc_sender"]}': #{e}")
+          Log.warn("Failed to decode a message from '#{headers['mc_sender']}': #{e}")
           return
         end
       end
 
       if type == :request
-        raise 'callerid in request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(payload[:callerid])
+        raise "callerid in request is not valid, surpressing reply to potentially forged request" unless PluginManager["security_plugin"].valid_callerid?(payload[:callerid])
       end
 
       [:collective, :agent, :filter, :requestid, :ttl, :msgtime].each do |prop|
@@ -235,7 +237,7 @@ module MCollective
         Log.debug("Handling #{requestid} as a direct request")
       end
 
-      PluginManager['connector_plugin'].publish(self)
+      PluginManager["connector_plugin"].publish(self)
     end
 
     def create_reqid