choria-mcorpc-support 2.22.1 → 2.23.0.pre

data/lib/mcollective/agent/scout.json

@@ -0,0 +1,224 @@
+{
+  "$schema": "https://choria.io/schemas/mcorpc/ddl/v1/agent.json",
+  "metadata": {
+    "name": "scout",
+    "description": "Choria Scout Agent Management API",
+    "author": "R.I.Pienaar <rip@devco.net>",
+    "license": "Apache-2.0",
+    "version": "0.0.1",
+    "url": "https://choria.io",
+    "provider": "golang",
+    "timeout": 5
+  },
+  "actions": [
+    {
+      "action": "checks",
+      "input": {
+      },
+      "output": {
+        "checks": {
+          "description": "Details about each check",
+          "display_as": "Checks",
+          "default": null,
+          "type": "array"
+        }
+      },
+      "display": "ok",
+      "description": "Obtain a list of checks and their current status"
+    },
+    {
+      "action": "goss_validate",
+      "input": {
+        "file": {
+          "prompt": "Goss File",
+          "description": "Path to the Goss validation specification",
+          "type": "string",
+          "default": null,
+          "optional": false,
+          "validation": ".+",
+          "maxlength": 256
+        },
+        "vars": {
+          "prompt": "Vars File",
+          "description": "Path to a file to use as template variables",
+          "type": "string",
+          "default": null,
+          "optional": true,
+          "validation": ".+",
+          "maxlength": 256
+        }
+      },
+      "output": {
+        "failures": {
+          "description": "The number of tests that failed",
+          "display_as": "Failed Tests",
+          "default": null,
+          "type": "integer"
+        },
+        "results": {
+          "description": "The full test results",
+          "display_as": "Results",
+          "default": null,
+          "type": "array"
+        },
+        "runtime": {
+          "description": "The time it took to run the tests, in seconds",
+          "display_as": "Runtime",
+          "default": null,
+          "type": "integer"
+        },
+        "success": {
+          "description": "Indicates if the test passed",
+          "display_as": "Success",
+          "default": null,
+          "type": "string"
+        },
+        "summary": {
+          "description": "A human friendly test result",
+          "display_as": "Summary",
+          "default": null,
+          "type": "string"
+        },
+        "tests": {
+          "description": "The number of tests that were run",
+          "display_as": "Tests",
+          "default": null,
+          "type": "integer"
+        }
+      },
+      "display": "failed",
+      "description": "Performs a Goss validation using a specific file",
+      "aggregate": [
+        {
+          "function": "summary",
+          "args": [
+            "tests",
+            {
+              "format": "%s Test Cases on %d node(s)"
+            }
+          ]
+        },
+        {
+          "function": "summary",
+          "args": [
+            "failures",
+            {
+              "format": "%s Failed Cases on %d node(s)"
+            }
+          ]
+        },
+        {
+          "function": "summary",
+          "args": [
+            "success",
+            {
+              "format": "%s Passed Cases on %d node(s)"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "action": "maintenance",
+      "input": {
+        "checks": {
+          "prompt": "Checks",
+          "description": "Check to pause, empty means all",
+          "type": "array",
+          "default": null,
+          "optional": true
+        }
+      },
+      "output": {
+        "failed": {
+          "description": "List of checks that could not be paused",
+          "display_as": "Failed",
+          "default": null,
+          "type": "array"
+        },
+        "skipped": {
+          "description": "List of checks that was skipped",
+          "display_as": "Skipped",
+          "default": null,
+          "type": "array"
+        },
+        "transitioned": {
+          "description": "List of checks that were paused",
+          "display_as": "Triggered",
+          "default": null,
+          "type": "array"
+        }
+      },
+      "display": "failed",
+      "description": "Pause checking of one or more checks"
+    },
+    {
+      "action": "resume",
+      "input": {
+        "checks": {
+          "prompt": "Checks",
+          "description": "Check to resume, empty means all",
+          "type": "array",
+          "default": null,
+          "optional": true
+        }
+      },
+      "output": {
+        "failed": {
+          "description": "List of checks that could not be resumed",
+          "display_as": "Failed",
+          "default": null,
+          "type": "array"
+        },
+        "skipped": {
+          "description": "List of checks that was skipped",
+          "display_as": "Skipped",
+          "default": null,
+          "type": "array"
+        },
+        "transitioned": {
+          "description": "List of checks that were resumed",
+          "display_as": "Triggered",
+          "default": null,
+          "type": "array"
+        }
+      },
+      "display": "failed",
+      "description": "Resume active checking of one or more checks"
+    },
+    {
+      "action": "trigger",
+      "input": {
+        "checks": {
+          "prompt": "Checks",
+          "description": "Check to trigger, empty means all",
+          "type": "array",
+          "default": null,
+          "optional": true
+        }
+      },
+      "output": {
+        "failed": {
+          "description": "List of checks that could not be triggered",
+          "display_as": "Failed",
+          "default": null,
+          "type": "array"
+        },
+        "skipped": {
+          "description": "List of checks that was skipped",
+          "display_as": "Skipped",
+          "default": null,
+          "type": "array"
+        },
+        "transitioned": {
+          "description": "List of checks that were triggered",
+          "display_as": "Triggered",
+          "default": null,
+          "type": "array"
+        }
+      },
+      "display": "failed",
+      "description": "Force an immediate check of one or more checks"
+    }
+  ]
+}

data/lib/mcollective/agents.rb

@@ -42,6 +42,7 @@ module MCollective
     def loadagent(agentname)
       agentfile = findagentfile(agentname)
       return false unless agentfile
+
       classname = class_for_agent(agentname)
 
       PluginManager.delete("#{agentname}_agent")
@@ -62,16 +63,16 @@ module MCollective
           Util.subscribe(Util.make_subscriptions(agentname, :broadcast)) unless @@agents.include?(agentname)
 
           @@agents[agentname] = {:file => agentfile}
-          return true
+          true
         else
           Log.debug("Not activating agent #{agentname} due to agent policy in activate? method")
-          return false
+          false
         end
       rescue Exception # rubocop:disable Lint/RescueException
         Log.error("Loading agent %s failed: %s" % [agentname, $!])
         PluginManager.delete("%s_agent" % agentname)
 
-        return false
+        false
       end
     end
 
@@ -87,14 +88,14 @@ module MCollective
       klass = Kernel.const_get("MCollective").const_get("Agent").const_get(agent.capitalize)
 
       if klass.respond_to?("activate?")
-        return klass.activate?
+        klass.activate?
       else
         Log.debug("#{klass} does not have an activate? method, activating as default")
-        return true
+        true
       end
     rescue Exception # rubocop:disable Lint/RescueException
       Log.warn("Agent activation check for %s #{agent} failed: %s: %s" % [agent, $!.class, $!])
-      return false
+      false
     end
 
     # searches the libdirs for agents

data/lib/mcollective/aggregate.rb

@@ -25,7 +25,7 @@ module MCollective
           format = (arguments.delete(:format) if arguments) || nil
           begin
             @functions << load_function(agg[:function]).new(output, arguments, format, @action)
-          rescue Exception => e
+          rescue Exception => e # rubocop:disable Lint/RescueException
             Log.error("Cannot create aggregate function '%s': %s" % [output, e])
             @failed << {:name => output, :type => :startup}
           end
@@ -47,7 +47,7 @@ module MCollective
         Log.debug("Calling aggregate function %s for result" % function)
         begin
           function.process_result(reply[:data][function.output_name], reply)
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           Log.error("Could not process aggregate function for '%s': %s" % [function.output_name, e])
           @failed << {:name => function.output_name, :type => :process_result}
           @functions.delete(function)
@@ -60,7 +60,7 @@ module MCollective
       summary = @functions.map do |function|
         begin
           function.summarize
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           Log.error("Could not summarize aggregate result for '%s': %s" % [function.output_name, e])
           @failed << {:name => function.output_name, :type => :summarize}
           nil
@@ -78,7 +78,7 @@ module MCollective
 
       PluginManager.loadclass("MCollective::Aggregate::%s" % function_name) unless Aggregate.const_defined?(function_name)
       Aggregate.const_get(function_name)
-    rescue Exception
+    rescue Exception # rubocop:disable Lint/RescueException
       raise("Aggregate function file '%s.rb' cannot be loaded" % function_name.downcase)
     end
   end

data/lib/mcollective/aggregate/average.rb

@@ -1,6 +1,6 @@
 module MCollective
   class Aggregate
-    class Average<Base
+    class Average < Base
       # Before function is run processing
       def startup_hook
         @result[:value] = 0
@@ -9,7 +9,7 @@ module MCollective
         @count = 0
 
         # Set default aggregate_function if it is undefined
-        @aggregate_format = "Average of #{@result[:output]}: %f" unless @aggregate_format
+        @aggregate_format ||= "Average of #{@result[:output]}: %f"
       end
 
       # Determines the average of a set of numerical values

data/lib/mcollective/aggregate/base.rb

@@ -17,9 +17,9 @@ module MCollective
         startup_hook
       end
 
-      ['startup_hook', 'process_result'].each do |method|
+      ["startup_hook", "process_result"].each do |method|
         define_method method do
-          raise RuntimeError, "'#{method}' method of function class #{@name} has not yet been implemented"
+          raise "'#{method}' method of function class #{@name} has not yet been implemented"
         end
       end
 

data/lib/mcollective/aggregate/result.rb

@@ -1,9 +1,9 @@
 module MCollective
   class Aggregate
     module Result
-      require 'mcollective/aggregate/result/base'
-      require 'mcollective/aggregate/result/numeric_result'
-      require 'mcollective/aggregate/result/collection_result'
+      require "mcollective/aggregate/result/base"
+      require "mcollective/aggregate/result/numeric_result"
+      require "mcollective/aggregate/result/collection_result"
     end
   end
 end

data/lib/mcollective/aggregate/result/collection_result.rb

@@ -1,13 +1,13 @@
 module MCollective
   class Aggregate
     module Result
-      class CollectionResult<Base
+      class CollectionResult < Base
         def to_s
           return "" if @result[:value].keys.include?(nil)
 
           result = StringIO.new
 
-          @result[:value].sort{|x,y| x[1] <=> y[1]}.reverse.each do |value|
+          @result[:value].sort {|x, y| x[1] <=> y[1]}.reverse.each do |value|
             result.puts @aggregate_format % [value[0], value[1]]
           end
 

data/lib/mcollective/aggregate/result/numeric_result.rb

@@ -1,11 +1,11 @@
 module MCollective
   class Aggregate
     module Result
-      class NumericResult<Base
+      class NumericResult < Base
         def to_s
           return "" if @result[:value].nil?
 
-          return @aggregate_format % @result[:value]
+          @aggregate_format % @result[:value]
         end
       end
     end

data/lib/mcollective/aggregate/sum.rb

@@ -1,12 +1,12 @@
 module MCollective
   class Aggregate
-    class Sum<Base
+    class Sum < Base
       def startup_hook
         @result[:value] = 0
         @result[:type] = :numeric
 
         # Set default aggregate_function if it is undefined
-        @aggregate_format = "Sum of #{@result[:output]}: %f" unless @aggregate_format
+        @aggregate_format ||= "Sum of #{@result[:output]}: %f"
       end
 
       # Determines the average of a set of numerical values

data/lib/mcollective/aggregate/summary.rb

@@ -1,13 +1,13 @@
 module MCollective
   class Aggregate
-    class Summary<Base
+    class Summary < Base
       # Before function is run processing
       def startup_hook
         @result[:value] = {}
         @result[:type] = :collection
 
         # set default aggregate_format if it is undefined
-        @aggregate_format = :calculate unless @aggregate_format
+        @aggregate_format ||= :calculate
       end
 
       # Increments the value field if value has been seen before
@@ -15,7 +15,7 @@ module MCollective
       def process_result(value, reply)
         unless value.nil?
           if value.is_a? Array
-            value.map{|val| add_value(val)}
+            value.map {|val| add_value(val)}
           else
             add_value(value)
           end
@@ -33,7 +33,6 @@ module MCollective
       def summarize
         if @aggregate_format == :calculate
           max_key_length = @result[:value].keys.map do |k|
-
             # Response values retain their types. Here we check
             # if the response is a string and turn it into a string
             # if it isn't one.

data/lib/mcollective/application.rb

@@ -31,6 +31,24 @@ module MCollective
         self[:description] = descr
       end
 
+      # Executes an external program instead of implement the logic in ruby
+      #
+      # @param [Hash] command the command to run
+      # @option command [String] :command the command to run
+      # @option command [Array] :args arguments to pass to the command
+      def external(command)
+        self[:external] = command
+      end
+
+      # Executes an external program to show help instead of supplying options
+      #
+      # @param [Hash] command the command to run
+      # @option command [String] :command the command to run
+      # @option command [Array] :args arguments to pass to the command
+      def external_help(command)
+        self[:external_help] = command
+      end
+
       # Supplies usage information, calling multiple times will
       # create multiple usage lines in --help output
       def usage(usage)
@@ -79,10 +97,12 @@ module MCollective
 
       # Creates an empty set of options
       def intialize_application_options
-        @application_options = {:description          => nil,
-                                :usage                => [],
-                                :cli_arguments        => [],
-                                :exclude_arg_sections => []}
+        @application_options = {:description => nil,
+                                :usage => [],
+                                :cli_arguments => [],
+                                :exclude_arg_sections => [],
+                                :external => nil,
+                                :external_help => nil}
       end
     end
 
@@ -101,7 +121,7 @@ module MCollective
       validation_result = blk.call(value)
 
       unless validation_result == true
-        STDERR.puts "Validation of #{name} failed: #{validation_result}"
+        warn "Validation of #{name} failed: #{validation_result}"
         exit 1
       end
     end
@@ -123,7 +143,7 @@ module MCollective
 
       post_option_parser(configuration) if respond_to?(:post_option_parser)
 
-      return options
+      options
     rescue Exception # rubocop:disable Lint/RescueException
       application_failure($!)
     end
@@ -205,14 +225,15 @@ module MCollective
       application_cli_arguments.each do |carg|
         # Check for required arguments
         next unless carg[:required]
+
         unless configuration[carg[:name]]
           validation_passed = false
-          STDERR.puts "The #{carg[:name]} option is mandatory"
+          warn "The #{carg[:name]} option is mandatory"
         end
       end
 
       unless validation_passed
-        STDERR.puts "\nPlease run with --help for detailed help"
+        warn "\nPlease run with --help for detailed help"
         exit 1
       end
     end
@@ -242,23 +263,23 @@ module MCollective
 
     # Handles failure, if we're far enough in the initialization
     # phase it will log backtraces if its in verbose mode only
-    def application_failure(e, err_dest=STDERR)
+    def application_failure(err, err_dest=$stderr)
       # peole can use exit() anywhere and not get nasty backtraces as a result
-      if e.is_a?(SystemExit)
+      if err.is_a?(SystemExit)
         disconnect
-        raise(e)
+        raise(err)
       end
 
       if options[:verbose]
-        err_dest.puts "\nThe %s application failed to run: %s\n" % [Util.colorize(:bold, $0), Util.colorize(:red, e.to_s)]
+        err_dest.puts "\nThe %s application failed to run: %s\n" % [Util.colorize(:bold, $0), Util.colorize(:red, err.to_s)]
       else
-        err_dest.puts "\nThe %s application failed to run, use -v for full error backtrace details: %s\n" % [Util.colorize(:bold, $0), Util.colorize(:red, e.to_s)]
+        err_dest.puts "\nThe %s application failed to run, use -v for full error backtrace details: %s\n" % [Util.colorize(:bold, $0), Util.colorize(:red, err.to_s)]
       end
 
       if options.nil? || options[:verbose]
-        e.backtrace.first << Util.colorize(:red, "  <----")
-        err_dest.puts "\n%s %s" % [Util.colorize(:red, e.to_s), Util.colorize(:bold, "(#{e.class})")]
-        e.backtrace.each {|l| err_dest.puts "\tfrom #{l}"}
+        err.backtrace.first << Util.colorize(:red, "  <----")
+        err_dest.puts "\n%s %s" % [Util.colorize(:red, err.to_s), Util.colorize(:bold, "(#{err.class})")]
+        err.backtrace.each {|l| err_dest.puts "\tfrom #{l}"}
       end
 
       disconnect
@@ -266,7 +287,14 @@ module MCollective
       exit 1
     end
 
+    def external_help
+      ext = application_options[:external_help]
+      exec(ext[:command], ext[:args])
+    end
+
     def help
+      return external_help if application_options[:external_help]
+
       application_parse_options(true)
     end
 
@@ -274,6 +302,8 @@ module MCollective
     # the main as supplied by the user.  Disconnects when done and pass any exception
     # onto the application_failure helper
     def run
+      return external_main if application_options[:external]
+
       application_parse_options
 
       validate_configuration(configuration) if respond_to?(:validate_configuration)
@@ -289,13 +319,21 @@ module MCollective
 
     def disconnect
       MCollective::PluginManager["connector_plugin"].disconnect
-    rescue # rubocop:disable Lint/HandleExceptions
+    rescue # rubocop:disable Lint/SuppressedException
+    end
+
+    def external_main
+      ext = application_options[:external]
+      args = ext[:args] || []
+      args.concat(ARGV)
+
+      exec(ext[:command], *args)
     end
 
     # Fake abstract class that logs if the user tries to use an application without
     # supplying a main override method.
     def main
-      STDERR.puts "Applications need to supply a 'main' method"
+      warn "Applications need to supply a 'main' method"
       exit 1
     end
 
@@ -305,9 +343,7 @@ module MCollective
                        :okcount => 0,
                        :failcount => 0}.merge(stats.to_hash)
 
-      if request_stats[:discoverytime] == 0 && request_stats[:responses] == 0
-        return 4
-      end
+      return 4 if request_stats[:discoverytime] == 0 && request_stats[:responses] == 0
 
       if request_stats[:discovered] > 0
         if request_stats[:responses] == 0