choria-mcorpc-support 2.20.3 → 2.20.4

data/lib/mcollective/monkey_patches.rb

@@ -1,128 +1,139 @@
 # start_with? was introduced in 1.8.7, we need to support
 # 1.8.5 and 1.8.6
 class String
-  def start_with?(str)
-    return self[0..(str.length-1)] == str
-  end unless method_defined?("start_with?")
+  unless method_defined?("start_with?")
+    def start_with?(str)
+      self[0..(str.length - 1)] == str
+    end
+  end
 end
 
 # Make arrays of Symbols sortable
 class Symbol
   include Comparable
 
-  def <=>(other)
-    self.to_s <=> other.to_s
-  end unless method_defined?("<=>")
+  unless method_defined?("<=>")
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+  end
 end
 
 # This provides an alias for RbConfig to Config for versions of Ruby older then
 # # version 1.8.5. This allows us to use RbConfig in place of the older Config in
 # # our code and still be compatible with at least Ruby 1.8.1.
 # require 'rbconfig'
-unless defined? ::RbConfig
-  ::RbConfig = ::Config
-end
+::RbConfig = ::Config unless defined? ::RbConfig
 
 # a method # that walks an array in groups, pass a block to
 # call the block on each sub array
 class Array
-  def in_groups_of(chunk_size, padded_with=nil, &block)
-    arr = self.clone
+  unless method_defined?(:in_groups_of)
+    def in_groups_of(chunk_size, padded_with=nil, &block)
+      arr = clone
 
-    # how many to add
-    padding = chunk_size - (arr.size % chunk_size)
+      # how many to add
+      padding = chunk_size - (arr.size % chunk_size)
 
-    # pad at the end
-    arr.concat([padded_with] * padding) unless padding == chunk_size
+      # pad at the end
+      arr.concat([padded_with] * padding) unless padding == chunk_size
 
-    # how many chunks we'll make
-    count = arr.size / chunk_size
+      # how many chunks we'll make
+      count = arr.size / chunk_size
 
-    # make that many arrays
-    result = []
-    count.times {|s| result <<  arr[s * chunk_size, chunk_size]}
+      # make that many arrays
+      result = []
+      count.times {|s| result << arr[s * chunk_size, chunk_size]}
 
-    if block_given?
-      result.each_with_index do |a, i|
-        case block.arity
+      if block_given?
+        result.each_with_index do |a, i|
+          case block.arity
           when 1
             yield(a)
           when 2
             yield(a, (i == result.size - 1))
           else
             raise "Expected 1 or 2 arguments, got #{block.arity}"
+          end
         end
+      else
+        result
       end
-    else
-      result
     end
-  end unless method_defined?(:in_groups_of)
+  end
 end
 
 class String
-  def bytes(&block)
-    # This should not be necessary, really ...
-    require 'enumerator'
-    return to_enum(:each_byte) unless block_given?
-    each_byte(&block)
-  end unless method_defined?(:bytes)
+  unless method_defined?(:bytes)
+    def bytes(&block)
+      # This should not be necessary, really ...
+      require "enumerator"
+      return to_enum(:each_byte) unless block_given?
+      each_byte(&block)
+    end
+  end
 end
 
 class Dir
-  def self.mktmpdir(prefix_suffix=nil, tmpdir=nil)
-    case prefix_suffix
-    when nil
-      prefix = "d"
-      suffix = ""
-    when String
-      prefix = prefix_suffix
-      suffix = ""
-    when Array
-      prefix = prefix_suffix[0]
-      suffix = prefix_suffix[1]
-    else
-      raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
-    end
-    tmpdir ||= Dir.tmpdir
-    t = Time.now.strftime("%Y%m%d")
-    n = nil
-    begin
-      path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
-      path << "-#{n}" if n
-      path << suffix
-      Dir.mkdir(path, 0700)
-    rescue Errno::EEXIST
-      n ||= 0
-      n += 1
-      retry
-    end
-
-    if block_given?
+  unless method_defined?(:mktmpdir)
+    def self.mktmpdir(prefix_suffix=nil, tmpdir=nil)
+      case prefix_suffix
+      when nil
+        prefix = "d"
+        suffix = ""
+      when String
+        prefix = prefix_suffix
+        suffix = ""
+      when Array
+        prefix = prefix_suffix[0]
+        suffix = prefix_suffix[1]
+      else
+        raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+      end
+      tmpdir ||= Dir.tmpdir
+      t = Time.now.strftime("%Y%m%d")
+      n = nil
       begin
-        yield path
-      ensure
-        FileUtils.remove_entry_secure path
+        path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+        path << "-#{n}" if n
+        path << suffix
+        Dir.mkdir(path, 0o700)
+      rescue Errno::EEXIST
+        n ||= 0
+        n += 1
+        retry
+      end
+
+      if block_given?
+        begin
+          yield path
+        ensure
+          FileUtils.remove_entry_secure path
+        end
+      else
+        path
       end
-    else
-      path
     end
-  end unless method_defined?(:mktmpdir)
-
-  def self.tmpdir
-    tmp = '.'
-    for dir in [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], '/tmp']
-      if dir and stat = File.stat(dir) and stat.directory? and stat.writable?
-        tmp = dir
-        break
-      end rescue nil
+  end
+
+  unless method_defined?(:tmpdir)
+    def self.tmpdir
+      tmp = "."
+      [ENV["TMPDIR"], ENV["TMP"], ENV["TEMP"], "/tmp"].each do |dir|
+        if dir && (stat = File.stat(dir)) && stat.directory? && stat.writable?
+          tmp = dir
+          break
+        end rescue nil
+      end
+
+      File.expand_path(tmp)
     end
-    File.expand_path(tmp)
-  end unless method_defined?(:tmpdir)
+  end
 end
 
 # Reject all SSLv2 ciphers and all SSLv2 or SSLv3 handshakes by default
-require 'openssl'
-class OpenSSL::SSL::SSLContext
+require "openssl"
+class OpenSSL::SSL::SSLContext # rubocop:disable Style/ClassAndModuleChildren
   if DEFAULT_PARAMS[:options]
     DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
   else
@@ -134,9 +145,7 @@ class OpenSSL::SSL::SSLContext
     DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
   end
 
-  if DEFAULT_PARAMS[:ciphers]
-    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
-  end
+  DEFAULT_PARAMS[:ciphers] << ":!SSLv2" if DEFAULT_PARAMS[:ciphers]
 
   alias __mcollective_original_initialize initialize
   private :__mcollective_original_initialize
@@ -145,7 +154,7 @@ class OpenSSL::SSL::SSLContext
     __mcollective_original_initialize(*args)
     params = {
       :options => DEFAULT_PARAMS[:options],
-      :ciphers => DEFAULT_PARAMS[:ciphers],
+      :ciphers => DEFAULT_PARAMS[:ciphers]
     }
     set_params(params)
   end

data/lib/mcollective/optionparser.rb

@@ -17,7 +17,7 @@ module MCollective
     # Starts a parser in verbose mode that does not show the common options:
     #
     #  oparser = MCollective::Optionparser.new({:verbose => true}, "filter", "common")
-    def initialize(defaults = {}, include_sections = nil, exclude_sections = nil)
+    def initialize(defaults={}, include_sections=nil, exclude_sections=nil)
       @parser = ::OptionParser.new
 
       @include = [include_sections].flatten
@@ -56,7 +56,7 @@ module MCollective
         next if @exclude.include?(i)
 
         options_name = "add_#{i}_options"
-        send(options_name)  if respond_to?(options_name)
+        send(options_name) if respond_to?(options_name)
       end
 
       @parser.environment("MCOLLECTIVE_EXTRA_OPTS")
@@ -74,7 +74,7 @@ module MCollective
       @parser.separator ""
       @parser.separator "Host Filters"
 
-      @parser.on('-W', '--with FILTER', 'Combined classes and facts filter') do |f|
+      @parser.on("-W", "--with FILTER", "Combined classes and facts filter") do |f|
         f.split(" ").each do |filter|
           begin
             fact_parsed = parse_fact(filter)
@@ -85,40 +85,40 @@ module MCollective
         end
       end
 
-      @parser.on('-S', '--select FILTER', 'Compound filter combining facts and classes') do |f|
+      @parser.on("-S", "--select FILTER", "Compound filter combining facts and classes") do |f|
         @options[:filter]["compound"] << Matcher.create_compound_callstack(f)
       end
 
-      @parser.on('-F', '--wf', '--with-fact fact=val', 'Match hosts with a certain fact') do |f|
+      @parser.on("-F", "--wf", "--with-fact fact=val", "Match hosts with a certain fact") do |f|
         fact_parsed = parse_fact(f)
 
         @options[:filter]["fact"] << fact_parsed if fact_parsed
       end
 
-      @parser.on('-C', '--wc', '--with-class CLASS', 'Match hosts with a certain config management class') do |f|
+      @parser.on("-C", "--wc", "--with-class CLASS", "Match hosts with a certain config management class") do |f|
         @options[:filter]["cf_class"] << f
       end
 
-      @parser.on('-A', '--wa', '--with-agent AGENT', 'Match hosts with a certain agent') do |a|
+      @parser.on("-A", "--wa", "--with-agent AGENT", "Match hosts with a certain agent") do |a|
         @options[:filter]["agent"] << a
       end
 
-      @parser.on('-I', '--wi', '--with-identity IDENT', 'Match hosts with a certain configured identity') do |a|
+      @parser.on("-I", "--wi", "--with-identity IDENT", "Match hosts with a certain configured identity") do |a|
         @options[:filter]["identity"] << a
       end
     end
 
     # These options should always be present
     def add_required_options
-      @parser.on('-c', '--config FILE', 'Load configuration from file rather than default') do |f|
+      @parser.on("-c", "--config FILE", "Load configuration from file rather than default") do |f|
         @options[:config] = f
       end
 
-      @parser.on('-v', '--verbose', 'Be verbose') do |v|
+      @parser.on("-v", "--verbose", "Be verbose") do |v|
         @options[:verbose] = v
       end
 
-      @parser.on('-h', '--help', 'Display this screen') do
+      @parser.on("-h", "--help", "Display this screen") do
         puts @parser
         exit! 1
       end
@@ -129,41 +129,41 @@ module MCollective
       @parser.separator ""
       @parser.separator "Common Options"
 
-      @parser.on('-T', '--target COLLECTIVE', 'Target messages to a specific sub collective') do |f|
+      @parser.on("-T", "--target COLLECTIVE", "Target messages to a specific sub collective") do |f|
         @options[:collective] = f
       end
 
-      @parser.on('--dt', '--discovery-timeout SECONDS', Integer, 'Timeout for doing discovery') do |t|
+      @parser.on("--dt", "--discovery-timeout SECONDS", Integer, "Timeout for doing discovery") do |t|
         @options[:disctimeout] = t
       end
 
-      @parser.on('-t', '--timeout SECONDS', Integer, 'Timeout for calling remote agents') do |t|
+      @parser.on("-t", "--timeout SECONDS", Integer, "Timeout for calling remote agents") do |t|
         @options[:timeout] = t
       end
 
-      @parser.on('-q', '--quiet', 'Do not be verbose') do |v|
+      @parser.on("-q", "--quiet", "Do not be verbose") do |_v|
         @options[:verbose] = false
       end
 
-      @parser.on('--ttl TTL', 'Set the message validity period') do |v|
+      @parser.on("--ttl TTL", "Set the message validity period") do |v|
         @options[:ttl] = v.to_i
       end
 
-      @parser.on('--reply-to TARGET', 'Set a custom target for replies') do |v|
+      @parser.on("--reply-to TARGET", "Set a custom target for replies") do |v|
         @options[:reply_to] = v
       end
 
-      @parser.on('--dm', '--disc-method METHOD', 'Which discovery method to use') do |v|
+      @parser.on("--dm", "--disc-method METHOD", "Which discovery method to use") do |v|
         raise "Discovery method is already set by a competing option" if @options[:discovery_method] && @options[:discovery_method] != v
         @options[:discovery_method] = v
       end
 
-      @parser.on('--do', '--disc-option OPTION', 'Options to pass to the discovery method') do |a|
+      @parser.on("--do", "--disc-option OPTION", "Options to pass to the discovery method") do |a|
         @options[:discovery_options] << a
       end
 
       @parser.on("--nodes FILE", "List of nodes to address") do |v|
-        raise "Cannot mix --disc-method, --disc-option and --nodes" if @options[:discovery_method] || @options[:discovery_options].size > 0
+        raise "Cannot mix --disc-method, --disc-option and --nodes" if @options[:discovery_method] || !@options[:discovery_options].empty?
         raise "Cannot read the discovery file #{v}" unless File.readable?(v)
 
         @options[:discovery_method] = "flatfile"
@@ -174,11 +174,11 @@ module MCollective
         @options[:publish_timeout] = pt
       end
 
-      @parser.on("--threaded", "Start publishing requests and receiving responses in threaded mode.") do |v|
+      @parser.on("--threaded", "Start publishing requests and receiving responses in threaded mode.") do |_v|
         @options[:threaded] = true
       end
 
-      @parser.on("--sort", "Sort the output of an RPC call before processing.") do |v|
+      @parser.on("--sort", "Sort the output of an RPC call before processing.") do |_v|
         @options[:sort] = true
       end
 
@@ -188,10 +188,10 @@ module MCollective
     end
 
     private
+
     # Parse a fact filter string like foo=bar into the tuple hash thats needed
     def parse_fact(fact)
       Util.parse_fact_string(fact)
     end
-
   end
 end

data/lib/mcollective/pluginmanager.rb

@@ -36,7 +36,6 @@ module MCollective
 
       raise("Plugin #{type} already loaded") if @plugins.include?(type)
 
-
       # If we get a string then store 'nil' as the instance, signalling that we'll
       # create the class later on demand.
       if klass.is_a?(String)
@@ -76,7 +75,7 @@ module MCollective
 
       if @plugins[plugin][:single]
         # Create an instance of the class if one hasn't been done before
-        if @plugins[plugin][:instance] == nil
+        if @plugins[plugin][:instance].nil?
           Log.debug("Returning new plugin #{plugin} with class #{klass}")
           @plugins[plugin][:instance] = create_instance(klass)
         else
@@ -92,11 +91,9 @@ module MCollective
 
     # use eval to create an instance of a class
     def self.create_instance(klass)
-      begin
-        eval("#{klass}.new")
-      rescue Exception => e
-        raise("Could not create instance of plugin #{klass}: #{e}")
-      end
+      eval("#{klass}.new") # rubocop:disable Security/Eval
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      raise("Could not create instance of plugin #{klass}: #{e}")
     end
 
     # Finds plugins in all configured libdirs
@@ -114,7 +111,7 @@ module MCollective
     # Will return the same list but only of files with extension .ddl
     # in the agent subdirectory
     def self.find(type, extension="rb")
-      extension = ".#{extension}" unless extension.match(/^\./)
+      extension = ".#{extension}" unless extension =~ /^\./
 
       plugins = []
 
@@ -146,14 +143,14 @@ module MCollective
     #
     # This will load only plugins matching /puppet/
     def self.find_and_load(type, extension="rb")
-      extension = ".#{extension}" unless extension.match(/^\./)
+      extension = ".#{extension}" unless extension =~ /^\./
 
       klasses = find(type, extension).map do |plugin|
         if block_given?
           next unless yield(plugin)
         end
 
-        "%s::%s::%s" % [ "MCollective", type.capitalize, plugin.capitalize ]
+        "%s::%s::%s" % ["MCollective", type.capitalize, plugin.capitalize]
       end.compact
 
       klasses.sort.uniq.each {|klass| loadclass(klass, true)}
@@ -167,7 +164,7 @@ module MCollective
       Log.debug("Loading #{klass} from #{fname}")
 
       load fname
-    rescue Exception => e
+    rescue Exception => e # rubocop:disable Lint/RescueException
       Log.error("Failed to load #{klass}: #{e}")
       raise unless squash_failures
     end