choria-mcorpc-support 2.21.0 → 2.23.0

data/lib/mcollective/application/choria.rb

@@ -0,0 +1,249 @@
+module MCollective
+  class Application
+    class Choria < Application
+      description "Choria Orchestrator Management and Configuration"
+
+      usage <<-USAGE
+  mco choria [OPTIONS] <ACTION>
+
+  The ACTION can be one of the following:
+
+     request_cert - requests a certificate from the Puppet CA
+     show_config  - shows the active configuration parameters
+
+  The environment is chosen using --environment and the concurrent
+  runs may be limited using --batch.
+
+  The batching works a bit different than typical, it will only batch
+  based on a sorted list of certificate names, this means the batches
+  will always run in predictable order.
+      USAGE
+
+      exclude_argument_sections "common", "filter", "rpc"
+
+      option :ca,
+             :arguments => ["--ca SERVER"],
+             :description => "Address of your Puppet CA",
+             :type => String
+
+      option :certname,
+             :arguments => ["--certname CERTNAME"],
+             :description => "Override the default certificate name",
+             :type => String
+
+      def post_option_parser(configuration)
+        if ARGV.length >= 1
+          configuration[:command] = ARGV.shift
+        else
+          abort("Please specify a command, valid commands are: %s" % valid_commands.join(", "))
+        end
+
+        ENV["MCOLLECTIVE_CERTNAME"] = configuration[:certname] if configuration[:certname]
+      end
+
+      # Validates the configuration
+      #
+      # @return [void]
+      def validate_configuration(configuration)
+        Util.loadclass("MCollective::Util::Choria")
+
+        abort("Unknown command %s, valid commands are: %s" % [configuration[:command], valid_commands.join(", ")]) unless valid_commands.include?(configuration[:command])
+
+        if !choria.has_client_public_cert? && !["request_cert", "show_config"].include?(configuration[:command])
+          abort("A certificate is needed from the Puppet CA for `%s`, please use the `request_cert` command" % choria.certname)
+        end
+      end
+
+      def main
+        send("%s_command" % configuration[:command])
+      rescue Util::Choria::UserError
+        warn("Encountered a critical error: %s" % Util.colorize(:red, $!.to_s))
+      rescue Util::Choria::Abort
+        exit(1)
+      end
+
+      # Requests a certificate from the CA
+      #
+      # @return [void]
+      def request_cert_command
+        disconnect
+
+        raise(Util::Choria::UserError, "Cannot only request certificates in Puppet security mode") unless choria.puppet_security?
+
+        raise(Util::Choria::UserError, "Already have a certificate '%s', cannot request a new one" % choria.client_public_cert) if choria.has_client_public_cert?
+
+        choria.ca = configuration[:ca] if configuration[:ca]
+
+        certname = choria.client_public_cert
+
+        choria.make_ssl_dirs
+        choria.fetch_ca
+
+        if choria.waiting_for_cert?
+          puts("Certificate %s has already been requested, attempting to retrieve it" % certname)
+        else
+          puts("Requesting certificate for '%s'" % certname)
+          choria.request_cert
+        end
+
+        puts("Waiting up to 240 seconds for it to be signed")
+        puts
+
+        puts("Key fingerprint: %s" % choria.csr_fingerprint)
+        puts
+
+        24.times do |time|
+          print "Attempting to download certificate %s: %d / 24\r" % [certname, time]
+
+          break if choria.attempt_fetch_cert
+
+          sleep 10
+        end
+
+        unless choria.has_client_public_cert?
+          raise(Util::Choria::UserError, "Could not fetch the certificate after 240 seconds, please ensure it gets signed and rerun this command")
+        end
+
+        puts("Certificate %s has been stored in %s" % [certname, choria.ssl_dir])
+      end
+
+      def show_config_command # rubocop:disable Metrics/MethodLength
+        disconnect
+
+        puts "Active Choria configuration:"
+        puts
+        puts "The active configuration used in Choria comes from using Puppet AIO defaults, querying SRV"
+        puts "records and reading configuration files.  The below information shows the completely resolved"
+        puts "configuration that will be used when running MCollective commands"
+        puts
+        puts "MCollective related:"
+        puts
+        puts "    MCollective Version: %s" % MCollective::VERSION
+        puts "         Choria Version: %s" % Util::Choria::VERSION
+        puts "     Client Config File: %s" % Util.config_file_for_user
+        puts "     Active Config File: %s" % Config.instance.configfile
+        puts "      Plugin Config Dir: %s" % File.join(Config.instance.configdir, "plugin.d")
+        puts "      Using SRV Records: %s" % choria.should_use_srv?
+        puts "              Federated: %s" % choria.federated?
+        puts "             SRV Domain: %s" % choria.srv_domain
+        puts "               NATS NGS: %s" % choria.ngs?
+
+        middleware_servers = choria.middleware_servers("puppet", 4222).map {|s, p| "%s:%s" % [s, p]}.join(", ")
+
+        puts "     Middleware Servers: %s" % middleware_servers
+
+        if choria.federated?
+          fed_servers = choria.federation_middleware_servers
+          if fed_servers
+            puts "     Federation Servers: %s" % fed_servers.map {|s, p| "%s:%s" % [s, p]}.join(", ")
+          else
+            puts "     Federation Servers: %s (fallback to normal client settings)" % middleware_servers
+          end
+          puts " Federation Collectives: %s" % choria.federation_collectives.join(", ")
+        end
+
+        puts
+
+        puppet_server = choria.puppet_server
+        puppetca_server = choria.puppetca_server
+        puppetdb_server = choria.puppetdb_server
+
+        puts "Puppet related:"
+        puts
+        puts "       Puppet Server: %s:%s" % [puppet_server[:target], puppet_server[:port]]
+        puts "     PuppetCA Server: %s:%s" % [puppetca_server[:target], puppetca_server[:port]]
+        puts "     PuppetDB Server: %s:%s" % [puppetdb_server[:target], puppetdb_server[:port]]
+
+        if choria.proxied_discovery?
+          proxy_server = choria.discovery_server
+          puts "     Discovery Proxy: %s:%s" % [proxy_server[:target], proxy_server[:port]]
+        else
+          puts "     Discovery Proxy: not using a proxy"
+        end
+
+        puts "      Facter Command: %s" % choria.facter_cmd
+        puts "       Facter Domain: %s" % choria.facter_domain
+
+        puts
+
+        puts "Security setup:"
+        puts
+
+        valid_ssl = choria.check_ssl_setup(false) rescue false
+
+        if valid_ssl
+          puts "     Valid SSL Setup: %s" % [Util.colorize(:green, "yes")]
+        else
+          puts "     Valid SSL Setup: %s try running 'mco choria request_cert'" % [Util.colorize(:red, "no")]
+        end
+
+        puts "   Security Provider: %s" % [choria.security_provider]
+        puts "            Certname: %s" % [choria.certname]
+        puts "       SSL Directory: %s (%s)" % [choria.ssl_dir, File.exist?(choria.ssl_dir) ? Util.colorize(:green, "found") : Util.colorize(:red, "absent")]
+        puts "  Client Public Cert: %s (%s)" % [choria.client_public_cert, choria.has_client_public_cert? ? Util.colorize(:green, "found") : Util.colorize(:red, "absent")]
+        puts "  Client Private Key: %s (%s)" % [choria.client_private_key, choria.has_client_private_key? ? Util.colorize(:green, "found") : Util.colorize(:red, "absent")]
+        puts "             CA Path: %s (%s)" % [choria.ca_path, choria.has_ca? ? Util.colorize(:green, "found") : Util.colorize(:red, "absent")]
+        puts "            CSR Path: %s (%s)" % [choria.csr_path, choria.has_csr? ? Util.colorize(:green, "found") : Util.colorize(:red, "absent")]
+
+        if choria.has_client_public_cert?
+          cn = choria.valid_certificate?(File.read(choria.client_public_cert), choria.certname, false)
+
+          puts "      Public Cert CN: %s (%s)" % [cn, cn == choria.certname ? Util.colorize(:green, "match") : Util.colorize(:red, "does not match certname")]
+        end
+
+        if choria.credential_file?
+          puts "    NATS Credentials: %s (%s)" % [
+            choria.credential_file,
+            File.exist?(choria.credential_file) ? Util.colorize(:green, "exit") : Util.colorize(:red, "does not exist")
+          ]
+          puts "         'nkeys' gem: %s" % choria.nkeys?
+        end
+
+        puts
+
+        puts "Active Choria configuration settings as found in configuration files:"
+        puts
+
+        choria_settings = Config.instance.pluginconf.select {|k, _| k.start_with?("choria")}
+        padding = choria_settings.empty? ? 2 : choria_settings.keys.map(&:length).max + 2
+
+        if choria_settings.empty?
+          puts "  No custom Choria settings found in your configuration files"
+        else
+          choria_settings.each do |k, v|
+            puts "%#{padding}s: %s" % [k, v]
+          end
+        end
+
+        puts
+      end
+
+      # Creates and cache a Choria helper class
+      #
+      # @return [Util::Choria]
+      def choria
+        @_choria ||= Util::Choria.new(false)
+      end
+
+      # List of valid commands this application respond to
+      #
+      # @return [Array<String>] like `plan` and `run`
+      def valid_commands
+        methods.grep(/_command$/).map {|c| c.to_s.gsub("_command", "")}
+      end
+
+      # Asks the user to confirm something on the CLI
+      #
+      # @note exits the application on no
+      # @param msg [String] the message to ask
+      # @return [void]
+      def confirm(msg)
+        print("%s (y/n) " % msg)
+
+        $stdout.flush
+
+        exit(1) unless $stdin.gets.strip.match?(/^(?:y|yes)$/i)
+      end
+    end
+  end
+end

data/lib/mcollective/application/completion.rb

@@ -1,5 +1,5 @@
 module MCollective
-  class Application::Completion<MCollective::Application
+  class Application::Completion < MCollective::Application # rubocop:disable Style/ClassAndModuleChildren
     description "Helper for shell completion systems"
 
     exclude_argument_sections "common", "filter", "rpc"
@@ -43,8 +43,8 @@ module MCollective
         PluginManager.find(:agent, "ddl").each do |agent|
           begin
             ddl = DDL.new(agent)
-            puts "%s:%s" % [ agent, ddl.meta[:description] ]
-          rescue
+            puts "%s:%s" % [agent, ddl.meta[:description]]
+          rescue # rubocop:disable Lint/SuppressedException
           end
         end
       else
@@ -64,7 +64,7 @@ module MCollective
       else
         DDL.new(configuration[:agent], :agent).actions.sort.each {|a| puts a}
       end
-    rescue
+    rescue # rubocop:disable Lint/SuppressedException
     end
 
     def list_inputs
@@ -79,7 +79,7 @@ module MCollective
       else
         DDL.new(configuration[:agent], :agent).action_interface(configuration[:action])[:input].keys.sort.each {|i| puts i}
       end
-    rescue
+    rescue # rubocop:disable Lint/SuppressedException
     end
 
     def list_applications
@@ -93,7 +93,7 @@ module MCollective
     end
 
     def main
-      actions = configuration.keys.map{|k| k.to_s}.grep(/^list_/)
+      actions = configuration.keys.map(&:to_s).grep(/^list_/)
 
       abort "Please choose either --list-[agents|actions|inputs|applications]" if actions.empty?
       abort "Please choose only one of --list-[agents|actions|inputs|applications]" if actions.size > 1

data/lib/mcollective/application/describe_filter.rb

@@ -1,5 +1,5 @@
 module MCollective
-  class Application::Describe_filter<Application
+  class Application::Describe_filter < Application # rubocop:disable Style/ClassAndModuleChildren
     exclude_argument_sections "common", "rpc"
 
     description "Display human readable interpretation of filters"
@@ -12,30 +12,29 @@ module MCollective
       puts "-S Query expands to the following instructions:"
       puts
       stack.each do |token|
-        if token.keys[0] == "statement"
+        case token.keys[0]
+        when "statement"
           if token.values[0] =~ /(<=|>=|=|=~|=)/
             op = $1
-            k,v = token.values[0].split(op)
+            k, v = token.values[0].split(op)
             puts indent + get_fact_string(k, v, op)
           else
             puts indent + get_class_string(token.values[0])
           end
-        elsif token.keys[0] == "fstatement"
+        when "fstatement"
           v = token.values[0]
-          result_string = indent + "Execute the Data Query '#{v["name"]}'"
-          if v["params"]
-            result_string += " with parameters (#{v["params"]})"
-          end
+          result_string = indent + "Execute the Data Query '#{v['name']}'"
+          result_string += " with parameters (#{v['params']})" if v["params"]
           result_string += ". "
-          result_string += "Check if the query's '#{v["value"]}' value #{v["operator"]} '#{v["r_compare"]}'  "
+          result_string += "Check if the query's '#{v['value']}' value #{v['operator']} '#{v['r_compare']}'  "
           puts result_string
-        elsif token.keys[0] == "("
-          puts indent + "("
+        when "("
+          puts "#{indent}("
           old_indent = indent
           indent *= 2
-        elsif token.keys[0] == ")"
+        when ")"
           indent = old_indent
-          puts indent + ")"
+          puts "#{indent})"
         else
           puts indent + token.keys[0].upcase
         end
@@ -46,7 +45,7 @@ module MCollective
       puts "-F filter expands to the following fact comparisons:"
       puts
       facts.each do |f|
-        puts "  " + get_fact_string(f[:fact], f[:value], f[:operator])
+        puts "  #{get_fact_string(f[:fact], f[:value], f[:operator])}"
       end
     end
 
@@ -54,30 +53,31 @@ module MCollective
       puts "-C filter expands to the following class checks:"
       puts
       classes.each do |c|
-        puts "  " + get_class_string(c)
+        puts "  #{get_class_string(c)}"
       end
     end
 
     def main
-      if !(@options[:filter]["fact"].empty?)
+      unless @options[:filter]["fact"].empty?
         describe_f_filter(@options[:filter]["fact"])
         puts
       end
 
-      if !(@options[:filter]["cf_class"].empty?)
+      unless @options[:filter]["cf_class"].empty?
         describe_c_filter(@options[:filter]["cf_class"])
         puts
       end
 
-      if !(@options[:filter]["compound"].empty?)
+      unless @options[:filter]["compound"].empty?
         describe_s_filter(@options[:filter]["compound"][0])
         puts
       end
     end
 
     private
-    def get_fact_string(fact, value, op)
-      "Check if fact '#{fact}' #{op} '#{value}'"
+
+    def get_fact_string(fact, value, oper)
+      "Check if fact '#{fact}' #{oper} '#{value}'"
     end
 
     def get_class_string(classname)

data/lib/mcollective/application/facts.rb

@@ -1,8 +1,8 @@
-class MCollective::Application::Facts<MCollective::Application
+class MCollective::Application::Facts < MCollective::Application # rubocop:disable Style/ClassAndModuleChildren
   description "Reports on usage for a specific fact"
 
   def post_option_parser(configuration)
-    configuration[:fact] = ARGV.shift if ARGV.size > 0
+    configuration[:fact] = ARGV.shift unless ARGV.empty?
   end
 
   def validate_configuration(configuration)
@@ -12,22 +12,30 @@ class MCollective::Application::Facts<MCollective::Application
   def show_single_fact_report(fact, facts, verbose=false)
     puts("Report for fact: #{fact}\n\n")
 
+    facts = stringify_facts_hash(facts)
+
     field_size = MCollective::Util.field_size(facts.keys)
     facts.keys.sort.each do |k|
       printf("        %-#{field_size}s found %d times\n", k, facts[k].size)
 
-      if verbose
-        puts
+      next unless verbose
 
-        facts[k].sort.each do |f|
-          puts("            #{f}")
-        end
+      puts
 
-        puts
+      facts[k].sort.each do |f|
+        puts("            #{f}")
       end
+
+      puts
     end
   end
 
+  def stringify_facts_hash(facts)
+    res = Hash.new([])
+    facts.each { |k, v| res[k.to_s] += v }
+    res
+  end
+
   def main
     rpcutil = rpcclient("rpcutil")
     rpcutil.progress = false
@@ -42,11 +50,11 @@ class MCollective::Application::Facts<MCollective::Application
           if facts.include?(value)
             facts[value] << resp[:senderid]
           else
-            facts[value] = [ resp[:senderid] ]
+            facts[value] = [resp[:senderid]]
           end
         end
-      rescue Exception => e
-        STDERR.puts "Could not parse facts for #{resp[:senderid]}: #{e.class}: #{e}"
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        warn "Could not parse facts for #{resp[:senderid]}: #{e.class}: #{e}"
       end
     end
 

data/lib/mcollective/application/federation.rb

@@ -0,0 +1,239 @@
+module MCollective
+  class Application
+    class Federation < Application
+      description "Choria Federation Broker Utilities"
+
+      usage <<-USAGE
+mco federation [OPTIONS] <ACTION>
+
+The ACTION can be one of the following:
+
+   trace         - trace the path to a client
+
+      USAGE
+
+      exclude_argument_sections "common", "filter", "rpc"
+
+      option :collective,
+             :description => "Target messages to a specific sub collective",
+             :arguments => ["-T", "--target COLLECTIVE"],
+             :type => String,
+             :required => false
+
+      # Publish a specially crafted 'ping' with seen-by headers
+      # embedded, this signals to the entire collective to record
+      # their route
+      def trace_node(node)
+        options[:filter] = Util.empty_filter
+
+        request = Message.new("ping", nil,
+                              :agent => "discovery",
+                              :filter => options[:filter],
+                              :collective => options[:collective],
+                              :type => :request,
+                              :headers => {"seen-by" => []},
+                              :options => options)
+
+        request.discovered_hosts = [node]
+
+        client = Client.new(options)
+        found_time = 0
+        route = []
+
+        stats = client.req(request) do |reply, message|
+          abort("Tracing requests requires MCollective 2.10.3 or newer") unless message
+
+          found_time = Time.now.to_f
+
+          abort("Received a response from %s while expecting a response from %s" % [reply[:senderid], node]) unless reply[:senderid] == node
+
+          route = message.headers["seen-by"]
+        end
+
+        raise("Did not receive any responses to trace request") if stats[:responses] == 0
+
+        {:route => route, :stats => stats, :response_time => (found_time - stats[:starttime]), :request => request.requestid}
+      end
+
+      def route_to(route, destination)
+        route.take_while {|hop| hop[1] != destination}
+      end
+
+      def route_back(route, destination)
+        route.reverse.take_while {|hop| hop.size == 2 || hop[1] != destination}.reverse
+      end
+
+      def destination_hop(route)
+        route[route_to(route, destination).size]
+      end
+
+      def extract_federation_brokers(route, destination)
+        abort("Unexpected route size %d found" % route.size) unless route.size == 5
+
+        [route_to(route, destination).last[1], route_back(route, destination).first[1]]
+      end
+
+      def draw_cluster(left, right, direction, indent)
+        if left.last == right.first && direction == :out
+          "%s└── %s" % [" " * indent, left.last]
+        elsif left.last == right.first
+          "%s┌── %s" % [" " * indent, left.last]
+        elsif direction == :out
+          [
+            "%s└─┐ %s" % [" " * indent, left.last],
+            "%s  └ %s" % [" " * indent, right.first]
+          ].join("\n")
+        else
+          [
+            "%s  ┌ %s" % [" " * indent, left.last],
+            "%s┌─┘ %s" % [" " * indent, right.first]
+          ].join("\n")
+        end
+      end
+
+      # @todo this is aweful brute force rubbish while I dont know what I want, make some algo
+      def display_unfederated_route(route)
+        c_out, node, c_in = route
+
+        if c_out[1] == node[0] && node[2] == c_out[1] && node[0] == c_out[1]
+          puts "  Shared Middleware"
+          puts
+          puts "    %s" % Util.colorize(:cyan, c_out[0])
+          puts draw_cluster(c_out, node, :out, 7)
+          puts "           └── %s" % Util.colorize(:yellow, node[1])
+
+        elsif c_out[1] == c_in[0] && node[0] == node[2]
+          puts "  NATS Cluster with Symetrical Path"
+          puts
+          puts "    %s" % Util.colorize(:cyan, c_out[0])
+          puts draw_cluster(c_out, node, :out, 7)
+          puts "           └── %s" % Util.colorize(:yellow, node[1])
+
+        else
+          puts "  NATS Cluster with Asymmetrical Path"
+          puts
+          puts "  %s" % Util.colorize(:cyan, c_out[0])
+          puts draw_cluster(c_out, node, :out, 5)
+          puts "         ├── %s" % Util.colorize(:yellow, node[1])
+          puts draw_cluster(node, c_in, :in, 5)
+          puts "  %s" % Util.colorize(:cyan, c_in[1])
+        end
+        puts
+        puts "[%s] Client [%s] Server [%s] Middleware" % [
+          Util.colorize(:cyan, "█"), Util.colorize(:yellow, "█"), "█"
+        ]
+        puts
+      end
+
+      # @todo this is aweful brute force rubbish while I dont know what I want, make some algo
+      def display_federated_route(route)
+        c_out, fb1, node, fb2, c_in = route
+
+        puts "  %s" % Util.colorize(:bold, "Request:")
+        puts "    %s" % Util.colorize(:cyan, c_out[0])
+        puts draw_cluster(c_out, fb1, :out, 7)
+        puts "            └─ %s" % Util.colorize(:green, fb1[1])
+        puts draw_cluster(fb1, node, :out, 15)
+        puts "                    └── %s" % Util.colorize(:yellow, node[1])
+        puts
+        puts "  %s" % Util.colorize(:bold, "Reply:")
+        puts "                    ┌── %s" % Util.colorize(:yellow, node[1])
+        puts draw_cluster(node, fb2, :int, 15)
+        puts "            ┌─ %s" % Util.colorize(:green, fb2[1])
+        puts draw_cluster(fb2, c_in, :in, 7)
+        puts "    %s" % Util.colorize(:cyan, c_in[1])
+        puts
+        puts "[%s] Client [%s] Federation Broker [%s] Server [%s] Middleware" % [
+          Util.colorize(:cyan, "█"), Util.colorize(:green, "█"), Util.colorize(:yellow, "█"), "█"
+        ]
+        puts
+      end
+
+      def trace_command
+        result = trace_node(configuration[:host])
+
+        abort("No routes were reported, are your nodes running a supported version?") if result[:route].empty?
+
+        puts "Received response from %s in %.2fms for message %s" % [configuration[:host], result[:response_time] * 1000, result[:request]]
+        puts
+
+        route = result[:route]
+        puts "Reported Route:"
+        puts
+        case route.size
+        when 5
+          display_federated_route(route)
+        when 3
+          display_unfederated_route(route)
+        end
+
+        puts
+
+        puts "Federation Brokers Instances:"
+        puts
+        if choria.federated?
+          extract_federation_brokers(result[:route], configuration[:host]).sort.uniq.each do |broker|
+            puts "  %s" % broker
+          end
+        else
+          puts "  Unfederated"
+        end
+        puts
+
+        puts "Known Federation Broker Clusters:"
+        puts
+        if choria.federated?
+          puts "  %s" % choria.federation_collectives.join(", ")
+        else
+          puts "  Unfederated"
+        end
+      end
+
+      # Creates and cache a Choria helper class
+      #
+      # @return [Util::Choria]
+      def choria
+        @_choria ||= Util::Choria.new
+      end
+
+      def post_option_parser(configuration)
+        if ARGV.length >= 1
+          configuration[:command] = ARGV.shift
+        else
+          abort("Please specify a command, valid commands are: %s" % valid_commands.join(", "))
+        end
+
+        if configuration[:command] == "trace"
+          if ARGV.length >= 1
+            configuration[:host] = ARGV.shift
+          else
+            abort("Please specify a host to trace, example: mco federation trace node1.prod.example.net")
+          end
+        end
+      end
+
+      def validate_configuration(configuration)
+        Util.loadclass("MCollective::Util::Choria")
+
+        abort("Unknown command %s, valid commands are: %s" % [configuration[:command], valid_commands.join(", ")]) unless valid_commands.include?(configuration[:command])
+
+        if !choria.has_client_public_cert? && !["request_cert", "show_config"].include?(configuration[:command])
+          abort("A certificate is needed from the Puppet CA for `%s`, please use the `request_cert` command" % choria.certname)
+        end
+      end
+
+      def main
+        send("%s_command" % configuration[:command])
+      rescue Interrupt
+        exit
+      end
+
+      # List of valid commands this application respond to
+      #
+      # @return [Array<String>] like `plan` and `run`
+      def valid_commands
+        methods.grep(/_command$/).map {|c| c.to_s.gsub("_command", "")}
+      end
+    end
+  end
+end