choria-mcorpc-support 2.23.3 → 2.24.4

data/lib/mcollective/ddl.rb

@@ -50,7 +50,6 @@ module MCollective
   module DDL
     require "mcollective/ddl/base"
     require "mcollective/ddl/agentddl"
-    require "mcollective/ddl/dataddl"
     require "mcollective/ddl/discoveryddl"
 
     # There used to be only one big nasty DDL class with a bunch of mashed

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]

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
+
+

data/lib/mcollective/discovery/delegate.ddl

@@ -0,0 +1,13 @@
+metadata    :name        => "delegate",
+            :description => "Choria CLI based delegated 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/delegate.rb

@@ -0,0 +1,72 @@
+module MCollective
+  class Discovery
+    class Delegate
+      def self.binary_name
+        "choria"
+      end
+
+      def self.discover(filter, timeout, limit, client)
+        raise("Cannot find the choria binary in your path") unless Util.command_in_path?("choria")
+
+        cmd = [binary_name, "discover", "-j", "--silent"]
+
+        cmd << "-T" << filter["collective"] if filter["collective"]
+
+        filter.fetch("identity", []).each do |i|
+          cmd << "-I" << i
+        end
+
+        filter.fetch("cf_class", []).each do |c|
+          cmd << "-C" << c
+        end
+
+        filter.fetch("fact", []).each do |f|
+          cmd << "-F" << "%s%s%s" % [f[:fact], f[:operator], f[:value]]
+        end
+
+        filter.fetch("agent", []).each do |a|
+          cmd << "-A" << a
+        end
+
+        filter.fetch("compound", []).each do |c|
+          next unless c.is_a?(Array)
+
+          cmd << "-S" << c.first["expr"]
+        end
+
+        client.options.fetch(:discovery_options, []).each do |opt|
+          cmd << "--do" << opt
+        end
+
+        cmd << "--dm" << (client.options.fetch(:discovery_method, "broadcast") rescue "broadcast")
+
+        run_discover(cmd, timeout)
+      end
+
+      def self.run_discover(cmd, timeout)
+        nodes = []
+
+        Log.debug("Executing choria for discovery using: %s" % cmd.join(" "))
+
+        Open3.popen3(ENV, *cmd) do |stdin, stdout, stderr, wait_thr|
+          stdin.close
+
+          begin
+            Timeout.timeout(timeout + 0.5) do
+              nodes.concat(JSON.parse(stdout.read))
+              status = wait_thr.value
+
+              raise("Choria discovery failed: %s" % stderr.read) unless status.exitstatus == 0
+            end
+          rescue Timeout::Error
+            Log.warn("Timeout waiting for Choria to perform discovery")
+            Process.kill("KILL", wait_thr[:pid])
+            raise("Choria failed to complete discovery within %d timeout" % timeout)
+          end
+        end
+
+        nodes
+      end
+    end
+  end
+end

data/lib/mcollective/discovery/external.ddl

@@ -0,0 +1,13 @@
+metadata    :name        => "external",
+            :description => "External executable 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/file.ddl

@@ -0,0 +1,13 @@
+metadata    :name        => "file",
+            :description => "Discovers from JSON, YAML and Text files",
+            :author      => "R.I.Pienaar <rip@devco.net>",
+            :license     => "Apache-2.0",
+            :version     => "0.1",
+            :url         => "https://choria.io/",
+            :timeout     => 2
+
+discovery do
+    capabilities [:identity]
+end
+
+

data/lib/mcollective/discovery/flatfile.ddl

@@ -1,11 +1,13 @@
 metadata    :name        => "flatfile",
-            :description => "Flatfile based discovery for node identities",
+            :description => "Discovers from JSON, YAML and Text files",
             :author      => "R.I.Pienaar <rip@devco.net>",
-            :license     => "ASL 2.0",
+            :license     => "Apache-2.0",
             :version     => "0.1",
-            :url         => "https://docs.puppetlabs.com/mcollective/",
-            :timeout     => 0
+            :url         => "https://choria.io/",
+            :timeout     => 2
 
 discovery do
-    capabilities :identity
+    capabilities [:identity]
 end
+
+

data/lib/mcollective/discovery/inventory.ddl

@@ -0,0 +1,13 @@
+metadata    :name        => "delegate",
+            :description => "Choria CLI based delegated 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/mc.ddl

@@ -1,9 +1,9 @@
 metadata    :name        => "mc",
-            :description => "MCollective Broadcast based discovery",
+            :description => "Choria Broadcast based discovery",
             :author      => "R.I.Pienaar <rip@devco.net>",
-            :license     => "ASL 2.0",
+            :license     => "Apache-2.0",
             :version     => "0.1",
-            :url         => "https://docs.puppetlabs.com/mcollective/",
+            :url         => "https://choria.io",
             :timeout     => 2
 
 discovery do

data/lib/mcollective/log.rb

@@ -96,9 +96,8 @@ module MCollective
         end
 
         @logger.start
-      rescue Exception => e # rubocop:disable Lint/RescueException
+      rescue Exception # rubocop:disable Lint/RescueException
         @configured = false
-        warn "Could not start logger: #{e.class} #{e}"
       end
 
       # figures out the filename that called us

data/lib/mcollective/optionparser.rb

@@ -168,7 +168,7 @@ module MCollective
         raise "Cannot read the discovery file #{v}" unless File.readable?(v)
 
         @options[:discovery_method] = "flatfile"
-        @options[:discovery_options] << v
+        @options[:discovery_options] << "file=%s" % v
       end
 
       @parser.on("--publish_timeout TIMEOUT", Integer, "Timeout for publishing requests to remote agents.") do |pt|

data/lib/mcollective/pluginpackager/forge_packager.rb

@@ -191,7 +191,7 @@ module MCollective
       end
 
       def render_template(infile, outfile)
-        erb = ERB.new(File.read(infile), 0, "%")
+        erb = ERB.new(File.read(infile), 0, "-")
         File.open(outfile, "w") do |f|
           f.puts erb.result(binding)
         end

data/lib/mcollective/rpc/client.rb

@@ -533,6 +533,8 @@ module MCollective
 
         # All else fails we do it the hard way using a traditional broadcast
         unless @discovered_agents
+          raise("Invalid discovery method %s" % discovery_method) unless @client.discoverer.find_known_methods.include?(discovery_method)
+
           @stats.time_discovery :start
 
           @client.options = options
@@ -548,9 +550,9 @@ module MCollective
             actual_timeout = @client.discoverer.discovery_timeout(discovery_timeout, options[:filter])
 
             if actual_timeout > 0
-              @stderr.print("Discovering hosts using the %s method for %d second(s) .... " % [@client.discoverer.discovery_method, actual_timeout])
+              @stderr.print("Discovering hosts using the %s method for %d second(s) .... " % [discovery_method, actual_timeout])
             else
-              @stderr.print("Discovering hosts using the %s method .... " % [@client.discoverer.discovery_method])
+              @stderr.print("Discovering hosts using the %s method .... " % discovery_method)
             end
           end
 

data/lib/mcollective/util.rb

@@ -147,13 +147,11 @@ module MCollective
 
     # Returns the PuppetLabs mcollective path for windows
     def self.windows_prefix
-      require "win32/dir"
-      File.join(Dir::COMMON_APPDATA, "PuppetLabs", "choria")
+      File.join(ENV["ALLUSERSPROFILE"], "PuppetLabs", "choria")
     end
 
     def self.choria_windows_prefix
-      require "win32/dir"
-      File.join(Dir::COMMON_APPDATA, "ChoriaIO", "choria")
+      File.join(ENV["ALLUSERSPROFILE"], "choria")
     end
 
     def self.config_paths_for_user

data/lib/mcollective/util/choria.rb

@@ -157,19 +157,19 @@ module MCollective
 
       # Determines if SRV records should be used
       #
-      # Setting choria.use_srv_records to anything other than t, true, yes or 1 will disable
+      # Setting choria.use_srv to anything other than t, true, yes or 1 will disable
       # SRV records
       #
       # @return [Boolean]
       def should_use_srv?
-        ["t", "true", "yes", "1"].include?(get_option("choria.use_srv_records", "1").downcase)
+        ["t", "true", "yes", "1"].include?(get_option("choria.use_srv", "1").downcase)
       end
 
       # Query DNS for a series of records
       #
       # The given records will be passed through {#srv_records} to figure out the domain to query in.
       #
-      # Querying of records can be bypassed by setting choria.use_srv_records to false
+      # Querying of records can be bypassed by setting choria.use_srv to false
       #
       # @yield [Hash] each record for modification by the caller
       # @param records [Array<String>] the records to query without their domain parts
@@ -634,21 +634,27 @@ module MCollective
 
       # The PuppetDB server to connect to
       #
-      # Will consult _x-puppet-db._tcp.example.net then _x-puppet._tcp.example.net
-      # then configurable using choria.puppetdb_host and choria.puppetdb_port, defaults
-      # to puppet:8081
+      # Use choria.puppetdb_host if set, otherwise query
+      # _x-puppet-db._tcp.example.net then _x-puppet._tcp.example.net if SRV
+      # lookup is enabled, and fallback to puppet:8081 if nothing else worked.
       #
       # @return [Hash] with :target and :port
       def puppetdb_server
-        d_host = get_option("choria.puppetdb_host", "puppet")
         d_port = get_option("choria.puppetdb_port", "8081")
 
+        answer = {
+          :target => get_option("choria.puppetdb_host", nil),
+          :port => d_port
+        }
+
+        return answer if answer[:target]
+
         answer = try_srv(["_x-puppet-db._tcp"], nil, nil)
         return answer if answer[:target]
 
         # In the case where we take _x-puppet._tcp SRV records we unfortunately have
         # to force the port else it uses the one from Puppet which will 404
-        answer = try_srv(["_x-puppet._tcp"], d_host, d_port)
+        answer = try_srv(["_x-puppet._tcp"], "puppet", d_port)
         answer[:port] = d_port
 
         answer