choria-mcorpc-support 2.23.0.pre → 2.24.0

data/lib/mcollective/application/tasks.rb

@@ -148,6 +148,13 @@ Examples:
                           :required => false,
                           :default => 1,
                           :type => Integer
+
+        self.class.option :__run_as,
+                          :arguments => ["--run-as USERNAME"],
+                          :description => "Run task as user USERNAME",
+                          :required => false,
+                          :default => nil,
+                          :type => String
       end
 
       def say(msg="")
@@ -180,6 +187,8 @@ Examples:
           :files => meta["files"].to_json
         }
 
+        request[:run_as] = configuration[:__run_as] if configuration[:__run_as]
+
         request[:input] = input.to_json if input
 
         if configuration[:__background]

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,72 +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?
-
-      timeout = 0
-
-      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
-
-      timeout
+      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]

data/lib/mcollective/discovery/broadcast.ddl

@@ -0,0 +1,11 @@
+metadata    :name        => "broadcast",
+            :description => "Choria Broadcast based discovery",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "Apache-2.0",
+            :version     => "0.1",
+            :url         => "https://choria.io",
+            :timeout     => 2
+
+discovery do
+    capabilities [:classes, :facts, :identity, :agents, :compound]
+end

data/lib/mcollective/discovery/choria.ddl

@@ -1,11 +1,13 @@
 metadata    :name        => "choria",
-            :description => "PuppetDB based discovery for the Choria plugin suite",
+            :description => "PuppetDB based discovery method",
             :author      => "R.I.Pienaar <rip@devco.net>",
             :license     => "Apache-2.0",
-            :version     => "0.19.0",
-            :url         => "https://github.com/choria-io",
-            :timeout     => 0
+            :version     => "0.1",
+            :url         => "https://choria.io/",
+            :timeout     => 2
 
 discovery do
     capabilities [:classes, :facts, :identity, :agents]
 end
+
+