choria-mcorpc-support 2.21.1 → 2.23.1

data/lib/mcollective/data.rb

@@ -28,12 +28,16 @@ module MCollective
     end
 
     # Data.package("httpd").architecture
-    def self.method_missing(method, *args) # rubocop:disable Style/MethodMissing:
+    def self.method_missing(method, *args)
       super unless PluginManager.include?(pluginname(method))
 
       PluginManager[pluginname(method)].lookup(args.first)
     end
 
+    def self.respond_to_missing?(method, *)
+      PluginManager.include?(pluginname(method)) || super
+    end
+
     def self.ddl(plugin)
       DDL.new(pluginname(plugin), :data)
     end
@@ -55,7 +59,8 @@ module MCollective
         ddl.validate_input_argument(input, :query, argument)
       else
         raise("No data plugin argument was declared in the %s DDL but an input was supplied" % name) if argument
-        return true
+
+        true
       end
     end
 
@@ -82,7 +87,7 @@ module MCollective
         when :number, :integer, :float
           return DDL.string_to_number(input)
         end
-      rescue # rubocop:disable Lint/HandleExceptions
+      rescue # rubocop:disable Lint/SuppressedException
       end
 
       input

data/lib/mcollective/data/agent_data.rb

@@ -1,6 +1,6 @@
 module MCollective
   module Data
-    class Agent_data<Base
+    class Agent_data < Base
       query do |plugin|
         raise "No agent called #{plugin} found" unless PluginManager.include?("#{plugin}_agent")
 

data/lib/mcollective/data/base.rb

@@ -8,6 +8,7 @@ module MCollective
         type = klass.to_s.split("::").last.downcase
 
         PluginManager << {:type => type, :class => klass.to_s, :single_instance => false}
+        super
       end
 
       def initialize
@@ -22,9 +23,9 @@ module MCollective
       def lookup(what)
         ddl_validate(what)
 
-        Log.debug("Doing data query %s for '%s'" % [ @name, what ])
+        Log.debug("Doing data query %s for '%s'" % [@name, what])
 
-        Timeout::timeout(@timeout) do
+        Timeout.timeout(@timeout) do
           query_data(what)
         end
 
@@ -40,7 +41,7 @@ module MCollective
       end
 
       def self.query(&block)
-        self.module_eval { define_method("query_data", &block) }
+        module_eval { define_method("query_data", &block) }
       end
 
       def ddl_validate(what)
@@ -58,10 +59,10 @@ module MCollective
 
       # Always be active unless a specific block is given with activate_when
       def self.activate?
-        return true
+        true
       end
 
-      def startup_hook;end
+      def startup_hook; end
     end
   end
 end

data/lib/mcollective/data/bolt_task_data.ddl

@@ -0,0 +1,90 @@
+metadata    :name => "bolt_task",
+            :description => "Information about past Bolt Task",
+            :author => "R.I.Pienaar <rip@devco.net>",
+            :license => "Apache-2.0",
+            :version => "0.19.0",
+            :url => "https://choria.io",
+            :timeout => 1
+
+usage <<-EOU
+This data plugin let you extract information about a previously
+run Bolt Task for use in discovery and elsewhere.
+
+To run a task on nodes where one previously failed:
+
+   mco tasks run myapp::update -S "bolt_task('ae561842dc7d5a9dae94f766dfb3d4c8').exitcode > 0"
+EOU
+
+dataquery :description => "Puppet Bolt Task state" do
+    input :query,
+          :prompt => "Task ID",
+          :description => "The Task ID to retrieve",
+          :type => :string,
+          :validation  => '^[a-z,0-9]{32}$',
+          :maxlength   => 32
+
+    output :known,
+           :description => "If this is a known task on this node",
+           :display_as => "Known Task",
+           :default => false
+
+    output :spool,
+           :description => "Where on disk the task status is stored",
+           :display_as => "Spool",
+           :default => ""
+
+    output :task,
+           :description => "The name of the task that was run",
+           :display_as => "Task",
+           :default => ""
+
+    output :caller,
+           :description => "The user who invoked the task",
+           :display_as => "Invoked by",
+           :default => ""
+
+    output :stdout,
+           :description => "The STDOUT output from the task",
+           :display_as => "STDOUT",
+           :default => ""
+
+    output :stderr,
+           :description => "The STDERR output from the task",
+           :display_as => "STDERR",
+           :default => ""
+
+    output :exitcode,
+           :description => "The exitcode from the task",
+           :display_as => "Exit Code",
+           :default => 127
+
+    output :runtime,
+           :description => "How long the task took to run",
+           :display_as => "Runtime",
+           :default => 0.0
+
+    output :start_time,
+           :description => "When the task was started, seconds since 1970 in UTC time",
+           :display_as => "Start Time",
+           :default => 0
+
+    output :wrapper_spawned,
+           :description => "Did the wrapper start successfully",
+           :display_as => "Wrapper Spawned",
+           :default => false
+
+    output :wrapper_error,
+           :description => "Error output from the wrapper command",
+           :display_as => "Wrapper Error",
+           :default => ""
+
+    output :wrapper_pid,
+           :description => "The PID of the wrapper that runs the task",
+           :display_as => "Wrapper PID",
+           :default => -1
+
+    output :completed,
+           :description => "Did the task complete running",
+           :display_as => "Completed",
+           :default => false
+end

data/lib/mcollective/data/bolt_task_data.rb

@@ -0,0 +1,32 @@
+module MCollective
+  module Data
+    class Bolt_task_data < Base
+      activate_when do
+        Util::Choria.new.tasks_support.tasks_compatible?
+      end
+
+      query do |taskid|
+        tasks = Util::Choria.new.tasks_support
+
+        begin
+          status = tasks.task_status(taskid)
+
+          result[:known] = true
+
+          if status["task"]
+            tasks.task_status(taskid).each do |item, value|
+              value = value.utc.to_i if value.is_a?(Time)
+              value = value.to_json if value.is_a?(Hash)
+
+              result[item.intern] = value
+            end
+
+            result[:start_time] = result[:start_time].to_i
+          end
+        rescue
+          Log.debug("Task %s was not found, returning default data. Error was: %s" % [taskid, $!.to_s])
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/data/collective_data.rb

@@ -1,6 +1,6 @@
 module MCollective
   module Data
-    class Collective_data<Base
+    class Collective_data < Base
       query do |collective|
         result[:member] = Config.instance.collectives.include?(collective)
       end

data/lib/mcollective/data/fact_data.rb

@@ -1,8 +1,8 @@
 module MCollective
   module Data
-    class Fact_data<Base
+    class Fact_data < Base
       query do |path|
-        parts = path.split /\./
+        parts = path.split(/\./)
         walk_path(parts)
       end
 
@@ -14,7 +14,7 @@ module MCollective
         result[:value] = false
         result[:value_encoding] = false
 
-        facts = PluginManager['facts_plugin'].get_facts
+        facts = PluginManager["facts_plugin"].get_facts
 
         path.each do |level|
           case facts
@@ -25,7 +25,7 @@ module MCollective
               return
             end
           when Hash
-            if !facts.include?(level)
+            unless facts.include?(level)
               # we don't have the key for the next level, so give up
               return
             end
@@ -44,10 +44,10 @@ module MCollective
           # this is fixed flatten the data with json and flag that we have
           # munged the data
           result[:value] = facts.to_json
-          result[:value_encoding] = 'application/json'
+          result[:value_encoding] = "application/json"
         else
           result[:value] = facts
-          result[:value_encoding] = 'text/plain'
+          result[:value_encoding] = "text/plain"
         end
       end
     end

data/lib/mcollective/data/fstat_data.rb

@@ -1,6 +1,6 @@
 module MCollective
   module Data
-    class Fstat_data<Base
+    class Fstat_data < Base
       query do |file|
         result[:name] = file
         result[:output] = "not present"
@@ -18,8 +18,7 @@ module MCollective
         result[:uid] = 0
         result[:gid] = 0
 
-
-        if File.exists?(file)
+        if File.exist?(file)
           result[:output] = "present"
           result[:present] = 1
 
@@ -53,4 +52,3 @@ module MCollective
     end
   end
 end
-

data/lib/mcollective/data/result.rb

@@ -9,7 +9,7 @@ module MCollective
       def initialize(outputs)
         @data = {}
 
-        outputs.keys.each do |output|
+        outputs.each_key do |output|
           @data[output] = Marshal.load(Marshal.dump(outputs[output].fetch(:default, nil)))
         end
       end
@@ -24,7 +24,8 @@ module MCollective
 
       def []=(key, val)
         # checks using the string representation of the class name to avoid deprecations on Bignum and Fixnum
-        raise "Can only store String, Integer, Float or Boolean data but got #{val.class} for key #{key}" unless ["String", "Integer", "Bignum", "Fixnum", "Float", "TrueClass", "FalseClass"].include?(val.class.to_s)
+        raise "Can only store String, Integer, Float or Boolean data but got #{val.class} for key #{key}" unless ["String", "Integer", "Bignum", "Fixnum", "Float", "TrueClass",
+                                                                                                                  "FalseClass"].include?(val.class.to_s)
 
         @data[key.to_sym] = val
       end
@@ -33,6 +34,10 @@ module MCollective
         @data.keys
       end
 
+      def respond_to_missing?(method, *)
+        include?(method)
+      end
+
       def method_missing(method, *args)
         key = method.to_sym
 

data/lib/mcollective/ddl/agentddl.rb

@@ -87,14 +87,10 @@ module MCollective
       # Sets the display preference to either :ok, :failed, :flatten or :always
       # operates on action level
       def display(pref)
-        if pref == :flatten
-          Log.warn("The display option :flatten is being deprecated and will be removed in the next minor release.")
-        end
+        Log.warn("The display option :flatten is being deprecated and will be removed in the next minor release.") if pref == :flatten
 
         # defaults to old behavior, complain if its supplied and invalid
-        unless [:ok, :failed, :flatten, :always].include?(pref)
-          raise "Display preference #{pref} is not valid, should be :ok, :failed, :flatten or :always"
-        end
+        raise "Display preference #{pref} is not valid, should be :ok, :failed, :flatten or :always" unless [:ok, :failed, :flatten, :always].include?(pref)
 
         action = @current_entity
         @entities[action][:display] = pref
@@ -223,23 +219,15 @@ module MCollective
       # agent should be allowed based on action name and inputs.
       def validate_rpc_request(action, arguments)
         # is the action known?
-        unless actions.include?(action)
-          raise DDLValidationError, "Attempted to call action #{action} for #{@pluginname} but it's not declared in the DDL"
-        end
+        raise DDLValidationError, "Attempted to call action #{action} for #{@pluginname} but it's not declared in the DDL" unless actions.include?(action)
 
         input = action_interface(action)[:input] || {}
         compatible_args = symbolize_basic_input_arguments(input, arguments)
 
         input.each_key do |key|
-          unless input[key][:optional]
-            unless compatible_args.include?(key)
-              raise DDLValidationError, "Action #{action} needs a #{key} argument"
-            end
-          end
+          raise DDLValidationError, "Action #{action} needs a #{key} argument" if !input[key][:optional] && !compatible_args.include?(key)
 
-          if compatible_args.include?(key)
-            validate_input_argument(input, key, compatible_args[key])
-          end
+          validate_input_argument(input, key, compatible_args[key]) if compatible_args.include?(key)
         end
 
         true

data/lib/mcollective/ddl/base.rb

@@ -64,6 +64,7 @@ module MCollective
       def usage(usage_text)
         @usage = usage_text
       end
+      # rubocop:enable Lint/DuplicateMethods, Style/TrivialAccessors
 
       def template_for_plugintype
         case @plugintype
@@ -80,9 +81,7 @@ module MCollective
       end
 
       def loadddlfile
-        if @config.mode == :client && !client_activated?
-          raise("%s/%s is disabled, cannot load DDL file" % [@plugintype, @pluginname])
-        end
+        raise("%s/%s is disabled, cannot load DDL file" % [@plugintype, @pluginname]) if @config.mode == :client && !client_activated?
 
         if ddlfile = findddlfile
           instance_eval(File.read(ddlfile), ddlfile, 1)
@@ -111,10 +110,10 @@ module MCollective
       end
 
       def validate_requirements
-        if requirement = @requirements[:mcollective]
-          if Util.versioncmp(Util.mcollective_version, requirement) < 0
-            raise DDLValidationError, "%s plugin '%s' requires MCollective version %s or newer" % [@plugintype.to_s.capitalize, @pluginname, requirement]
-          end
+        requirement = @requirements[:mcollective]
+
+        if requirement && (Util.versioncmp(Util.mcollective_version, requirement) < 0)
+          raise DDLValidationError, "%s plugin '%s' requires MCollective version %s or newer" % [@plugintype.to_s.capitalize, @pluginname, requirement]
         end
 
         true
@@ -147,7 +146,7 @@ module MCollective
           Validator.validate(argument, input[key][:type])
         end
 
-        return true
+        true
       rescue => e
         raise DDLValidationError, "Cannot validate input %s: %s" % [key, e.to_s], e.backtrace
       end
@@ -196,8 +195,8 @@ module MCollective
         action = @current_entity
 
         @entities[action][:output][argument] = {:description => properties[:description],
-                                                :display_as  => properties[:display_as],
-                                                :default     => properties[:default]}
+                                                :display_as => properties[:display_as],
+                                                :default => properties[:default]}
 
         @entities[action][:output][argument][:type] = properties[:type] if properties[:type]
       end
@@ -208,9 +207,7 @@ module MCollective
         valid_requirements = [:mcollective]
 
         requirement.each_key do |key|
-          unless valid_requirements.include?(key)
-            raise "Requirement %s is not a valid requirement, only %s is supported" % [key, valid_requirements.join(", ")]
-          end
+          raise "Requirement %s is not a valid requirement, only %s is supported" % [key, valid_requirements.join(", ")] unless valid_requirements.include?(key)
 
           @requirements[key] = requirement[key]
         end

data/lib/mcollective/discovery.rb

@@ -29,9 +29,7 @@ module MCollective
 
       raise "Unknown discovery method %s" % method unless has_method?(method)
 
-      unless method == "mc"
-        raise "Custom discovery methods require direct addressing mode" unless Config.instance.direct_addressing
-      end
+      raise "Custom discovery methods require direct addressing mode" if method != "mc" && !Config.instance.direct_addressing
 
       method
     end
@@ -49,9 +47,7 @@ module MCollective
 
       # if the discovery method got changed we might have an old DDL cached
       # this will detect that and reread the correct DDL from disk
-      unless @ddl.meta[:name] == discovery_method
-        @ddl = DDL.new(discovery_method, :discovery)
-      end
+      @ddl = DDL.new(discovery_method, :discovery) unless @ddl.meta[:name] == discovery_method
 
       @ddl
     end
@@ -62,32 +58,22 @@ module MCollective
     def check_capabilities(filter)
       capabilities = ddl.discovery_interface[:capabilities]
 
-      unless capabilities.include?(:classes)
-        raise "Cannot use class filters while using the '%s' discovery method" % discovery_method unless filter["cf_class"].empty?
-      end
+      raise "Cannot use class filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:classes) && !filter["cf_class"].empty?
 
-      unless capabilities.include?(:facts)
-        raise "Cannot use fact filters while using the '%s' discovery method" % discovery_method unless filter["fact"].empty?
-      end
+      raise "Cannot use fact filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:facts) && !filter["fact"].empty?
 
-      unless capabilities.include?(:identity)
-        raise "Cannot use identity filters while using the '%s' discovery method" % discovery_method unless filter["identity"].empty?
-      end
+      raise "Cannot use identity filters while using the '%s' discovery method" % discovery_method if !capabilities.include?(:identity) && !filter["identity"].empty?
 
-      unless capabilities.include?(:compound)
-        raise "Cannot use compound filters while using the '%s' discovery method" % discovery_method unless filter["compound"].empty?
-      end
+      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)
-      unless discovery_method == "mc"
-        unless filter["compound"].empty?
-          Log.info "Switching to mc discovery method because compound filters are used"
-          @client.options[:discovery_method] = "mc"
+      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
+        return true
       end
 
       false
@@ -99,19 +85,18 @@ module MCollective
     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
+      # 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)
@@ -134,9 +119,9 @@ module MCollective
       discovered = discovery_class.discover(filter, discovery_timeout(timeout, filter), limit, @client)
 
       if limit > 0
-        return discovered[0, limit]
+        discovered[0, limit]
       else
-        return discovered
+        discovered
       end
     end
   end