choria-mcorpc-support 2.21.1 → 2.23.1

data/lib/mcollective/util/bolt_support.rb

@@ -0,0 +1,176 @@
+require "mcollective"
+require_relative "choria"
+require_relative "playbook"
+
+require_relative "bolt_support/task_result"
+require_relative "bolt_support/task_results"
+require_relative "bolt_support/plan_runner"
+
+module MCollective
+  module Util
+    class BoltSupport
+      def choria
+        @_choria ||= Choria.new
+      end
+
+      # Converts the current Puppet loglevel to one we understand
+      #
+      # @return ["debug", "info", "warn", "error", "fatal"]
+      def self.loglevel
+        case Puppet::Util::Log.level
+        when :notice, :warning
+          "warn"
+        when :err
+          "error"
+        when :alert, :emerg, :crit
+          "fatal"
+        else
+          Puppet::Util::Log.level.to_s
+        end
+      end
+
+      # Configures MCollective and initialize the Bolt Support class
+      #
+      # @return [BoltSupport]
+      def self.init_choria
+        Config.instance.loadconfig(Util.config_file_for_user) unless Config.instance.configured
+
+        new
+      end
+
+      # Creates a configured instance of the Playbook
+      #
+      # @return [Playbook]
+      def playbook
+        @_playbook ||= begin
+          pb = Playbook.new(self.class.loglevel)
+          pb.logger = Playbook::Puppet_Logger
+          pb.set_logger_level
+          pb
+        end
+      end
+
+      def nodes
+        @_nodes ||= Playbook::Nodes.new(playbook)
+      end
+
+      # Discovers nodes using playbook node sets
+      #
+      # @param scope [Puppet::Parser::Scope] scope to log against
+      # @param type [String] a known node set type like `terraform`
+      # @param properties [Hash] properties valid for the node set type
+      def discover_nodes(scope, type, properties)
+        uses_properties = properties.delete("uses") || {}
+        playbook.logger.scope = scope
+        assign_playbook_name(scope)
+        playbook.uses.from_hash(uses_properties)
+
+        nodes.from_hash("task_nodes" => properties.merge(
+          "type" => type,
+          "uses" => uses_properties.keys
+        ))
+
+        nodes.prepare
+        nodes["task_nodes"]
+      end
+
+      # Retrieves a data item from a data store
+      #
+      # @param scope [Puppet::Parser::Scope] scope to log against
+      # @param item [String] the item to fetch
+      # @param properties [Hash] the data source properties
+      def data_read(scope, item, properties)
+        playbook.logger.scope = scope
+        assign_playbook_name(scope)
+        playbook.data_stores.from_hash("plan_store" => properties)
+        playbook.data_stores.prepare
+        playbook.data_stores.read("plan_store/%s" % item)
+      end
+
+      # Writes a value to a data store
+      #
+      # @param scope [Puppet::Parser::Scope] scope to log against
+      # @param item [String] the item to fetch
+      # @param value [String] the item to fetch
+      # @param properties [Hash] the data source properties
+      # @return [String] the data that was written
+      def data_write(scope, item, value, properties)
+        config = {"plan_store" => properties}
+
+        playbook.logger.scope = scope
+        assign_playbook_name(scope)
+        playbook.data_stores.from_hash(config)
+        playbook.data_stores.prepare
+        playbook.data_stores.write("plan_store/%s" % item, value)
+      end
+
+      # Performs a block within a lock in a data store
+      #
+      # @param scope [Puppet::Parser::Scope] scope to log against
+      # @param item [String] the lock key
+      # @param properties [Hash] the data source properties
+      def data_lock(scope, item, properties, &blk)
+        locked = false
+        lock_path = "plan_store/%s" % item
+        config = {"plan_store" => properties}
+
+        playbook.logger.scope = scope
+        assign_playbook_name(scope)
+        playbook.data_stores.from_hash(config)
+        playbook.data_stores.prepare
+
+        playbook.data_stores.lock(lock_path)
+        locked = true
+
+        yield
+      ensure
+        playbook.data_stores.release(lock_path) if locked
+      end
+
+      # Runs a playbook task and return execution results
+      #
+      # @param scope [Puppet::Parser::Scope] scope to log against
+      # @param type [String] the task type
+      # @param properties [Hash] properties passed to the task
+      # @return [BoltSupport::TaskResults]
+      def run_task(scope, type, properties)
+        task_properties = properties.reject {|k, _| k.start_with?("_") }
+        playbook.logger.scope = scope
+        assign_playbook_name(scope)
+
+        tasks = playbook.tasks.load_tasks([type => task_properties], "tasks")
+
+        playbook.tasks.run_task(tasks[0], "plan", false)
+
+        result = tasks[0][:result]
+        runner = tasks[0][:runner]
+
+        execution_result = runner.to_execution_result([result.success, result.msg, result.data])
+
+        results = execution_result.map do |node, result_properties|
+          TaskResult.new(node, JSON.parse(result_properties.to_json))
+        end
+
+        task_results = TaskResults.new(results, nil)
+        task_results.message = result.msg
+
+        return task_results if result.success
+        return task_results if properties.fetch("fail_ok", false)
+        return task_results if properties["_catch_errors"]
+
+        raise(result.msg)
+      end
+
+      # Assigns the playbook name based on the fact choria.plan
+      #
+      # @see PlanRunner#in_environment
+      def assign_playbook_name(scope)
+        return unless scope
+        return unless scope["facts"]["choria"]
+        return unless scope["facts"]["choria"]["playbook"]
+
+        playbook.metadata["name"] = scope["facts"]["choria"]["playbook"]
+      end
+    end
+  end
+end

data/lib/mcollective/util/bolt_support/plan_runner.rb

@@ -0,0 +1,167 @@
+require "puppet"
+require "puppet_pal"
+require "tmpdir"
+
+module MCollective
+  module Util
+    class BoltSupport
+      class PlanRunner
+        def self.init_puppet
+          TaskResults.include_iterable
+          Puppet::Util::Log.newdestination(:console)
+        end
+
+        init_puppet
+
+        attr_reader :modulepath
+
+        # @param plan [String] the name of the plan to use
+        # @param tmpdir [String] the path to an already existing temporary directory
+        # @param modulepath [String,nil] a : seperated list of locations to look for modules, uses puppet basemodulepath if nil
+        # @param loglevel [debug, info, warn, err]
+        def initialize(plan, tmpdir, modulepath, loglevel)
+          @plan = plan
+          @loglevel = loglevel
+          @tmpdir = tmpdir
+
+          raise("A temporary directory could not be created") unless @tmpdir
+          raise("A temporary directory could not be created") unless File.directory?(@tmpdir)
+
+          @modulepath = modulepath
+
+          unless @modulepath
+            initialize_settings
+            @modulepath = Puppet.settings[:basemodulepath]
+          end
+
+          @modulepath = @modulepath.split(":")
+
+          Puppet[:log_level] = @loglevel
+        end
+
+        # Determines if the requested plan exist
+        #
+        # @return [Boolean]
+        def exist?
+          with_script_compiler do |compiler|
+            return !!compiler.plan_signature(@plan)
+          end
+        end
+
+        # Initialize Puppet to use the configured tmp dir
+        def puppet_cli_options
+          Puppet::Settings::REQUIRED_APP_SETTINGS.map do |setting|
+            "--%s %s" % [setting, @tmpdir]
+          end
+        end
+
+        # Retrieves the signature of a plan - its parameters and types
+        #
+        # NOTE: at present it's not possible to extract description or default values
+        #
+        # @return [Hash]
+        def plan_signature
+          with_script_compiler do |compiler|
+            sig = compiler.plan_signature(@plan)
+
+            raise("Cannot find playbook %s in %s" % [@plan, @modulepath.join(":")]) unless sig
+
+            sig.params_type.elements.map do |elem|
+              [elem.name, {
+                "type" => elem.value_type.to_s,
+                "required" => !elem.key_type.is_a?(Puppet::Pops::Types::POptionalType)
+              }]
+            end
+          end
+        end
+
+        # Yields a PAL script compiler in the temporary environment
+        def with_script_compiler(&block)
+          in_environment do |env|
+            env.with_script_compiler(&block)
+          end
+        end
+
+        # Facts to use in the environment
+        def facts
+          {
+            "choria" => {
+              "playbook" => @plan
+            }
+          }
+        end
+
+        def initialize_settings
+          Puppet.initialize_settings(puppet_cli_options) unless Puppet.settings.global_defaults_initialized?
+        end
+
+        # Sets up a temporary environment
+        def in_environment(&block)
+          initialize_settings
+
+          Puppet::Pal.in_tmp_environment("choria", :modulepath => @modulepath, :facts => facts, &block)
+        end
+
+        # Converts a Puppet type into something mcollective understands
+        #
+        # This is inevitably hacky by its nature, there is no way for me to
+        # parse the types.  PAL might get some helpers for this but till then
+        # this is going to have to be best efforts.
+        #
+        # When there is a too complex situation users can always put in --input
+        # and some JSON to work around it until something better comes around
+        #
+        # @param type [String] a puppet type
+        # @return [Class, Boolean] The data type, if its an array input or not
+        def puppet_type_to_ruby(type)
+          array = false
+
+          type = $1 if type =~ /Optional\[(.+)/
+
+          if type =~ /Array\[(.+)/
+            type = $1
+            array = true
+          end
+
+          return [Numeric, array] if type =~ /Integer/
+          return [Numeric, array] if type =~ /Float/
+          return [Hash, array] if type =~ /Hash/
+          return [:boolean, array] if type =~ /Boolean/
+
+          [String, array]
+        end
+
+        def run!(params)
+          with_script_compiler do |compiler|
+            compiler.call_function("choria::run_playbook", @plan, params)
+          end
+        end
+
+        # Adds the CLI options for an application based on the playbook inputs
+        #
+        # @param application [MCollective::Application]
+        # @param set_required [Boolean]
+        def add_cli_options(application, set_required=false)
+          sig = plan_signature
+
+          return if sig.nil? || sig.empty?
+
+          sig.each do |name, details|
+            type, array = puppet_type_to_ruby(details["type"])
+
+            properties = {
+              :description => "Plan input property (%s)" % details["type"],
+              :arguments => "--%s %s" % [name.downcase, name.upcase],
+              :type => array ? :array : type
+            }
+
+            properties[:required] = true if details["required"] && set_required
+            properties[:arguments] = "--[no-]%s" % name.downcase if type == :boolean
+
+            application.class.option(name, properties)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/util/bolt_support/task_result.rb

@@ -0,0 +1,94 @@
+module MCollective
+  module Util
+    class BoltSupport
+      class TaskResult
+        attr_reader :host, :result
+
+        # Method used by Puppet to create the TaskResult from a hash
+        #
+        # @param hash [Hash] hash as prodused by various execution_result method
+        # @return [TaskResult]
+        def self.from_asserted_hash(hash)
+          new(hash.keys.first, hash.values.first)
+        end
+
+        # @param host [String] node name
+        # @param result [Hash] result value as produced by execution_result methods
+        def initialize(host, result)
+          @host = host
+          @result = result
+        end
+
+        def to_hash
+          {@host => @result}
+        end
+
+        def to_json(obj={})
+          to_hash.to_json(obj)
+        end
+
+        # A error object if this represents an error
+        #
+        # @return [Puppet::DataTypes::Error, nil]
+        def error
+          if @result["error"]
+            if defined?(Puppet::DataTypes::Error)
+              Puppet::DataTypes::Error.from_asserted_hash(@result["error"])
+            else
+              @result["error"]
+            end
+          end
+        end
+
+        # The type of task that created this result
+        #
+        # @return String examples like mcollective, data etc
+        def type
+          @result["type"]
+        end
+
+        # If this task result represents a succesful task
+        #
+        # This supposed fail_ok, any task with that set will be considered passed
+        #
+        # @return Boolean
+        def ok
+          return true if @result["fail_ok"]
+
+          !@result.include?("error")
+        end
+        alias :ok? :ok
+
+        def fail_ok
+          @result["fail_ok"]
+        end
+        alias :fail_ok? :fail_ok
+
+        # Access the value data embedded in the result
+        #
+        # @param key [String] data to access
+        # @return [Object] the specifiv item in the value hash or the raw value
+        def [](key)
+          return @result["value"] unless @result["value"].is_a?(Hash)
+
+          @result["value"][key]
+        end
+
+        # Access the value data in raw form
+        #
+        # @return [Object] whatever value the task produced
+        def value
+          @result["value"]
+        end
+
+        def to_s
+          if Object.const_defined?(:Puppet)
+            Puppet::Pops::Types::StringConverter.convert(self, "%p")
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/util/bolt_support/task_results.rb

@@ -0,0 +1,128 @@
+module MCollective
+  module Util
+    class BoltSupport
+      class TaskResults
+        attr_reader :results, :exception
+        attr_writer :message
+
+        include Enumerable
+
+        def self.include_iterable
+          include(Puppet::Pops::Types::Iterable)
+          include(Puppet::Pops::Types::IteratorProducer)
+        end
+
+        # Method used by Puppet to create the TaskResults from a array
+        #
+        # @param results [Array<TaskResult>] hash as prodused by various execution_result method
+        # @return [TaskResults]
+        def self.from_asserted_hash(results, exception=nil)
+          new(results, exception)
+        end
+
+        # @param results [Array<TaskResult>]
+        def initialize(results, exception=nil)
+          @results = results
+          @exception = exception
+        end
+
+        def to_json(obj={})
+          @results.to_json(obj)
+        end
+
+        # Iterate over all results
+        #
+        # @yield [TaskResult]
+        def each(&block)
+          @results.each(&block)
+        end
+
+        # Set of all the results that are errors regardless of fail_ok
+        #
+        # @return [TaskResults]
+        def error_set
+          TaskResults.new(@results.select(&:error))
+        end
+
+        # Set of all the results that are ok regardless of fail_ok
+        #
+        # @return [TaskResults]
+        def ok_set
+          TaskResults.new(@results.reject(&:error))
+        end
+
+        # Determines if all results are ok, considers fail_ok
+        #
+        # @return [Boolean]
+        def ok
+          @results.all?(&:ok)
+        end
+        alias :ok? :ok
+
+        def fail_ok
+          @results.all?(&:fail_ok)
+        end
+        alias :fail_ok? :fail_ok
+
+        def message
+          return exception.to_s if exception
+
+          @message
+        end
+
+        # List of node names for all results
+        #
+        # @return [Array<String>]
+        def hosts
+          @results.map(&:host)
+        end
+
+        # First result in the set
+        #
+        # @return [TaskResult]
+        def first
+          @results.first
+        end
+
+        # Finds a result by name
+        #
+        # @param host [String] node hostname
+        # @return [TaskResult,nil]
+        def find(host)
+          @results.find {|r| r.host == host}
+        end
+
+        # Determines if the resultset is empty
+        #
+        # @return [Boolean]
+        def empty
+          @results.empty?
+        end
+        alias :empty? :empty
+
+        # Determines the count of results in the set
+        #
+        # @return [Integer]
+        def count
+          @results.size
+        end
+
+        def to_s
+          if Object.const_defined?(:Puppet)
+            Puppet::Pops::Types::StringConverter.convert(self, "%p")
+          else
+            super
+          end
+        end
+
+        def iterator
+          if Object.const_defined?(:Puppet) && Puppet.const_defined?(:Pops) && self.class.included_modules.include?(Puppet::Pops::Types::Iterable)
+            return Puppet::Pops::Types::Iterable.on(@results, TaskResult)
+          end
+
+          raise(NotImplementedError, "iterator requires puppet code to be loaded.")
+        end
+      end
+    end
+  end
+end