choria-mcorpc-support 2.23.3 → 2.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 73c63dbc1dacba7b90acdba3141cfedd3731da11
-  data.tar.gz: 42cfc48d721f69b6ec805e71624a8b8cff0fc141
+SHA256:
+  metadata.gz: d257a05d7cf82742e97521bbe9e40f7c20df649c9d65d6eda5ae2bf3993c8598
+  data.tar.gz: 2615868ac083003a9ca4f0eb6578f78e10cc5607686050940c6f68cf8da28a08
 SHA512:
-  metadata.gz: 2f5370f390815f5881473b6c0e482db4f821f88ecb2616e33af9aa29a91e1561f1306b24945b1df2fe9d7ad05f8f770908298cb9279ae6dedb90658906654454
-  data.tar.gz: 250ca8bb59baccda7324a4f21f7db4f938c6fc06cdfe968f46263e0fe11ba55214d237dda44a5db0243500007a8ffec856e336880334d5e0df3d2e53903499a9
+  metadata.gz: 159da1e1cd128e985466cc105dc1d261be41fa005fd7ef56475972a401cc0274f3ced19fe0c74a912c8d9324b0a41fc12e3e6edb4e251e0e7b76798d297a8c71
+  data.tar.gz: dff94f50b37d25b6f7fdbea30591f46a17e2a59186aa512422fe91bbef2350bd9be87d9fa7c5ed81ad6d22ada96f4ed5ff3e43173f05e4f1b80133f6aeaf2634

data/lib/mcollective.rb

@@ -15,6 +15,7 @@ require "mcollective/monkey_patches"
 require "mcollective/cache"
 require "mcollective/exceptions"
 require "systemu"
+require "open3"
 
 # == The Marionette Collective
 #
@@ -34,9 +35,9 @@ module MCollective
   require "mcollective/client"
   require "mcollective/config"
   require "mcollective/connector"
-  require "mcollective/data"
   require "mcollective/ddl"
   require "mcollective/discovery"
+  require "mcollective/discovery/delegate"
   require "mcollective/facts"
   require "mcollective/logger"
   require "mcollective/log"
@@ -53,7 +54,7 @@ module MCollective
   require "mcollective/util"
   require "mcollective/validator"
 
-  VERSION = "2.23.3".freeze
+  VERSION = "2.24.0".freeze
 
   def self.version
     VERSION

data/lib/mcollective/application/find.rb

@@ -16,7 +16,7 @@ class MCollective::Application::Find < MCollective::Application # rubocop:disabl
 
     nodes.each {|c| puts c}
 
-    warn "\nDiscovered %s nodes in %.2f seconds using the %s discovery plugin" % [nodes.size, discoverytime, mc.client.discoverer.discovery_method] if options[:verbose]
+    warn "\nDiscovered %s nodes in %.2f seconds using the %s discovery plugin" % [nodes.size, discoverytime, mc.client.options[:discovery_method]] if options[:verbose]
 
     !nodes.empty? ? exit(0) : exit(1)
   end

data/lib/mcollective/application/plugin.rb

@@ -9,7 +9,6 @@ mco plugin package [options] <directory>
        mco plugin doc <plugin>
        mco plugin doc <type/plugin>
        mco plugin generate agent <pluginname> [actions=val,val]
-       mco plugin generate data <pluginname> [outputs=val,val]
 
           info : Display plugin information including package details.
        package : Create all available plugin packages.
@@ -116,11 +115,6 @@ mco plugin package [options] <directory>
            :arguments => ["--actions [ACTIONS]"],
            :type => Array
 
-    option :outputs,
-           :description => "Outputs to be generated for an Data Plugin",
-           :arguments => ["--outputs [OUTPUTS]"],
-           :type => Array
-
     option :keep_artifacts,
            :description => "Don't remove artifacts after building packages",
            :arguments => ["--keep-artifacts"],
@@ -167,7 +161,7 @@ mco plugin package [options] <directory>
 
     # Generate a plugin skeleton
     def generate_command
-      raise "undefined plugin type. cannot generate plugin. valid types are 'agent' and 'data'" if configuration["target"] == "."
+      raise "undefined plugin type. cannot generate plugin. valid types are 'agent'" if configuration["target"] == "."
 
       unless configuration[:pluginname]
         puts "No plugin name specified. Using 'new_plugin'"
@@ -181,12 +175,6 @@ mco plugin package [options] <directory>
         Generators::AgentGenerator.new(configuration[:pluginname], configuration[:actions], configuration[:pluginname],
                                        configuration[:description], configuration[:author], configuration[:license],
                                        configuration[:version], configuration[:url], configuration[:timeout])
-      when "data"
-        raise "data plugin must have at least one output" unless configuration[:outputs]
-
-        Generators::DataGenerator.new(configuration[:pluginname], configuration[:outputs], configuration[:pluginname],
-                                      configuration[:description], configuration[:author], configuration[:license],
-                                      configuration[:version], configuration[:url], configuration[:timeout])
       else
         raise "invalid plugin type. cannot generate plugin '#{configuration[:target]}'"
       end
@@ -228,7 +216,6 @@ mco plugin package [options] <directory>
         ["Agents", :agent],
         ["Aggregate", :aggregate],
         ["Connectors", :connector],
-        ["Data Queries", :data],
         ["Discovery Methods", :discovery],
         ["Validator Plugins", :validator]
       ]
@@ -345,7 +332,7 @@ mco plugin package [options] <directory>
     # Return the name of the type of plugin as a string
     def identify_plugin
       plugintype = Dir.glob(File.join(configuration[:target], "*")).select do |file|
-        File.directory?(file) && file.match(/(connector|facts|registration|security|audit|pluginpackager|data|discovery|validator)/)
+        File.directory?(file) && file.match(/(connector|facts|registration|security|audit|pluginpackager|discovery|validator)/)
       end
 
       raise "more than one plugin type detected in directory" if plugintype.size > 1

data/lib/mcollective/client.rb

@@ -150,7 +150,7 @@ module MCollective
     # of the discovery being cancelled soon as it reached the
     # requested limit of hosts
     def discover(filter, timeout, limit=0)
-      @discoverer.discover(filter.merge("collective" => collective), timeout, limit)
+      @discoverer.discover(filter.merge("collective" => collective), timeout, limit, self)
     end
 
     # Send a request, performs the passed block for each response

data/lib/mcollective/config.rb

@@ -17,123 +17,130 @@ module MCollective
       @configured = false
     end
 
-    def loadconfig(configfile) # rubocop:disable Metrics/MethodLength
-      set_config_defaults(configfile)
+    def parse_config_file(configfile, libdirs) # rubocop:disable Metrics/MethodLength
+      File.readlines(configfile).each do |line|
+        # strip blank spaces, tabs etc off the end of all lines
+        line.gsub!(/\s*$/, "")
 
-      if File.exist?(configfile)
-        libdirs = []
-        File.readlines(configfile).each do |line|
-          # strip blank spaces, tabs etc off the end of all lines
-          line.gsub!(/\s*$/, "")
+        next if line =~ /^#|^$/
+        next unless line =~ /(.+?)\s*=\s*(.+)/
 
-          next if line =~ /^#|^$/
-          next unless line =~ /(.+?)\s*=\s*(.+)/
+        key = $1.strip
+        val = $2
 
-          key = $1.strip
-          val = $2
+        begin
+          case key
+          when "collectives"
+            @collectives = val.split(",").map(&:strip)
+          when "main_collective"
+            @main_collective = val
+          when "logfile"
+            @logfile = val
+          when "keeplogs"
+            @keeplogs = Integer(val)
+          when "max_log_size"
+            @max_log_size = Integer(val)
+          when "loglevel"
+            @loglevel = val
+          when "logfacility"
+            @logfacility = val
+          when "libdir"
+            paths = val.split(File::PATH_SEPARATOR)
+            paths.each do |path|
+              raise("libdir paths should be absolute paths but '%s' is relative" % path) unless Util.absolute_path?(path)
 
-          begin
-            case key
-            when "collectives"
-              @collectives = val.split(",").map(&:strip)
-            when "main_collective"
-              @main_collective = val
-            when "logfile"
-              @logfile = val
-            when "keeplogs"
-              @keeplogs = Integer(val)
-            when "max_log_size"
-              @max_log_size = Integer(val)
-            when "loglevel"
-              @loglevel = val
-            when "logfacility"
-              @logfacility = val
-            when "libdir"
-              paths = val.split(File::PATH_SEPARATOR)
-              paths.each do |path|
-                raise("libdir paths should be absolute paths but '%s' is relative" % path) unless Util.absolute_path?(path)
-
-                libdirs << path
-              end
-            when "identity"
-              @identity = val
-            when "direct_addressing"
-              @direct_addressing = Util.str_to_bool(val)
-            when "direct_addressing_threshold"
-              @direct_addressing_threshold = Integer(val)
-            when "color"
-              @color = Util.str_to_bool(val)
-            when "daemonize"
-              @daemonize = Util.str_to_bool(val)
-            when "securityprovider"
-              @securityprovider = val.capitalize
-            when "factsource"
-              @factsource = val.capitalize
-            when "connector"
-              @connector = val.capitalize
-            when "classesfile"
-              @classesfile = val
-            when /^plugin.(.+)$/
-              @pluginconf[$1] = val
-            when "discovery_timeout"
-              @discovery_timeout = Integer(val)
-            when "publish_timeout"
-              @publish_timeout = Integer(val)
-            when "connection_timeout"
-              @connection_timeout = Integer(val)
-            when "rpcaudit"
-              @rpcaudit = Util.str_to_bool(val)
-            when "rpcauditprovider"
-              @rpcauditprovider = val.capitalize
-            when "rpcauthorization"
-              @rpcauthorization = Util.str_to_bool(val)
-            when "rpcauthprovider"
-              @rpcauthprovider = val.capitalize
-            when "rpclimitmethod"
-              @rpclimitmethod = val.to_sym
-            when "logger_type"
-              @logger_type = val
-            when "fact_cache_time"
-              @fact_cache_time = Integer(val)
-            when "ssl_cipher"
-              @ssl_cipher = val
-            when "threaded"
-              @threaded = Util.str_to_bool(val)
-            when "ttl"
-              @ttl = Integer(val)
-            when "default_discovery_options"
-              @default_discovery_options << val
-            when "default_discovery_method"
-              @default_discovery_method = val
-            when "soft_shutdown"
-              @soft_shutdown = Util.str_to_bool(val)
-            when "soft_shutdown_timeout"
-              @soft_shutdown_timeout = Integer(val)
-            when "activate_agents"
-              @activate_agents = Util.str_to_bool(val)
-            when "default_batch_size"
-              @default_batch_size = Integer(val)
-            when "default_batch_sleep_time"
-              @default_batch_sleep_time = Float(val)
-            else
-              # server config might now be choria config which will divirge from mcollective
-              # in time, so we only raise this error when it looks like we aren't loading
-              # a server config else we try our best to load as much as we can
-              raise("Unknown config parameter '#{key}'") unless configfile =~ /server/
+              libdirs << path
             end
-          rescue ArgumentError
-            raise("Could not parse value for configuration option '%s' with value '%s'" % [key, val])
+          when "identity"
+            @identity = val
+          when "direct_addressing"
+            @direct_addressing = Util.str_to_bool(val)
+          when "direct_addressing_threshold"
+            @direct_addressing_threshold = Integer(val)
+          when "color"
+            @color = Util.str_to_bool(val)
+          when "daemonize"
+            @daemonize = Util.str_to_bool(val)
+          when "securityprovider"
+            @securityprovider = val.capitalize
+          when "factsource"
+            @factsource = val.capitalize
+          when "connector"
+            @connector = val.capitalize
+          when "classesfile"
+            @classesfile = val
+          when /^plugin.(.+)$/
+            @pluginconf[$1] = val
+          when "discovery_timeout"
+            @discovery_timeout = Integer(val)
+          when "publish_timeout"
+            @publish_timeout = Integer(val)
+          when "connection_timeout"
+            @connection_timeout = Integer(val)
+          when "rpcaudit"
+            @rpcaudit = Util.str_to_bool(val)
+          when "rpcauditprovider"
+            @rpcauditprovider = val.capitalize
+          when "rpcauthorization"
+            @rpcauthorization = Util.str_to_bool(val)
+          when "rpcauthprovider"
+            @rpcauthprovider = val.capitalize
+          when "rpclimitmethod"
+            @rpclimitmethod = val.to_sym
+          when "logger_type"
+            @logger_type = val
+          when "fact_cache_time"
+            @fact_cache_time = Integer(val)
+          when "ssl_cipher"
+            @ssl_cipher = val
+          when "threaded"
+            @threaded = Util.str_to_bool(val)
+          when "ttl"
+            @ttl = Integer(val)
+          when "default_discovery_options"
+            @default_discovery_options << val
+          when "default_discovery_method"
+            @default_discovery_method = val
+          when "soft_shutdown"
+            @soft_shutdown = Util.str_to_bool(val)
+          when "soft_shutdown_timeout"
+            @soft_shutdown_timeout = Integer(val)
+          when "activate_agents"
+            @activate_agents = Util.str_to_bool(val)
+          when "default_batch_size"
+            @default_batch_size = Integer(val)
+          when "default_batch_sleep_time"
+            @default_batch_sleep_time = Float(val)
+          else
+            # server config might now be choria config which will divirge from mcollective
+            # in time, so we only raise this error when it looks like we aren't loading
+            # a server config else we try our best to load as much as we can
+            raise("Unknown config parameter '#{key}'") unless configfile =~ /server/
           end
+        rescue ArgumentError
+          raise("Could not parse value for configuration option '%s' with value '%s'" % [key, val])
         end
+      end
+    end
+
+    def loadconfig(configfile)
+      set_config_defaults(configfile)
+
+      if File.exist?(configfile)
+        libdirs = []
+
+        parse_config_file(configfile, libdirs)
 
         read_plugin_config_dir("#{@configdir}/plugin.d")
 
-        raise 'Identities can only match /\w\.\-/' unless @identity =~ /^[\w.\-]+$/
+        parse_project_config(libdirs)
+
+        raise('Identities can only match /\w\.\-/') unless @identity =~ /^[\w.\-]+$/
 
         @configured = true
 
         libdirs.each do |dir|
-          Log.debug("Cannot find libdir: #{dir}") unless File.directory?(dir)
+          Log.debug("Cannot find libdir: %s" % dir) unless File.directory?(dir)
 
           # remove the old one if it exists, we're moving it to the front
           $LOAD_PATH.reject! { |elem| elem == dir }
@@ -154,6 +161,31 @@ module MCollective
       end
     end
 
+    def project_root
+      Dir.pwd
+    end
+
+    def parse_project_config(libdirs)
+      project_config_files(project_root).each do |pfile|
+        parse_config_file(pfile, libdirs)
+      end
+    end
+
+    def project_config_files(path)
+      paths = []
+
+      path = File.expand_path(path)
+      parent = File.expand_path("..", path)
+
+      paths << project_config_files(parent) if parent != path
+
+      config = File.join(path, "choria.conf")
+
+      paths << config if File.exist?(config)
+
+      paths.flatten
+    end
+
     def set_config_defaults(configfile) # rubocop:disable Naming/AccessorMethodName
       @subscribe = []
       @pluginconf = {}

data/lib/mcollective/discovery.rb

@@ -1,30 +1,26 @@
 module MCollective
   class Discovery
     def initialize(client)
-      @known_methods = find_known_methods
-      @default_method = Config.instance.default_discovery_method
       @client = client
     end
 
     def find_known_methods
-      PluginManager.find("discovery")
+      ["broadcast", "mc", "inventory", "flatfile", "external", "choria", "file"]
     end
 
     def has_method?(method)
-      @known_methods.include?(method)
+      find_known_methods.include?(method)
     end
 
     def force_direct_mode?
-      discovery_method != "mc"
+      true
     end
 
     def discovery_method
-      method = "mc"
-
       if @client.options[:discovery_method]
         method = @client.options[:discovery_method]
       else
-        method = @default_method
+        method = Config.instance.default_discovery_method
       end
 
       raise "Unknown discovery method %s" % method unless has_method?(method)
@@ -35,11 +31,11 @@ module MCollective
     end
 
     def discovery_class
-      method = discovery_method.capitalize
-
-      PluginManager.loadclass("MCollective::Discovery::#{method}") unless self.class.const_defined?(method)
+      Delegate
+    end
 
-      self.class.const_get(method)
+    def check_capabilities(filter)
+      true
     end
 
     def ddl
@@ -52,71 +48,23 @@ module MCollective
       @ddl
     end
 
-    # Agent filters are always present no matter what, so we cant raise an error if the capabilities
-    # suggest the discovery method cant do agents we just have to rely on the discovery plugin to not
-    # do stupid things in the presense of a agent filter
-    def check_capabilities(filter)
-      capabilities = ddl.discovery_interface[:capabilities]
-
-      raise "Cannot use class filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:classes) && !filter["cf_class"].empty?
-
-      raise "Cannot use fact filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:facts) && !filter["fact"].empty?
-
-      raise "Cannot use identity filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:identity) && !filter["identity"].empty?
-
-      raise "Cannot use compound filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:compound) && !filter["compound"].empty?
-    end
-
     # checks if compound filters are used and then forces the 'mc' discovery plugin
     def force_discovery_method_by_filter(filter)
-      if discovery_method != "mc" && !filter["compound"].empty?
-        Log.info "Switching to mc discovery method because compound filters are used"
-        @client.options[:discovery_method] = "mc"
-
-        return true
-      end
-
       false
     end
 
-    # if a compound filter is specified and it has any function
-    # then we read the DDL for each of those plugins and sum up
-    # the timeout declared in the DDL
     def timeout_for_compound_filter(compound_filter)
-      return 0 if compound_filter.nil? || compound_filter.empty?
-
-      # disabled while bringing in new compound filters
-      # compound_filter.each do |filter|
-      #   filter.each do |statement|
-      #     next unless statement["fstatement"]
-      #
-      #     pluginname = Data.pluginname(statement["fstatement"]["name"])
-      #     ddl = DDL.new(pluginname, :data)
-      #     timeout += ddl.meta[:timeout]
-      #   end
-      # end
-
       0
     end
 
     def discovery_timeout(timeout, filter)
-      timeout ||= ddl.meta[:timeout]
-
-      if filter["compound"] && filter["compound"].empty?
-        timeout
-      else
-        timeout + timeout_for_compound_filter(filter["compound"])
-      end
+      timeout || ddl.meta[:timeout]
     end
 
-    def discover(filter, timeout, limit)
+    def discover(filter, timeout, limit, client)
       raise "Limit has to be an integer" unless limit.is_a?(Integer)
 
-      force_discovery_method_by_filter(filter)
-
-      check_capabilities(filter)
-
-      discovered = discovery_class.discover(filter, discovery_timeout(timeout, filter), limit, @client)
+      discovered = discovery_class.discover(filter, discovery_timeout(timeout, filter), limit, client)
 
       if limit > 0
         discovered[0, limit]