choria-mcorpc-support 2.22.0 → 2.23.2

data/lib/mcollective/rpc/progress.rb

@@ -13,7 +13,7 @@ module MCollective
     #  * [ ==================================================> ] 100 / 100
     class Progress
       def initialize(size=nil)
-        @twirl = ['|', '/', '-', "\\", '|', '/', '-', "\\"]
+        @twirl = ["|", "/", "-", "\\", "|", "/", "-", "\\"]
         @twirldex = 0
 
         if size
@@ -56,7 +56,7 @@ module MCollective
 
         @twirldex == 7 ? @twirldex = 0 : @twirldex += 1
 
-        return txt
+        txt
       end
     end
   end

data/lib/mcollective/rpc/reply.rb

@@ -13,19 +13,17 @@ module MCollective
 
         begin
           initialize_data
-        rescue Exception => e
-          Log.warn("Could not pre-populate reply data from the DDL: %s: %s" % [e.class, e.to_s ])
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Log.warn("Could not pre-populate reply data from the DDL: %s: %s" % [e.class, e.to_s])
         end
       end
 
       def initialize_data
-        unless @ddl.actions.include?(@action)
-          raise "No action '%s' defined for agent '%s' in the DDL" % [@action, @ddl.pluginname]
-        end
+        raise "No action '%s' defined for agent '%s' in the DDL" % [@action, @ddl.pluginname] unless @ddl.actions.include?(@action)
 
         interface = @ddl.action_interface(@action)
 
-        interface[:output].keys.each do |output|
+        interface[:output].each_key do |output|
           # must deep clone this data to avoid accidental updates of the DDL in cases where the
           # default is for example a string and someone does << on it
           @data[output] = Marshal.load(Marshal.dump(interface[:output][output].fetch(:default, nil)))
@@ -44,20 +42,20 @@ module MCollective
         @statuscode = code
 
         case code
-          when 1
-            raise RPCAborted, msg
+        when 1
+          raise RPCAborted, msg
 
-          when 2
-            raise UnknownRPCAction, msg
+        when 2
+          raise UnknownRPCAction, msg
 
-          when 3
-            raise MissingRPCData, msg
+        when 3
+          raise MissingRPCData, msg
 
-          when 4
-            raise InvalidRPCData, msg
+        when 4
+          raise InvalidRPCData, msg
 
-          else
-            raise UnknownRPCError, msg
+        else
+          raise UnknownRPCError, msg
         end
       end
 
@@ -78,9 +76,9 @@ module MCollective
       # Returns a compliant Hash of the reply that should be sent
       # over the middleware
       def to_hash
-        return {:statuscode => @statuscode,
-                :statusmsg => @statusmsg,
-                :data => @data}
+        {:statuscode => @statuscode,
+         :statusmsg => @statusmsg,
+         :data => @data}
       end
     end
   end

data/lib/mcollective/rpc/request.rb

@@ -57,12 +57,14 @@ module MCollective
       # If data is a hash, gives easy access to its members, else returns nil
       def [](key)
         return nil unless @data.is_a?(Hash)
-        return @data[compatible_key(key)]
+
+        @data[compatible_key(key)]
       end
 
       def fetch(key, default)
         return nil unless @data.is_a?(Hash)
-        return @data.fetch(compatible_key(key), default)
+
+        @data.fetch(compatible_key(key), default)
       end
 
       def to_hash
@@ -76,10 +78,10 @@ module MCollective
         @ddl.validate_rpc_request(@action, @data)
       end
 
-      def to_json
-        to_hash.merge!({:sender   => @sender,
+      def to_json(*_args)
+        to_hash.merge!({:sender => @sender,
                         :callerid => @callerid,
-                        :uniqid   => @uniqid}).to_json
+                        :uniqid => @uniqid}).to_json
       end
     end
   end

data/lib/mcollective/rpc/result.rb

@@ -40,12 +40,10 @@ module MCollective
 
         return if interface.fetch(:output, {}).empty?
 
-        interface[:output].each do |output, properties|
+        interface[:output].each do |output, _properties|
           next if data.include?(output)
 
-          if output.is_a?(Symbol) && data.include?(output.to_s)
-            data[output] = data.delete(output.to_s)
-          end
+          data[output] = data.delete(output.to_s) if output.is_a?(Symbol) && data.include?(output.to_s)
         end
       end
 
@@ -69,17 +67,17 @@ module MCollective
         @results.fetch(compatible_key(key), default)
       end
 
-      def each
-        @results.each_pair {|k,v| yield(k,v) }
+      def each(&block)
+        @results.each_pair(&block)
       end
 
-      def to_json(*a)
+      def to_json(*result)
         {:agent => @agent,
          :action => @action,
          :sender => self[:sender],
          :statuscode => self[:statuscode],
          :statusmsg => self[:statusmsg],
-         :data => data}.to_json(*a)
+         :data => data}.to_json(*result)
       end
 
       def <=>(other)

data/lib/mcollective/rpc/stats.rb

@@ -2,9 +2,8 @@ module MCollective
   module RPC
     # Class to wrap all the stats and to keep track of some timings
     class Stats
-      attr_accessor :noresponsefrom, :unexpectedresponsefrom, :starttime, :discoverytime, :blocktime, :responses
-      attr_accessor :totaltime, :discovered, :discovered_nodes, :okcount, :failcount, :noresponsefrom
-      attr_accessor :responsesfrom, :requestid, :aggregate_summary, :ddl, :aggregate_failures
+      attr_accessor :noresponsefrom, :unexpectedresponsefrom, :starttime, :discoverytime, :blocktime, :responses, :totaltime, :discovered, :discovered_nodes, :okcount,
+                    :failcount, :responsesfrom, :requestid, :aggregate_summary, :ddl, :aggregate_failures
 
       def initialize
         reset
@@ -17,7 +16,7 @@ module MCollective
         @responsesfrom = []
         @responses = 0
         @starttime = Time.now.to_f
-        @discoverytime = 0 unless @discoverytime
+        @discoverytime ||= 0
         @blocktime = 0
         @totaltime = 0
         @discovered = 0
@@ -31,18 +30,18 @@ module MCollective
 
       # returns a hash of our stats
       def to_hash
-        {:noresponsefrom    => @noresponsefrom,
+        {:noresponsefrom => @noresponsefrom,
          :unexpectedresponsefrom => @unexpectedresponsefrom,
-         :starttime         => @starttime,
-         :discoverytime     => @discoverytime,
-         :blocktime         => @blocktime,
-         :responses         => @responses,
-         :totaltime         => @totaltime,
-         :discovered        => @discovered,
-         :discovered_nodes  => @discovered_nodes,
-         :okcount           => @okcount,
-         :requestid         => @requestid,
-         :failcount         => @failcount,
+         :starttime => @starttime,
+         :discoverytime => @discoverytime,
+         :blocktime => @blocktime,
+         :responses => @responses,
+         :totaltime => @totaltime,
+         :discovered => @discovered,
+         :discovered_nodes => @discovered_nodes,
+         :okcount => @okcount,
+         :requestid => @requestid,
+         :failcount => @failcount,
          :aggregate_summary => @aggregate_summary,
          :aggregate_failures => @aggregate_failures}
       end
@@ -82,9 +81,10 @@ module MCollective
 
       # Utility to time discovery from :start to :end
       def time_discovery(action)
-        if action == :start
+        case action
+        when :start
           @discovery_start = Time.now.to_f
-        elsif action == :end
+        when :end
           @discoverytime = Time.now.to_f - @discovery_start
         else
           raise("Uknown discovery action #{action}")
@@ -95,9 +95,10 @@ module MCollective
 
       # helper to time block execution time
       def time_block_execution(action)
-        if action == :start
+        case action
+        when :start
           @block_start = Time.now.to_f
-        elsif action == :end
+        when :end
           @blocktime += Time.now.to_f - @block_start
         else
           raise("Uknown block action #{action}")
@@ -156,16 +157,16 @@ module MCollective
 
           result.puts Util.colorize(:bold, "Summary of %s:" % display_as)
           result.puts
-          unless aggregate_report == ""
-            result.puts aggregate.to_s.split("\n").map{|x| "   " + x}.join("\n")
-          else
+          if aggregate_report == ""
             result.puts Util.colorize(:yellow, "     No aggregate summary could be computed")
+          else
+            result.puts aggregate.to_s.split("\n").map {|x| "   #{x}"}.join("\n")
           end
           result.puts
         end
 
         @aggregate_failures.each do |failed|
-          case(failed[:type])
+          case (failed[:type])
           when :startup
             message = "exception raised while processing startup hook"
           when :create
@@ -187,65 +188,55 @@ module MCollective
 
       # Returns a blob of text representing the request status based on the
       # stats contained in this class
-      def report(caption = "rpc stats", summarize = true, verbose = false)
+      def report(caption="rpc stats", summarize=true, verbose=false)
         result_text = []
 
         if verbose
-            if @aggregate_summary.size > 0 && summarize
-              result_text << text_for_aggregates
-            else
-              result_text << ""
-            end
+          if !@aggregate_summary.empty? && summarize
+            result_text << text_for_aggregates
+          else
+            result_text << ""
+          end
 
           result_text << Util.colorize(:yellow, "---- #{caption} ----")
 
           if @discovered
             @responses < @discovered ? color = :red : color = :reset
-            result_text << "           Nodes: %s / %s" % [ Util.colorize(color, @discovered), Util.colorize(color, @responses) ]
+            result_text << "           Nodes: %s / %s" % [Util.colorize(color, @discovered), Util.colorize(color, @responses)]
           else
             result_text << "           Nodes: #{@responses}"
           end
 
           @failcount < 0 ? color = :red : color = :reset
 
-          result_text << "     Pass / Fail: %s / %s" % [Util.colorize(color, @okcount), Util.colorize(color, @failcount) ]
+          result_text << "     Pass / Fail: %s / %s" % [Util.colorize(color, @okcount), Util.colorize(color, @failcount)]
           result_text << "      Start Time: %s"      % [Time.at(@starttime)]
           result_text << "  Discovery Time: %.2fms"  % [@discoverytime * 1000]
           result_text << "      Agent Time: %.2fms"  % [@blocktime * 1000]
           result_text << "      Total Time: %.2fms"  % [@totaltime * 1000]
-        else
-          if @discovered
-            @responses < @discovered ? color = :red : color = :green
-
-            if @aggregate_summary.size + @aggregate_failures.size > 0 && summarize
-              result_text << text_for_aggregates
-            else
-              result_text << ""
-            end
+        elsif @discovered
+          @responses < @discovered ? color = :red : color = :green
 
-            result_text << "Finished processing %s / %s hosts in %.2f ms" % [Util.colorize(color, @responses), Util.colorize(color, @discovered), @blocktime * 1000]
+          if @aggregate_summary.size + @aggregate_failures.size > 0 && summarize
+            result_text << text_for_aggregates
           else
-            result_text << "Finished processing %s hosts in %.2f ms" % [Util.colorize(:bold, @responses), @blocktime * 1000]
+            result_text << ""
           end
+
+          result_text << "Finished processing %s / %s hosts in %.2f ms" % [Util.colorize(color, @responses), Util.colorize(color, @discovered), @blocktime * 1000]
+        else
+          result_text << "Finished processing %s hosts in %.2f ms" % [Util.colorize(:bold, @responses), @blocktime * 1000]
         end
 
         no_response_r = no_response_report
         unexpected_response_r = unexpected_response_report
-        if no_response_r || unexpected_response_r
-          result_text << ""
-        end
+        result_text << "" if no_response_r || unexpected_response_r
 
-        if no_response_r != ""
-          result_text << "" << no_response_r
-        end
+        result_text << "" << no_response_r if no_response_r != ""
 
-        if unexpected_response_r != ""
-          result_text << "" << unexpected_response_r
-        end
+        result_text << "" << unexpected_response_r if unexpected_response_r != ""
 
-        if no_response_r || unexpected_response_r
-          result_text << ""
-        end
+        result_text << "" if no_response_r || unexpected_response_r
 
         result_text.join("\n")
       end
@@ -254,13 +245,13 @@ module MCollective
       def no_response_report
         result_text = StringIO.new
 
-        if @noresponsefrom.size > 0
+        unless @noresponsefrom.empty?
           result_text.puts Util.colorize(:red, "No response from:")
           result_text.puts
 
           field_size = Util.field_size(@noresponsefrom, 30)
           fields_num = Util.field_number(field_size)
-          format = "   " + ( " %-#{field_size}s" * fields_num )
+          format = "   #{" %-#{field_size}s" * fields_num}"
 
           @noresponsefrom.sort.in_groups_of(fields_num) do |c|
             result_text.puts format % c
@@ -274,13 +265,13 @@ module MCollective
       def unexpected_response_report
         result_text = StringIO.new
 
-        if @unexpectedresponsefrom.size > 0
+        unless @unexpectedresponsefrom.empty?
           result_text.puts Util.colorize(:red, "Unexpected response from:")
           result_text.puts
 
           field_size = Util.field_size(@unexpectedresponsefrom, 30)
           fields_num = Util.field_number(field_size)
-          format = "   " + ( " %-#{field_size}s" * fields_num )
+          format = "   #{" %-#{field_size}s" * fields_num}"
 
           @unexpectedresponsefrom.sort.in_groups_of(fields_num) do |c|
             result_text.puts format % c

data/lib/mcollective/security/base.rb

@@ -25,12 +25,12 @@ module MCollective
     # that takes care of encoding the core requirements.  The best place to see how security
     # works is by looking at the provided MCollective::Security::PSK plugin.
     class Base
-      attr_reader :stats
       attr_accessor :initiated_by
 
       # Register plugins that inherits base
       def self.inherited(klass)
         PluginManager << {:type => "security_plugin", :class => klass.to_s}
+        super
       end
 
       # Initializes configuration and logging as well as prepare a zero'd hash of stats
@@ -38,7 +38,6 @@ module MCollective
       def initialize
         @config = Config.instance
         @log = Log
-        @stats = PluginManager["global_stats"]
       end
 
       # Takes a Hash with a filter in it and validates it against host information.
@@ -52,18 +51,18 @@ module MCollective
       # - identity - the configured identity of the system
       #
       # TODO: Support REGEX and/or multiple filter keys to be AND'd
-      def validate_filter?(filter)
+      def validate_filter?(filter) # rubocop:disable Metrics/MethodLength
         failed = 0
         passed = 0
 
         passed = 1 if Util.empty_filter?(filter)
 
-        filter.keys.each do |key|
+        filter.each_key do |key|
           case key
           when /puppet_class|cf_class/
             filter[key].each do |f|
               Log.debug("Checking for class #{f}")
-              if Util.has_cf_class?(f) then
+              if Util.has_cf_class?(f)
                 Log.debug("Passing based on configuration management class #{f}")
                 passed += 1
               else
@@ -73,43 +72,7 @@ module MCollective
             end
 
           when "compound"
-            filter[key].each do |compound|
-              result = false
-              truth_values = []
-
-              begin
-                compound.each do |expression|
-                  case expression.keys.first
-                    when "statement"
-                      truth_values << Matcher.eval_compound_statement(expression).to_s
-                    when "fstatement"
-                      truth_values << Matcher.eval_compound_fstatement(expression.values.first)
-                    when "and"
-                      truth_values << "&&"
-                    when "or"
-                      truth_values << "||"
-                    when "("
-                      truth_values << "("
-                    when ")"
-                      truth_values << ")"
-                    when "not"
-                      truth_values << "!"
-                  end
-                end
-
-                result = eval(truth_values.join(" "))
-              rescue DDLValidationError
-                result = false
-              end
-
-              if result
-                Log.debug("Passing based on class and fact composition")
-                passed +=1
-              else
-                Log.debug("Failing based on class and fact composition")
-                failed +=1
-              end
-            end
+            # removed while rebuilding compound filters, this whole method is probably unused now
 
           when "agent"
             filter[key].each do |f|
@@ -136,7 +99,7 @@ module MCollective
           when "identity"
             unless filter[key].empty?
               # Identity filters should not be 'and' but 'or' as each node can only have one identity
-              matched = filter[key].select{|f| Util.has_identity?(f)}.size
+              matched = filter[key].select {|f| Util.has_identity?(f)}.size
 
               if matched == 1
                 Log.debug("Passing based on identity")
@@ -152,15 +115,11 @@ module MCollective
         if failed == 0 && passed > 0
           Log.debug("Message passed the filter checks")
 
-          @stats.passed
-
-          return true
+          true
         else
           Log.debug("Message failed the filter checks")
 
-          @stats.filtered
-
-          return false
+          false
         end
       end
 
@@ -194,12 +153,10 @@ module MCollective
       # Mostly used by security plugins to figure out if they should do the hard work of decrypting
       # etc messages that would only later on be ignored
       def should_process_msg?(msg, msgid)
-        if msg.expected_msgid
-          unless msg.expected_msgid == msgid
-            msgtext = "Got a message with id %s but was expecting %s, ignoring message" % [msgid, msg.expected_msgid]
-            Log.debug msgtext
-            raise MsgDoesNotMatchRequestID, msgtext
-          end
+        if msg.expected_msgid && msg.expected_msgid != msgid
+          msgtext = "Got a message with id %s but was expecting %s, ignoring message" % [msgid, msg.expected_msgid]
+          Log.debug msgtext
+          raise MsgDoesNotMatchRequestID, msgtext
         end
 
         true
@@ -211,7 +168,7 @@ module MCollective
       # callerids are generally in the form uid=123 or cert=foo etc so we do that
       # here but security plugins could override this for some complex uses
       def valid_callerid?(id)
-        !!id.match(/^[\w]+=[\w\.\-]+$/)
+        !!id.match(/^\w+=[\w.\-]+$/)
       end
 
       # Returns a unique id for the caller, by default we just use the unix