choria-mcorpc-support 2.21.1 → 2.23.1

data/lib/mcollective/monkey_patches.rb

@@ -67,8 +67,8 @@ class String
   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
@@ -141,9 +141,7 @@ class OpenSSL::SSL::SSLContext # rubocop:disable Style/ClassAndModuleChildren
   end
 
   # ruby 1.8.5 doesn't define this constant, but has it on by default
-  if defined?(OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS)
-    DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
-  end
+  DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS if defined?(OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS)
 
   DEFAULT_PARAMS[:ciphers] << ":!SSLv2" if DEFAULT_PARAMS[:ciphers]
 

data/lib/mcollective/optionparser.rb

@@ -86,7 +86,7 @@ module MCollective
       end
 
       @parser.on("-S", "--select FILTER", "Compound filter combining facts and classes") do |f|
-        @options[:filter]["compound"] << Matcher.create_compound_callstack(f)
+        @options[:filter]["compound"] << [{"expr" => f}]
       end
 
       @parser.on("-F", "--wf", "--with-fact fact=val", "Match hosts with a certain fact") do |f|
@@ -155,6 +155,7 @@ module MCollective
 
       @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
 

data/lib/mcollective/pluginmanager.rb

@@ -91,7 +91,7 @@ module MCollective
 
     # use eval to create an instance of a class
     def self.create_instance(klass)
-      eval("#{klass}.new") # rubocop:disable Security/Eval
+      eval("#{klass}.new") # rubocop:disable Security/Eval, Style/EvalWithLocation
     rescue Exception => e # rubocop:disable Lint/RescueException
       raise("Could not create instance of plugin #{klass}: #{e}")
     end
@@ -146,9 +146,7 @@ module MCollective
       extension = ".#{extension}" unless extension =~ /^\./
 
       klasses = find(type, extension).map do |plugin|
-        if block_given?
-          next unless yield(plugin)
-        end
+        next if block_given? && !yield(plugin)
 
         "%s::%s::%s" % ["MCollective", type.capitalize, plugin.capitalize]
       end.compact
@@ -159,7 +157,7 @@ module MCollective
     # Loads a class from file by doing some simple search/replace
     # on class names and then doing a require.
     def self.loadclass(klass, squash_failures=false)
-      fname = klass.gsub("::", "/").downcase + ".rb"
+      fname = "#{klass.gsub('::', '/').downcase}.rb"
 
       Log.debug("Loading #{klass} from #{fname}")
 

data/lib/mcollective/pluginpackager.rb

@@ -84,9 +84,7 @@ module MCollective
 
     # Return the path to a plugin's core directories
     def self.get_plugin_path(target)
-      if File.exist?(File.join(target, "lib", "mcollective"))
-        return File.join(target, "lib", "mcollective")
-      end
+      return File.join(target, "lib", "mcollective") if File.exist?(File.join(target, "lib", "mcollective"))
 
       target
     end

data/lib/mcollective/pluginpackager/agent_definition.rb

@@ -2,8 +2,7 @@ module MCollective
   module PluginPackager
     # MCollective Agent Plugin package
     class AgentDefinition
-      attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :revision, :preinstall
-      attr_accessor :plugintype, :dependencies, :postinstall, :mcname, :mcversion
+      attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :revision, :preinstall, :plugintype, :dependencies, :postinstall, :mcname, :mcversion
 
       def initialize(configuration, mcdependency, plugintype)
         @plugintype = plugintype
@@ -53,9 +52,7 @@ module MCollective
         agent[:files] = (Dir.glob(File.join(agentdir, "**", "**")) - ddls)
         agent[:plugindependency] = {:name => "#{@mcname}-#{@metadata[:name]}-common", :version => @metadata[:version], :revision => @revision}
 
-        if @metadata[:provider] == "external"
-          agent[:executable_files] << File.join(agentdir, @agent_name)
-        end
+        agent[:executable_files] << File.join(agentdir, @agent_name) if @metadata[:provider] == "external"
 
         agent
       end
@@ -95,9 +92,7 @@ module MCollective
         end
 
         # We fail if there is no ddl file present
-        if common[:files].grep(/^.*\.ddl$/).empty?
-          raise "cannot create package - No ddl file found in #{File.join(@path, 'agent')}"
-        end
+        raise "cannot create package - No ddl file found in #{File.join(@path, 'agent')}" if common[:files].grep(/^.*\.ddl$/).empty?
 
         common[:files].uniq!
 

data/lib/mcollective/pluginpackager/forge_packager.rb

@@ -40,7 +40,7 @@ module MCollective
 
           puts("Completed building module for %s" % module_name)
         rescue
-          STDERR.puts("Failed to build plugin module: %s: %s" % [$!.class, $!.to_s])
+          warn("Failed to build plugin module: %s: %s" % [$!.class, $!.to_s])
         ensure
           if @keep_artifacts
             puts("Keeping build artifacts")
@@ -191,12 +191,12 @@ module MCollective
       end
 
       def render_template(infile, outfile)
-        erb = ERB.new(File.read(infile), nil, "-")
+        erb = ERB.new(File.read(infile), 0, "%")
         File.open(outfile, "w") do |f|
           f.puts erb.result(binding)
         end
       rescue
-        STDERR.puts("Could not render template %s to %s" % [infile, outfile])
+        warn("Could not render template %s to %s" % [infile, outfile])
         raise
       end
 
@@ -218,9 +218,7 @@ module MCollective
         actual_version = s.stdout.chomp
         required_version = "1.12.0"
 
-        if Util.versioncmp(actual_version, required_version) < 0
-          raise("Cannot build package. pdk #{required_version} or greater required.  We have #{actual_version}.")
-        end
+        raise("Cannot build package. pdk #{required_version} or greater required.  We have #{actual_version}.") if Util.versioncmp(actual_version, required_version) < 0
       end
 
       def run_build
@@ -230,7 +228,7 @@ module MCollective
           end
         end
       rescue
-        STDERR.puts("Build process has failed")
+        warn("Build process has failed")
         raise
       end
 
@@ -238,14 +236,14 @@ module MCollective
         package_file = File.join(@tmpdir, "pkg", module_file_name)
         FileUtils.cp(package_file, ".")
       rescue
-        STDERR.puts("Could not copy package to working directory")
+        warn("Could not copy package to working directory")
         raise
       end
 
       def cleanup_tmpdirs
         FileUtils.rm_r(@tmpdir) if File.directory?(@tmpdir)
       rescue
-        STDERR.puts("Could not remove temporary build directory %s" % [@tmpdir])
+        warn("Could not remove temporary build directory %s" % [@tmpdir])
         raise
       end
     end

data/lib/mcollective/pluginpackager/standard_definition.rb

@@ -1,8 +1,7 @@
 module MCollective
   module PluginPackager
     class StandardDefinition
-      attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :revision
-      attr_accessor :plugintype, :preinstall, :postinstall, :dependencies, :mcname, :mcversion
+      attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :revision, :plugintype, :preinstall, :postinstall, :dependencies, :mcname, :mcversion
 
       def initialize(configuration, mcdependency, plugintype)
         @plugintype = plugintype

data/lib/mcollective/registration/base.rb

@@ -10,6 +10,7 @@ module MCollective
       # Register plugins that inherits base
       def self.inherited(klass)
         PluginManager << {:type => "registration_plugin", :class => klass.to_s}
+        super
       end
 
       # Creates a background thread that periodically send a registration notice.
@@ -44,7 +45,7 @@ module MCollective
           collective = main_collective
         end
 
-        return collective
+        collective
       end
 
       def interval
@@ -52,15 +53,15 @@ module MCollective
       end
 
       def publish(message)
-        unless message
-          Log.debug("Skipping registration due to nil body")
-        else
+        if message
           req = Message.new(message, nil, {:type => :request, :agent => "registration", :collective => target_collective, :filter => msg_filter})
           req.encode!
 
           Log.debug("Sending registration #{req.requestid} to collective #{req.collective}")
 
           req.publish
+        else
+          Log.debug("Skipping registration due to nil body")
         end
       end
 
@@ -69,22 +70,23 @@ module MCollective
       end
 
       private
+
       def publish_thread(connnection)
         if config.registration_splay
-            splay_delay = rand(interval)
-            Log.debug("registration_splay enabled. Registration will start in #{splay_delay} seconds")
-            sleep splay_delay
-          end
+          splay_delay = rand(interval)
+          Log.debug("registration_splay enabled. Registration will start in #{splay_delay} seconds")
+          sleep splay_delay
+        end
 
-          loop do
-            begin
-              publish(body)
-              sleep interval
-            rescue Exception => e
-              Log.error("Sending registration message failed: #{e}")
-              sleep interval
-            end
+        loop do
+          begin
+            publish(body)
+            sleep interval
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            Log.error("Sending registration message failed: #{e}")
+            sleep interval
           end
+        end
       end
     end
   end

data/lib/mcollective/rpc.rb

@@ -21,13 +21,11 @@ module MCollective
     def rpcoptions
       oparser = MCollective::Optionparser.new({:verbose => false, :progress_bar => true}, "filter")
 
-      options = oparser.parse do |parser, opts|
+      oparser.parse do |parser, opts|
         yield(parser, opts) if block_given?
 
         Helpers.add_simplerpc_options(parser, opts)
       end
-
-      options
     end
 
     # Wrapper to create clients, supposed to be used as
@@ -86,7 +84,7 @@ module MCollective
       if block_given?
         yield(rpc)
       else
-        return rpc
+        rpc
       end
     end
 

data/lib/mcollective/rpc/actionrunner.rb

@@ -35,11 +35,11 @@ module MCollective
 
       def run
         unless canrun?(command)
-          Log.warn("Cannot run #{to_s}")
-          raise RPCAborted, "Cannot execute #{to_s}"
+          Log.warn("Cannot run #{self}")
+          raise RPCAborted, "Cannot execute #{self}"
         end
 
-        Log.debug("Running #{to_s}")
+        Log.debug("Running #{self}")
 
         request_file = saverequest(request)
         reply_file = tempfile("reply")
@@ -51,13 +51,13 @@ module MCollective
 
         Log.debug("#{command} exited with #{runner.status.exitstatus}")
 
-        stderr.each_line {|l| Log.error("#{to_s}: #{l.chomp}")} unless stderr.empty?
-        stdout.each_line {|l| Log.info("#{to_s}: #{l.chomp}")} unless stdout.empty?
+        stderr.each_line {|l| Log.error("#{self}: #{l.chomp}")} unless stderr.empty?
+        stdout.each_line {|l| Log.info("#{self}: #{l.chomp}")} unless stdout.empty?
 
         {:exitstatus => runner.status.exitstatus,
-         :stdout     => runner.stdout,
-         :stderr     => runner.stderr,
-         :data       => load_results(reply_file.path)}
+         :stdout => runner.stdout,
+         :stderr => runner.stderr,
+         :data => load_results(reply_file.path)}
       ensure
         request_file.close! if request_file.respond_to?("close!")
         reply_file.close! if reply_file.respond_to?("close")
@@ -65,7 +65,7 @@ module MCollective
 
       def shell(command, infile, outfile)
         env = {"MCOLLECTIVE_REQUEST_FILE" => infile,
-               "MCOLLECTIVE_REPLY_FILE"   => outfile}
+               "MCOLLECTIVE_REPLY_FILE" => outfile}
 
         Shell.new("#{command} #{infile} #{outfile}", :cwd => Dir.tmpdir, :stdout => stdout, :stderr => stderr, :environment => env)
       end
@@ -78,20 +78,20 @@ module MCollective
         if respond_to?("load_#{format}_results")
           tempdata = send("load_#{format}_results", file)
 
-          tempdata.each_pair do |k,v|
+          tempdata.each_pair do |k, v|
             data[k.to_sym] = v
           end
         end
 
         data
-      rescue Exception => e
+      rescue Exception # rubocop:disable Lint/RescueException
         {}
       end
 
       def load_json_results(file)
         return {} unless File.readable?(file)
 
-        JSON.load(File.read(file)) || {}
+        JSON.parse(File.read(file)) || {}
       rescue JSON::ParserError
         {}
       end
@@ -119,7 +119,7 @@ module MCollective
       end
 
       def to_s
-        "%s#%s command: %s" % [ agent, action, command ]
+        "%s#%s command: %s" % [agent, action, command]
       end
 
       def tempfile(prefix)
@@ -127,15 +127,13 @@ module MCollective
       end
 
       def path_to_command(command)
-        if Util.absolute_path?(command)
-          return command
-        end
+        return command if Util.absolute_path?(command)
 
         Config.instance.libdir.each do |libdir|
           command_file_old = File.join(libdir, "agent", agent, command)
           command_file_new = File.join(libdir, "mcollective", "agent", agent, command)
-          command_file_old_exists = File.exists?(command_file_old)
-          command_file_new_exists = File.exists?(command_file_new)
+          command_file_old_exists = File.exist?(command_file_old)
+          command_file_new_exists = File.exist?(command_file_new)
 
           if command_file_new_exists && command_file_old_exists
             Log.debug("Found 'implemented_by' scripts found in two locations #{command_file_old} and #{command_file_new}")

data/lib/mcollective/rpc/agent.rb

@@ -53,8 +53,7 @@ module MCollective
         @ddl = DDL.new(@agent_name, :agent)
         @meta = @ddl.meta
         @timeout = @meta[:timeout] || 10
-
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         Log.error("Failed to load DDL for the '%s' agent, DDLs are required: %s: %s" % [@agent_name, e.class, e.to_s])
         raise DDLValidationError
       end
@@ -89,35 +88,29 @@ module MCollective
           end
         rescue RPCAborted => e
           @reply.fail e.to_s, 1
-
         rescue UnknownRPCAction => e
           @reply.fail e.to_s, 2
-
         rescue MissingRPCData => e
           @reply.fail e.to_s, 3
-
         rescue InvalidRPCData, DDLValidationError => e
           @reply.fail e.to_s, 4
-
         rescue UnknownRPCError => e
           Log.error("%s#%s failed: %s: %s" % [@agent_name, @request.action, e.class, e.to_s])
           Log.error(e.backtrace.join("\n\t"))
           @reply.fail e.to_s, 5
-
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           Log.error("%s#%s failed: %s: %s" % [@agent_name, @request.action, e.class, e.to_s])
           Log.error(e.backtrace.join("\n\t"))
           @reply.fail e.to_s, 5
-
         end
 
         after_processing_hook
 
         if @request.should_respond?
-          return @reply.to_hash
+          @reply.to_hash
         else
           Log.debug("Client did not request a response, surpressing reply")
-          return nil
+          nil
         end
       end
 
@@ -137,7 +130,7 @@ module MCollective
       #    File.exist?("/usr/bin/puppet")
       # end
       def self.activate?
-        agent_name = self.to_s.split("::").last.downcase
+        agent_name = to_s.split("::").last.downcase
         config = Config.instance
 
         Log.debug("Starting default activation checks for #{agent_name}")
@@ -146,14 +139,12 @@ module MCollective
         should_activate = config.activate_agents
 
         # Check agent specific state to determine if agent should be loaded
-        should_activate = Util.str_to_bool(config.pluginconf.fetch("#{agent_name}.activate_agent", 
-                                           should_activate))
+        should_activate = Util.str_to_bool(config.pluginconf.fetch("#{agent_name}.activate_agent",
+                                                                   should_activate))
 
-        unless should_activate
-          Log.debug("Found plugin configuration '#{agent_name}.activate_agent' with value '#{should_activate}'")
-        end
+        Log.debug("Found plugin configuration '#{agent_name}.activate_agent' with value '#{should_activate}'") unless should_activate
 
-        return should_activate
+        should_activate
       end
 
       # Returns an array of actions this agent support
@@ -163,7 +154,6 @@ module MCollective
         end
       end
 
-      private
       # Runs a command via the MC::Shell wrapper, options are as per MC::Shell
       #
       # The simplest use is:
@@ -206,22 +196,18 @@ module MCollective
         [:stderr, :stdout].each do |k|
           if options.include?(k)
             if options[k].is_a?(Symbol)
-              reply[ options[k] ] = ""
-              shellopts[k] = reply[ options[k] ]
+              reply[options[k]] = ""
+              shellopts[k] = reply[options[k]]
+            elsif options[k].respond_to?("<<")
+              shellopts[k] = options[k]
             else
-              if options[k].respond_to?("<<")
-                shellopts[k] = options[k]
-              else
-                reply.fail! "#{k} should support << while calling run(#{command})"
-              end
+              reply.fail! "#{k} should support << while calling run(#{command})"
             end
           end
         end
 
         [:stdin, :cwd, :environment, :timeout].each do |k|
-          if options.include?(k)
-            shellopts[k] = options[k]
-          end
+          shellopts[k] = options[k] if options.include?(k)
         end
 
         shell = Shell.new(command, shellopts)
@@ -263,7 +249,7 @@ module MCollective
       def self.action(name, &block)
         raise "Need to pass a body for the action" unless block_given?
 
-        self.module_eval { define_method("#{name}_action", &block) }
+        module_eval { define_method("#{name}_action", &block) }
       end
 
       # Helper that creates a method on the class that will call your authorization
@@ -272,16 +258,18 @@ module MCollective
         plugin = plugin.to_s.capitalize
 
         # turns foo_bar into FooBar
-        plugin = plugin.to_s.split("_").map {|v| v.capitalize}.join
+        plugin = plugin.to_s.split("_").map(&:capitalize).join
         pluginname = "MCollective::Util::#{plugin}"
 
         PluginManager.loadclass(pluginname) unless MCollective::Util.constants.include?(plugin)
 
+        # rubocop:disable Style/EvalWithLocation
         class_eval("
                       def authorization_hook(request)
                    #{pluginname}.authorize(request)
                       end
                    ")
+        # rubocop:enable Style/EvalWithLocation
       end
 
       # Validates a data member, if validation is a regex then it will try to match it
@@ -304,7 +292,7 @@ module MCollective
 
         Validator.validate(@request[key], validation)
       rescue ValidatorError => e
-        raise InvalidRPCData, "Input %s did not pass validation: %s" % [ key, e.message ]
+        raise InvalidRPCData, "Input %s did not pass validation: %s" % [key, e.message]
       end
 
       # convenience wrapper around Util#shellescape
@@ -323,10 +311,8 @@ module MCollective
 
         reply.data.merge!(res[:data])
 
-        if res[:exitstatus] > 0
-          reply.fail "Failed to run #{command}: #{res[:stderr]}", res[:exitstatus]
-        end
-      rescue Exception => e
+        reply.fail "Failed to run #{command}: #{res[:stderr]}", res[:exitstatus] if res[:exitstatus] > 0
+      rescue Exception => e # rubocop:disable Lint/RescueException
         Log.warn("Unhandled #{e.class} exception during #{request.agent}##{request.action}: #{e}")
         reply.fail! "Unexpected failure calling #{command}: #{e.class}: #{e}"
       end
@@ -338,15 +324,13 @@ module MCollective
       # This will not be called right when the daemon starts up, we use
       # lazy loading and initialization so it will only be called the first
       # time a request for this agent arrives.
-      def startup_hook
-      end
+      def startup_hook; end
 
       # Called just after a message was received from the middleware before
       # it gets passed to the handlers.  @request and @reply will already be
       # set, the msg passed is the message as received from the normal
       # mcollective runner and the connection is the actual connector.
-      def before_processing_hook(msg, connection)
-      end
+      def before_processing_hook(msg, connection); end
 
       # Called at the end of processing just before the response gets sent
       # to the middleware.
@@ -356,8 +340,7 @@ module MCollective
       # it is outside of the block is so you'll have access to even status codes
       # set by the exception handlers.  If you do raise an exception it will just
       # be passed onto the runner and processing will fail.
-      def after_processing_hook
-      end
+      def after_processing_hook; end
 
       # Gets called right after a request was received and calls audit plugins
       #
@@ -366,7 +349,7 @@ module MCollective
       # do not care for the auditing in a specific agent.
       def audit_request(msg, connection)
         PluginManager["rpcaudit_plugin"].audit_request(msg, connection) if @config.rpcaudit
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         Log.warn("Audit failed - #{e} - continuing to process message")
       end
     end