choria-mcorpc-support 2.21.0 → 2.23.0

data/lib/mcollective/facts/yaml_facts.rb

@@ -1,13 +1,13 @@
 module MCollective
   module Facts
-    require 'yaml'
+    require "yaml"
 
     # A factsource that reads a hash of facts from a YAML file
     #
     # Multiple files can be specified seperated with a : in the
     # config file, they will be merged with later files overriding
     # earlier ones in the list.
-    class Yaml_facts<Base
+    class Yaml_facts < Base
       def initialize
         @yaml_file_mtimes = {}
 
@@ -23,15 +23,15 @@ module MCollective
         fact_files.each do |file|
           begin
             if File.exist?(file)
-	      if YAML.respond_to? :safe_load
-                facts.merge!(YAML.safe_load(File.read(file))) 
-	      else
-                facts.merge!(YAML.load(File.read(file)))  # rubocop:disable Security/YAMLLoad
+              if YAML.respond_to? :safe_load
+                facts.merge!(YAML.safe_load(File.read(file)))
+              else
+                facts.merge!(YAML.load(File.read(file)))
               end
             else
               raise("Can't find YAML file to load: #{file}")
             end
-          rescue Exception => e
+          rescue Exception => e # rubocop:disable Lint/RescueException
             Log.error("Failed to load yaml facts from #{file}: #{e.class}: #{e}")
           end
         end
@@ -49,13 +49,13 @@ module MCollective
           @yaml_file_mtimes[file] ||= File.stat(file).mtime
           mtime = File.stat(file).mtime
 
-          if mtime > @yaml_file_mtimes[file]
-            @yaml_file_mtimes[file] = mtime
+          next unless mtime > @yaml_file_mtimes[file]
 
-            Log.debug("Forcing fact reload due to age of #{file}")
+          @yaml_file_mtimes[file] = mtime
 
-            return true
-          end
+          Log.debug("Forcing fact reload due to age of #{file}")
+
+          return true
         end
 
         false

data/lib/mcollective/generators.rb

@@ -1,7 +1,7 @@
 module MCollective
   module Generators
-    require "mcollective/generators/base.rb"
-    require "mcollective/generators/data_generator.rb"
-    require "mcollective/generators/agent_generator.rb"
+    require "mcollective/generators/base"
+    require "mcollective/generators/data_generator"
+    require "mcollective/generators/agent_generator"
   end
 end

data/lib/mcollective/generators/agent_generator.rb

@@ -1,11 +1,10 @@
 module MCollective
   module Generators
-    class AgentGenerator<Base
-
+    class AgentGenerator < Base
       attr_accessor :ddl, :content
 
-      def initialize(plugin_name, actions = [],  name = nil, description = nil, author = nil ,
-                     license = nil, version = nil, url = nil, timeout = nil)
+      def initialize(plugin_name, actions=[], name=nil, description=nil, author=nil,
+                     license=nil, version=nil, url=nil, timeout=nil)
 
         super(name, description, author, license, version, url, timeout)
         @plugin_name = plugin_name

data/lib/mcollective/generators/base.rb

@@ -2,6 +2,7 @@ module MCollective
   module Generators
     class Base
       attr_accessor :meta, :plugin_name, :mod_name
+
       def initialize(name, description, author, license, version, url, timeout)
         @meta = {:name => name,
                  :description => description,
@@ -23,23 +24,21 @@ module MCollective
       end
 
       def write_plugins
-        begin
-          Dir.mkdir @plugin_name
-          dirname = File.join(@plugin_name, @mod_name.downcase)
-          Dir.mkdir dirname
-          puts "Created plugin directory : #{@plugin_name}"
+        Dir.mkdir @plugin_name
+        dirname = File.join(@plugin_name, @mod_name.downcase)
+        Dir.mkdir dirname
+        puts "Created plugin directory : #{@plugin_name}"
 
-          File.open(File.join(dirname, "#{@plugin_name}.ddl"), "w"){|f| f.puts @ddl}
-          puts "Created DDL file : #{File.join(dirname, "#{@plugin_name}.ddl")}"
+        File.open(File.join(dirname, "#{@plugin_name}.ddl"), "w") {|f| f.puts @ddl}
+        puts "Created DDL file : #{File.join(dirname, "#{@plugin_name}.ddl")}"
 
-          File.open(File.join(dirname, "#{@plugin_name}.rb"), "w"){|f| f.puts @plugin}
-          puts "Created #{@mod_name} file : #{File.join(dirname, "#{@plugin_name}.rb")}"
-        rescue Errno::EEXIST
-          raise "cannot generate '#{@plugin_name}' : plugin directory already exists."
-        rescue Exception => e
-          FileUtils.rm_rf(@plugin_name) if File.directory?(@plugin_name)
-          raise "cannot generate plugin - #{e}"
-        end
+        File.open(File.join(dirname, "#{@plugin_name}.rb"), "w") {|f| f.puts @plugin}
+        puts "Created #{@mod_name} file : #{File.join(dirname, "#{@plugin_name}.rb")}"
+      rescue Errno::EEXIST
+        raise "cannot generate '#{@plugin_name}' : plugin directory already exists."
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        FileUtils.rm_rf(@plugin_name) if File.directory?(@plugin_name)
+        raise "cannot generate plugin - #{e}"
       end
     end
   end

data/lib/mcollective/generators/data_generator.rb

@@ -1,11 +1,10 @@
 module MCollective
   module Generators
-    class DataGenerator<Base
-
+    class DataGenerator < Base
       attr_accessor :ddl, :content
 
-      def initialize(plugin_name, outputs = [],  name = nil, description = nil, author = nil ,
-                     license = nil, version = nil, url = nil, timeout = nil)
+      def initialize(plugin_name, outputs=[], name=nil, description=nil, author=nil,
+                     license=nil, version=nil, url=nil, timeout=nil)
 
         super(name, description, author, license, version, url, timeout)
         @mod_name = "Data"
@@ -22,7 +21,7 @@ module MCollective
         query_text = "dataquery :description => \"Query information\" do\n"
         query_text += ERB.new(File.read(File.join(File.dirname(__FILE__), "templates", "data_input_snippet.erb"))).result
 
-        @outputs.each_with_index do |output,i|
+        @outputs.each_with_index do |output, i|
           query_text += "%2s%s" % [" ", "output :#{output},\n"]
           query_text += "%9s%s" % [" ", ":description => \"%DESCRIPTION%\",\n"]
           query_text += "%9s%s" % [" ", ":display_as => \"%DESCRIPTION%\"\n"]
@@ -39,7 +38,7 @@ module MCollective
         content_text = "%6s%s" % [" ", "query do |what|\n"]
 
         @outputs.each do |output|
-           content_text += "%8s%s" % [" ", "result[:#{output}] = nil\n"]
+          content_text += "%8s%s" % [" ", "result[:#{output}] = nil\n"]
         end
         content_text += "%6s%s" % [" ", "end\n"]
 

data/lib/mcollective/log.rb

@@ -60,7 +60,7 @@ module MCollective
         else
           t = Time.new.strftime("%H:%M:%S")
 
-          STDERR.puts "#{t}: #{level}: #{from}: #{msg}"
+          warn "#{t}: #{level}: #{from}: #{msg}"
         end
       end
 
@@ -98,7 +98,7 @@ module MCollective
         @logger.start
       rescue Exception => e # rubocop:disable Lint/RescueException
         @configured = false
-        STDERR.puts "Could not start logger: #{e.class} #{e}"
+        warn "Could not start logger: #{e.class} #{e}"
       end
 
       # figures out the filename that called us

data/lib/mcollective/logger/base.rb

@@ -29,7 +29,7 @@ module MCollective
       end
 
       # Sets a new level and record it in @active_level
-      def set_level(level)
+      def set_level(level) # rubocop:disable Naming/AccessorMethodName
         set_logging_level(level)
         @active_level = level.to_sym
       end
@@ -47,6 +47,7 @@ module MCollective
       end
 
       private
+
       def map_level(level)
         raise "Logger class do not know how to handle #{level} messages" unless valid_levels.include?(level.to_sym)
 
@@ -54,7 +55,7 @@ module MCollective
       end
 
       # Gets the next level in the list, cycles down to the firt once it reaches the end
-      def get_next_level
+      def get_next_level # rubocop:disable Naming/AccessorMethodName
         # if all else fails, always go to debug mode
         nextlvl = :debug
 

data/lib/mcollective/logger/console_logger.rb

@@ -1,7 +1,7 @@
 module MCollective
   module Logger
     # Implements a syslog based logger using the standard ruby syslog class
-    class Console_logger<Base
+    class Console_logger < Base
       def start
         set_level(:info)
 
@@ -9,19 +9,19 @@ module MCollective
         set_level(config.loglevel.to_sym) if config.configured
       end
 
-      def set_logging_level(level)
+      def set_logging_level(level) # rubocop:disable Naming/AccessorMethodName
         # nothing to do here, we ignore high levels when we log
       end
 
       def valid_levels
-        {:info  => :info,
-         :warn  => :warning,
+        {:info => :info,
+         :warn => :warning,
          :debug => :debug,
          :fatal => :crit,
          :error => :err}
       end
 
-      def log(level, from, msg, normal_output=STDERR, last_resort_output=STDERR)
+      def log(level, from, msg, normal_output=$stderr, last_resort_output=$stderr)
         if @known_levels.index(level) >= @known_levels.index(@active_level)
           time = Time.new.strftime("%Y/%m/%d %H:%M:%S")
 
@@ -41,20 +41,20 @@ module MCollective
 
         colors = {:error => Util.color(:red),
                   :fatal => Util.color(:red),
-                  :warn  => Util.color(:yellow),
-                  :info  => Util.color(:green),
+                  :warn => Util.color(:yellow),
+                  :info => Util.color(:green),
                   :reset => Util.color(:reset)}
 
         if colorize
-          return colors[level] || ""
+          colors[level] || ""
         else
-          return ""
+          ""
         end
       end
 
       # Helper to return a string in specific color
       def colorize(level, msg)
-        "%s%s%s" % [ color(level), msg, color(:reset) ]
+        "%s%s%s" % [color(level), msg, color(:reset)]
       end
     end
   end

data/lib/mcollective/logger/file_logger.rb

@@ -1,4 +1,4 @@
-require 'logger'
+require "logger"
 
 module MCollective
   module Logger
@@ -9,7 +9,7 @@ module MCollective
     #   - config.logfile
     #   - config.keeplogs defaults to 2097152
     #   - config.max_log_size defaults to 5
-    class File_logger<Base
+    class File_logger < Base
       def start
         config = Config.instance
 
@@ -19,16 +19,16 @@ module MCollective
         set_level(config.loglevel.to_sym)
       end
 
-      def set_logging_level(level)
+      def set_logging_level(level) # rubocop:disable Naming/AccessorMethodName
         @logger.level = map_level(level)
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         @logger.level = ::Logger::DEBUG
         log(:error, "", "Could not set logging to #{level} using debug instead: #{e.class} #{e}")
       end
 
       def valid_levels
-        {:info  => ::Logger::INFO,
-         :warn  => ::Logger::WARN,
+        {:info => ::Logger::INFO,
+         :warn => ::Logger::WARN,
          :debug => ::Logger::DEBUG,
          :fatal => ::Logger::FATAL,
          :error => ::Logger::ERROR}
@@ -39,7 +39,7 @@ module MCollective
       rescue
         # if this fails we probably cant show the user output at all,
         # STDERR it as last resort
-        STDERR.puts("#{level}: #{msg}")
+        warn("#{level}: #{msg}")
       end
 
       def reopen

data/lib/mcollective/logger/syslog_logger.rb

@@ -1,8 +1,8 @@
 module MCollective
   module Logger
     # Implements a syslog based logger using the standard ruby syslog class
-    class Syslog_logger<Base
-      require 'syslog'
+    class Syslog_logger < Base
+      require "syslog"
 
       include Syslog::Constants
 
@@ -19,34 +19,30 @@ module MCollective
       end
 
       def syslog_facility(facility)
-        begin
-          Syslog.const_get("LOG_#{facility.upcase}")
-        rescue NameError => e
-          STDERR.puts "Invalid syslog facility #{facility} supplied, reverting to USER"
-          Syslog::LOG_USER
-        end
+        Syslog.const_get("LOG_#{facility.upcase}")
+      rescue NameError
+        warn "Invalid syslog facility #{facility} supplied, reverting to USER"
+        Syslog::LOG_USER
       end
 
-      def set_logging_level(level)
+      def set_logging_level(level) # rubocop:disable Naming/AccessorMethodName
         # noop
       end
 
       def valid_levels
-        {:info  => :info,
-         :warn  => :warning,
+        {:info => :info,
+         :warn => :warning,
          :debug => :debug,
          :fatal => :crit,
          :error => :err}
       end
 
       def log(level, from, msg)
-        if @known_levels.index(level) >= @known_levels.index(@active_level)
-          Syslog.send(map_level(level), "#{from} #{msg}")
-        end
+        Syslog.send(map_level(level), "#{from} #{msg}") if @known_levels.index(level) >= @known_levels.index(@active_level)
       rescue
         # if this fails we probably cant show the user output at all,
         # STDERR it as last resort
-        STDERR.puts("#{level}: #{msg}")
+        warn("#{level}: #{msg}")
       end
     end
   end

data/lib/mcollective/matcher.rb

@@ -102,9 +102,9 @@ module MCollective
           # If data field has not been set we set the comparison result to nil
           eval_result = nil
         end
-        return eval_result
+        eval_result
       else
-        return result
+        result
       end
     rescue NoMethodError
       Log.debug("cannot execute discovery function '#{function_hash['name']}'. data plugin not found")
@@ -113,9 +113,10 @@ module MCollective
 
     # Evaluates a compound statement
     def self.eval_compound_statement(expression)
-      if expression.values.first =~ /^\//
+      case expression.values.first
+      when /^\//
         Util.has_cf_class?(expression.values.first)
-      elsif expression.values.first =~ />=|<=|=|<|>/
+      when />=|<=|=|<|>/
         optype = expression.values.first.match(/>=|<=|=|<|>/)
         name, value = expression.values.first.split(optype[0])
         if value.split("")[0] == "/"
@@ -160,20 +161,21 @@ module MCollective
           result = l_compare.match(r_compare)
           # Flip return value for != operator
           if function_hash["operator"] == "!=~"
-            return !result
+            !result
           else
-            return !!result
+            !!result
           end
         else
           Log.debug("Cannot do a regex check on a non string value.")
-          return false
+          false
         end
         # Otherwise do a normal comparison while taking the type into account
       else
         if l_compare.is_a? String
           r_compare = r_compare.to_s
         elsif r_compare.is_a? String
-          if l_compare.is_a? Numeric
+          case l_compare
+          when Numeric
             r_compare = r_compare.strip
             begin
               r_compare = Integer(r_compare)
@@ -184,7 +186,7 @@ module MCollective
                 raise(ArgumentError, "invalid numeric value: #{r_compare}")
               end
             end
-          elsif l_compare.is_a?(TrueClass) || l_compare.is_a?(FalseClass)
+          when TrueClass, FalseClass
             r_compare = r_compare.strip
             if r_compare == true.to_s # rubocop:disable Metrics/BlockNesting
               r_compare = true
@@ -201,8 +203,8 @@ module MCollective
         else
           raise(ArgumentError, "invalid operator: #{operator}")
         end
-        result = l_compare.send(operator, r_compare)
-        return result
+        l_compare.send(operator, r_compare)
+
       end
     end
 
@@ -210,9 +212,7 @@ module MCollective
     def self.create_compound_callstack(call_string)
       callstack = Matcher::Parser.new(call_string).execution_stack
       callstack.each_with_index do |statement, i|
-        if statement.keys.first == "fstatement"
-          callstack[i]["fstatement"] = create_function_hash(statement.values.first)
-        end
+        callstack[i]["fstatement"] = create_function_hash(statement.values.first) if statement.keys.first == "fstatement"
       end
       callstack
     end

data/lib/mcollective/matcher/parser.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Metrics/BlockNesting
 module MCollective
   module Matcher
     class Parser
@@ -10,9 +11,9 @@ module MCollective
         @token_errors = []
         @paren_errors = []
         parse
-        exit_with_token_errors if @token_errors.size > 0
-        exit_with_parse_errors if @parse_errors.size > 0
-        exit_with_paren_errors if @paren_errors.size > 0
+        exit_with_token_errors unless @token_errors.empty?
+        exit_with_parse_errors unless @parse_errors.empty?
+        exit_with_paren_errors unless @paren_errors.empty?
       end
 
       # Exit and highlight any malformed tokens
@@ -31,7 +32,7 @@ module MCollective
             @scanner.arguments[i] = Util.colorize(:red, @scanner.arguments[i])
           end
         end
-        raise "Parse errors found while parsing -S input #{ @scanner.arguments.join}"
+        raise "Parse errors found while parsing -S input #{@scanner.arguments.join}"
       end
 
       def exit_with_paren_errors
@@ -42,13 +43,12 @@ module MCollective
       end
 
       # Parse the input string, one token at a time a contruct the call stack
-      def parse
+      def parse # rubocop:disable Metrics/MethodLength
         pre_index = @scanner.token_index
-        p_token,p_token_value = nil
-        c_token,c_token_value = @scanner.get_token
-        parenth = 0
+        p_token = nil
+        c_token, c_token_value = @scanner.get_token
 
-        while (c_token != nil)
+        until c_token.nil?
           @scanner.token_index += 1
           n_token, n_token_value = @scanner.get_token
 
@@ -58,67 +58,56 @@ module MCollective
               @token_errors << c_token_value
 
             when "and"
-              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !(n_token == nil)
+              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !n_token.nil?
                 @parse_errors << [pre_index, scanner.token_index]
               end
 
-              if p_token == nil
+              case p_token
+              when nil
                 @parse_errors << [pre_index - c_token.size, scanner.token_index]
-              elsif (p_token == "and" || p_token == "or")
+              when "and", "or"
                 @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
               end
 
             when "or"
-              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !(n_token == nil)
+              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !n_token.nil?
                 @parse_errors << [pre_index, scanner.token_index]
               end
 
-              if p_token == nil
+              case p_token
+              when nil
                 @parse_errors << [pre_index - c_token.size, scanner.token_index]
-              elsif (p_token == "and" || p_token == "or")
+              when "and", "or"
                 @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
               end
 
             when "not"
-              unless n_token =~ /fstatement|statement|\(|not/ && !(n_token == nil)
-                @parse_errors << [pre_index, scanner.token_index]
-              end
+              @parse_errors << [pre_index, scanner.token_index] unless n_token =~ /fstatement|statement|\(|not/ && !n_token.nil?
 
-            when "statement","fstatement"
-              unless n_token =~ /and|or|\)/
-                unless scanner.token_index == scanner.arguments.size
-                  @parse_errors << [pre_index, scanner.token_index]
-                end
-              end
+            when "statement", "fstatement"
+              @parse_errors << [pre_index, scanner.token_index] if n_token !~ /and|or|\)/ && scanner.token_index != scanner.arguments.size
 
             when ")"
-              unless (n_token =~ /|and|or|not|\(/)
-                unless(scanner.token_index == scanner.arguments.size)
-                  @parse_errors << [pre_index, scanner.token_index]
-                end
-              end
-              unless @paren_errors.empty?
-                @paren_errors.pop
+              @parse_errors << [pre_index, scanner.token_index] if n_token !~ /|and|or|not|\(/ && scanner.token_index != scanner.arguments.size
+              if @paren_errors.empty?
+                @paren_errors.push(n_token.nil? ? scanner.token_index - 1 : scanner.token_index - n_token_value.size)
               else
-                @paren_errors.push((n_token.nil?) ? scanner.token_index - 1: scanner.token_index - n_token_value.size)
+                @paren_errors.pop
               end
 
             when "("
-              unless n_token =~ /fstatement|statement|not|\(/
-                @parse_errors << [pre_index, scanner.token_index]
-              end
-              @paren_errors.push((n_token.nil?) ? scanner.token_index - 1: scanner.token_index - n_token_value.size)
+              @parse_errors << [pre_index, scanner.token_index] unless n_token =~ /fstatement|statement|not|\(/
+              @paren_errors.push(n_token.nil? ? scanner.token_index - 1 : scanner.token_index - n_token_value.size)
 
             else
               @parse_errors << [pre_index, scanner.token_index]
             end
 
-            unless n_token == " " ||c_token == "bad_token"
-              @execution_stack << {c_token => c_token_value}
-            end
+            @execution_stack << {c_token => c_token_value} unless n_token == " " || c_token == "bad_token"
 
-            p_token, p_token_value = c_token, c_token_value
-            c_token, c_token_value = n_token, n_token_value
+            p_token = c_token
+            c_token = n_token
+            c_token_value = n_token_value
           end
           pre_index = @scanner.token_index
         end
@@ -126,3 +115,4 @@ module MCollective
     end
   end
 end
+# rubocop:enable Metrics/BlockNesting