choria-mcorpc-support 2.22.1 → 2.23.0.pre

data/lib/mcollective/util/tasks_support/cli.rb

@@ -0,0 +1,260 @@
+module MCollective
+  module Util
+    class TasksSupport
+      class CLI
+        attr_reader :output
+
+        def initialize(support, format, verbose)
+          @support = support
+
+          if format == :json
+            require_relative "json_formatter"
+            @output = CLI::JSONFormatter.new(self, verbose)
+          else
+            require_relative "default_formatter"
+            @output = CLI::DefaultFormatter.new(self, verbose)
+          end
+        end
+
+        # Shows the task list
+        #
+        # @param environment [String] the environment to query
+        # @param detail [Boolean] show task descriptions
+        # @param out [IO]
+        def show_task_list(environment, detail, out=$stdout)
+          out.puts "Known tasks in the %s environment" % environment
+          out.puts
+
+          known_tasks = task_list(environment, detail, out)
+
+          out.print("\r")
+
+          padding = known_tasks.keys.map(&:size).max + 2
+
+          if detail
+            known_tasks.each do |name, description|
+              out.puts "  %-#{padding}s %s" % [name, description]
+            end
+
+            out.puts
+            out.puts("Use mco task <TASK> to see task help")
+          else
+            known_tasks.keys.in_groups_of(3) do |tasks|
+              out.puts "  %s" % tasks.compact.map {|t| "%-#{padding}s" % t }.join(" ")
+            end
+
+            out.puts
+            out.puts("Use mco task <TASK> to see task help")
+            out.puts("Pass option --detail to see task descriptions")
+          end
+        end
+
+        # Retrieves the task list
+        #
+        # @param environment [String] the environment to query
+        # @param detail [Boolean] show task descriptions
+        def task_list(environment, detail, out=$stdout)
+          tasks = {}
+
+          out.print("Retrieving tasks....")
+
+          known_tasks = @support.tasks(environment)
+
+          known_tasks.each_with_index do |task, idx|
+            description = nil
+            if detail
+              out.print(twirl("Retrieving tasks....", known_tasks.size, idx))
+              meta = task_metadata(task["name"], environment)
+              description = meta["metadata"]["description"]
+            end
+
+            tasks[task["name"]] = description || ""
+          end
+
+          tasks
+        end
+
+        # Creates help for a task
+        #
+        # @param task [String] task name
+        # @param environment [String] environment to feetch task from
+        # @param out [IO]
+        def show_task_help(task, environment, out=$stdout)
+          out.puts("Retrieving task metadata for task %s from the Puppet Server" % task)
+
+          begin
+            meta = task_metadata(task, environment)
+          rescue
+            abort($!.to_s)
+          end
+
+          out.puts
+
+          out.puts("%s - %s" % [Util.colorize(:bold, task), meta["metadata"]["description"]])
+          out.puts
+
+          if meta["metadata"]["parameters"].nil? || meta["metadata"]["parameters"].empty?
+            out.puts("The task takes no parameters or have none defined")
+            out.puts
+          else
+            out.puts("Task Parameters:")
+
+            meta["metadata"]["parameters"].sort_by {|n, _| n}.each do |name, details|
+              out.puts("  %-30s %s (%s)" % [name, details["description"], details["type"]])
+            end
+          end
+
+          out.puts
+          out.puts "Task Files:"
+          meta["files"].each do |file|
+            out.puts("  %-30s %s bytes" % [file["filename"], file["size_bytes"]])
+          end
+
+          out.puts
+          out.puts("Use 'mco tasks run %s' to run this task" % [task])
+        end
+
+        # (see DefaultFormatter.print_task_summary)
+        def print_task_summary(*args)
+          @output.print_task_summary(*args)
+        end
+
+        # (see DefaultFormatter.print_result)
+        def print_result(*args)
+          @output.print_result(*args)
+        end
+
+        # (see DefaultFormatter.print_rpc_stats)
+        def print_rpc_stats(*args)
+          @output.print_rpc_stats(*args)
+        end
+
+        # (see DefaultFormatter.print_result_metadata)
+        def print_result_metadata(*args)
+          @output.print_result_metadata(*args)
+        end
+
+        # Parses the given CLI input string and creates results based on it
+        #
+        # @param configuration [Hash] the mcollective Application configuration
+        # @return [Hash]
+        def task_input(configuration)
+          result = {}
+
+          input = configuration[:__json_input]
+
+          if input
+            if input.start_with?("@")
+              input.sub!("@", "")
+              result = JSON.parse(File.read(input)) if input.end_with?("json")
+              result = YAML.safe_load(File.read(input)) if input.end_with?("yaml")
+            else
+              result = JSON.parse(input)
+            end
+          end
+
+          configuration.each do |item, value|
+            next if item.to_s.start_with?("__")
+
+            result[item.to_s] = value
+          end
+
+          result
+        end
+
+        # Validates the inputs provided on the CLI would be acceptable to the task
+        #
+        # @param task [String] task name
+        # @param meta [Hash] task metadata
+        # @param input [Hash] proposed input to pass to the task
+        # @return [Boolean]
+        # @raize [Exit] on failure
+        def validate_task_input(task, meta, input)
+          ok, reason = @support.validate_task_inputs(input, meta)
+
+          return true if ok
+
+          abort(reason)
+        end
+
+        # Adds CLI options for all defined input
+        #
+        # @param meta [Hash] the task metadata
+        # @param application [Application]
+        def create_task_options(task, environment, application)
+          meta = task_metadata(task, environment)
+
+          return if meta["metadata"]["parameters"].nil? || meta["metadata"]["parameters"].empty?
+
+          meta["metadata"]["parameters"].sort_by {|n, _| n}.each do |name, details|
+            type, array, _ = @support.puppet_type_to_ruby(details["type"])
+
+            properties = {
+              :description => "%s (%s)" % [details["description"], details["type"]],
+              :arguments => ["--%s %s" % [name.downcase, name.upcase]],
+              :type => type
+            }
+
+            properties[:type] = :array if array
+
+            if type == Hash
+              properties[:arguments] = ["--%s JSON" % name.downcase]
+              properties[:type] = String
+            end
+
+            properties[:arguments] = ["--[no-]%s" % name.downcase] if type == :boolean
+
+            application.class.option(name.intern, properties)
+          end
+        end
+
+        # Transform hash inputs given as json strings to hashes
+        #
+        # @param meta [Hash] task metadata
+        # @param input [Hash] proposed input to pass to the task
+        def transform_hash_strings(meta, input)
+          return unless meta["metadata"]["parameters"]
+
+          meta["metadata"]["parameters"].each do |name, details|
+            type, _, _ = @support.puppet_type_to_ruby(details["type"])
+
+            next unless type == Hash && input[name].is_a?(String)
+
+            begin
+              input[name] = JSON.parse(input[name])
+            rescue
+              raise("Could not parse input '%s' as JSON data: %s: %s" % [name, $!.class, $!.message])
+            end
+          end
+        end
+
+        # Retrieves task metadata from Puppet Server and cache it
+        #
+        # @param task [String] the task to fetch
+        # @param environment [String] Puppet environment
+        def task_metadata(task, environment)
+          @_metadata ||= {}
+
+          return @_metadata[task] if @_metadata[task]
+
+          @_metadata[task] = @support.task_metadata(task, environment)
+        end
+
+        # Draw a compact CLI progress indicator
+        #
+        # @param msg [String] the message to prefix
+        # @param max [Integer] the biggest number to expect
+        # @param current [Integer] the current number
+        def twirl(msg, max, current)
+          charset = ["▖", "▘", "▝", "▗"]
+          index = current % charset.size
+          char = charset[index]
+          char = Util.colorize(:green, "✓") if max == current
+
+          format = "\r%s %s  %#{@max.to_s.size}d / %d"
+          format % [msg, char, current, max]
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/util/tasks_support/default_formatter.rb

@@ -0,0 +1,138 @@
+module MCollective
+  module Util
+    class TasksSupport
+      class CLI
+        class DefaultFormatter
+          attr_reader :out
+
+          def initialize(cli, verbose=false, out=$stdout)
+            @cli = cli
+            @verbose = verbose
+            @out = out
+          end
+
+          # Prints the summary of a task over a number of machines
+          #
+          # @param taskid [String] the task id
+          # @param names [Array<String>] list of unique task names seen in the estate
+          # @param callers [Array<String>] list of unique callers seen in the estate
+          # @param completed [Integer] nodes that completed the task - success or fails
+          # @param running [Integer] nodes still running the task
+          # @param task_not_known [Integer] nodes where the task is unknown
+          # @param wrapper_failure [Integer] nodes where the wrapper executable failed to launch
+          # @param success [Integer] nodes that completed the task succesfully
+          # @param fails [Integer] nodes that did not complete the task succesfully
+          # @param runtime [Float] total run time across all nodes
+          # @param rpcstats [RPC::Stats] the stats from the RPC client that fetched the statusses
+          def print_task_summary(taskid, names, callers, completed, running, task_not_known, wrapper_failure, success, fails, runtime, rpcstats)
+            if callers.size > 1 || names.size > 1
+              out.puts
+              out.puts("%s received more than 1 task name or caller name for this task, this should not happen" % Util.colorize(:red, "WARNING"))
+              out.puts("happen in normal operations and might indicate forged requests were made or cache corruption.")
+              out.puts
+            end
+
+            out.puts("Summary for task %s" % [Util.colorize(:bold, taskid)])
+            out.puts
+            out.puts("                       Task Name: %s" % names.join(","))
+            out.puts("                          Caller: %s" % callers.join(","))
+            out.puts("                       Completed: %s" % (completed > 0 ? Util.colorize(:green, completed) : Util.colorize(:yellow, completed)))
+            out.puts("                         Running: %s" % (running > 0 ? Util.colorize(:yellow, running) : Util.colorize(:green, running)))
+            out.puts("                    Unknown Task: %s" % Util.colorize(:red, task_not_known)) if task_not_known > 0
+            out.puts("                 Wrapper Failure: %s" % Util.colorize(:red, wrapper_failure)) if wrapper_failure > 0
+            out.puts
+            out.puts("                      Successful: %s" % (success > 0 ? Util.colorize(:green, success) : Util.colorize(:red, success)))
+            out.puts("                          Failed: %s" % (fails > 0 ? Util.colorize(:red, fails) : fails))
+            out.puts
+            out.puts("                Average Run Time: %.2fs" % [runtime / (running + completed)])
+
+            if rpcstats.noresponsefrom.empty?
+              out.puts
+              out.puts rpcstats.no_response_report
+            end
+
+            if running > 0
+              out.puts
+              out.puts("%s nodes are still running, use 'mco tasks status %s' to check on them later" % [Util.colorize(:bold, running), taskid])
+            end
+          end
+
+          # Prints the RPC stats for a request
+          #
+          # @param stats [RPC::Stats] request stats
+          def print_rpc_stats(stats)
+            out.puts stats.report("Task Stats", false, @verbose)
+          end
+
+          # Prints an individual result
+          #
+          # @param result [RPC::Result]
+          def print_result(result)
+            status = result[:data]
+            stdout_text = status[:stdout] || ""
+
+            unless @verbose
+              begin
+                stdout_text = JSON.parse(status[:stdout])
+                stdout_text.delete("_error")
+                stdout_text = stdout_text.to_json
+                stdout_text = nil if stdout_text == "{}"
+              rescue # rubocop:disable Lint/SuppressedException
+              end
+            end
+
+            if result[:statuscode] != 0
+              out.puts("%-40s %s" % [
+                Util.colorize(:red, result[:sender]),
+                Util.colorize(:yellow, result[:statusmsg])
+              ])
+
+              out.puts("   %s" % stdout_text) if stdout_text
+              out.puts("   %s" % status[:stderr]) unless ["", nil].include?(status[:stderr])
+              out.puts
+            elsif result[:statuscode] == 0 && @verbose
+              out.puts(result[:sender])
+              out.puts("   %s" % stdout_text) if stdout_text
+              out.puts("   %s" % status[:stderr]) unless ["", nil].include?(status[:stderr])
+              out.puts
+            end
+          end
+
+          # Prints metadata for an individual result
+          #
+          # @param status [RPC::Reply] the individual task status to print
+          def print_result_metadata(status)
+            result = status.results
+
+            if [0, 1].include?(result[:statuscode])
+              if result[:data][:exitcode] == 0
+                out.puts("  %-40s %s" % [result[:sender], Util.colorize(:green, result[:data][:exitcode])])
+              else
+                out.puts("  %-40s %s" % [result[:sender], Util.colorize(:red, result[:data][:exitcode])])
+              end
+
+              out.puts("    %s by %s at %s" % [
+                Util.colorize(:bold, result[:data][:task]),
+                result[:data][:callerid],
+                Time.at(result[:data][:start_time]).utc.strftime("%F %T")
+              ])
+
+              out.puts("    completed: %s runtime: %s stdout: %s stderr: %s" % [
+                result[:data][:completed] ? Util.colorize(:bold, "yes") : Util.colorize(:yellow, "no"),
+                Util.colorize(:bold, "%.2f" % result[:data][:runtime]),
+                result[:data][:stdout].empty? ? Util.colorize(:yellow, "no") : Util.colorize(:bold, "yes"),
+                result[:data][:stderr].empty? ? Util.colorize(:bold, "no") : Util.colorize(:red, "yes")
+              ])
+            elsif result[:statuscode] == 3
+              out.puts("  %-40s %s" % [result[:sender], Util.colorize(:yellow, "Unknown Task")])
+            else
+              out.puts("  %-40s %s" % [result[:sender], Util.colorize(:yellow, result[:statusmsg])])
+            end
+
+            out.puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/util/tasks_support/json_formatter.rb

@@ -0,0 +1,108 @@
+module MCollective
+  module Util
+    class TasksSupport
+      class CLI
+        class JSONFormatter
+          attr_reader :out
+
+          def initialize(cli, verbose=false, out=$stdout)
+            @cli = cli
+            @verbose = verbose
+            @out = out
+
+            @started = false
+            @in_results = false
+            @in_stats = false
+            @first_item = true
+          end
+
+          def start
+            return if @started
+
+            @started = true
+            @in_results = true
+
+            out.puts '{"items": ['
+          end
+
+          def end_results
+            return unless @in_results
+
+            @in_results = false
+            out.puts "],"
+          end
+
+          # (see DefaultFormatter.print_task_summary)
+          def print_task_summary(taskid, names, callers, completed, running, task_not_known, wrapper_failure, success, fails, runtime, rpcstats)
+            end_results
+
+            stats = {
+              "names" => names,
+              "callers" => callers,
+              "completed" => completed,
+              "running" => running,
+              "task_not_known" => task_not_known,
+              "wrapper_failure" => wrapper_failure,
+              "success" => success,
+              "failed" => fails,
+              "average_runtime" => runtime / (running + completed),
+              "noresponses" => rpcstats.noresponsefrom
+            }
+
+            summary = {
+              "nodes" => rpcstats.discovered_nodes.size,
+              "taskid" => taskid,
+              "completed" => stats["completed"] == rpcstats.discovered_nodes.size,
+              "success" => success == rpcstats.discovered_nodes.size
+            }
+
+            out.puts '"stats":'
+            out.puts stats.to_json
+            out.puts ","
+            out.puts '"summary":'
+
+            out.puts summary.to_json
+            out.puts "}"
+          end
+
+          # (see DefaultFormatter.print_rpc_stats)
+          def print_rpc_stats(stats)
+            end_results
+          end
+
+          # (see DefaultFormatter.print_result)
+          def print_result(result)
+            start
+
+            result = result.results
+
+            item = {
+              "host" => result[:sender]
+            }
+
+            result[:data].each do |k, v|
+              item[k.to_s] = v
+            end
+
+            begin
+              item["stdout"] = JSON.parse(item["stdout"])
+              item["stdout"] = item["stdout"].delete("_output") if item["stdout"]["_output"]
+            rescue # rubocop:disable Lint/SuppressedException
+            end
+
+            out.puts "," unless @first_item
+
+            out.puts item.to_json
+
+            @first_item = false
+          end
+
+          # (see DefaultFormatter.print_result_metadata)
+          def print_result_metadata(status)
+            print_result(status)
+          end
+        end
+      end
+    end
+  end
+end