choria-mcorpc-support 2.23.0 → 2.24.1

data/lib/mcollective/data/bolt_task_data.rb

@@ -1,32 +0,0 @@
-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.ddl

@@ -1,20 +0,0 @@
-metadata    :name        => "Collective",
-            :description => "Collective membership",
-            :author      => "Puppet Labs",
-            :license     => "ASL 2.0",
-            :version     => "1.0",
-            :url         => "https://docs.puppetlabs.com/mcollective/",
-            :timeout     => 1
-
-dataquery :description => "Collective" do
-  input :query,
-        :prompt => 'Collective',
-        :description => 'Collective name to ask about, eg mcollective',
-        :type => :string,
-        :validation => /./,
-        :maxlength => 256
-
-  output :member,
-        :description => 'Node is a member of the named collective',
-        :display_as => 'member'
-end

data/lib/mcollective/data/collective_data.rb

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

data/lib/mcollective/data/fact_data.ddl

@@ -1,28 +0,0 @@
-metadata    :name        => "Fact",
-            :description => "Structured fact query",
-            :author      => "Puppet Labs",
-            :license     => "ASL 2.0",
-            :version     => "1.0",
-            :url         => "https://docs.puppetlabs.com/mcollective/",
-            :timeout     => 1
-
-dataquery :description => "Fact" do
-  input :query,
-        :prompt => 'Fact Path',
-        :description => 'Path to a fact, eg network.eth0.address',
-        :type => :string,
-        :validation => /./,
-        :maxlength => 256
-
-  output :exists,
-        :description => 'Fact is present',
-        :display_as => 'exists'
-
-  output :value,
-        :description => 'Fact value',
-        :display_as => 'value'
-
-  output :value_encoding,
-        :description => 'Encoding of the fact value (text/plain or application/json)',
-        :display_as => 'value_encoding'
-end

data/lib/mcollective/data/fact_data.rb

@@ -1,55 +0,0 @@
-module MCollective
-  module Data
-    class Fact_data < Base
-      query do |path|
-        parts = path.split(/\./)
-        walk_path(parts)
-      end
-
-      private
-
-      def walk_path(path)
-        # Set up results as though we didn't find the value
-        result[:exists] = false
-        result[:value] = false
-        result[:value_encoding] = false
-
-        facts = PluginManager["facts_plugin"].get_facts
-
-        path.each do |level|
-          case facts
-          when Array
-            level = Integer(level)
-            if level >= facts.size
-              # array index out would be out of bounds, so we don't have the value
-              return
-            end
-          when Hash
-            unless facts.include?(level)
-              # we don't have the key for the next level, so give up
-              return
-            end
-          else
-            # this isn't a container data type, so we can't walk into it
-            return
-          end
-
-          facts = facts[level]
-        end
-
-        result[:exists] = true
-        case facts
-        when Array, Hash
-          # Currently data plugins cannot return structured data, so until
-          # 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"
-        else
-          result[:value] = facts
-          result[:value_encoding] = "text/plain"
-        end
-      end
-    end
-  end
-end

data/lib/mcollective/data/fstat_data.ddl

@@ -1,89 +0,0 @@
-metadata    :name        => "File Stat",
-            :description => "Retrieve file stat data for a given file",
-            :author      => "R.I.Pienaar <rip@devco.net>",
-            :license     => "ASL 2.0",
-            :version     => "1.0",
-            :url         => "https://docs.puppetlabs.com/mcollective/",
-            :timeout     => 1
-
-dataquery :description => "File stat information" do
-    input :query,
-          :prompt => "File Name",
-          :description => "Valid File Name",
-          :type => :string,
-          :validation => /.+/,
-          :maxlength => 120
-
-    output :name,
-           :description => "File name",
-           :display_as => "Name"
-
-    output :output,
-           :description => "Human readable information about the file",
-           :display_as => "Status"
-
-    output :present,
-           :description => "Indicates if the file exist using 0 or 1",
-           :display_as => "Present"
-
-    output :size,
-           :description => "File size",
-           :display_as => "Size"
-
-    output :mode,
-           :description => "File mode",
-           :display_as => "Mode"
-
-    output :md5,
-           :description => "File MD5 digest",
-           :display_as => "MD5"
-
-    output :mtime,
-           :description => "File modification time",
-           :display_as => "Modification time"
-
-    output :ctime,
-           :description => "File change time",
-           :display_as => "Change time"
-
-    output :atime,
-           :description => "File access time",
-           :display_as => "Access time"
-
-    output :mtime_seconds,
-           :description => "File modification time in seconds",
-           :display_as => "Modification time"
-
-    output :ctime_seconds,
-           :description => "File change time in seconds",
-           :display_as => "Change time"
-
-    output :atime_seconds,
-           :description => "File access time in seconds",
-           :display_as => "Access time"
-
-    output :mtime_age,
-           :description => "File modification age in seconds",
-           :display_as => "Modification age"
-
-    output :ctime_age,
-           :description => "File change age in seconds",
-           :display_as => "Change age"
-
-    output :atime_age,
-           :description => "File access age in seconds",
-           :display_as => "Access age"
-
-    output :uid,
-           :description => "File owner",
-           :display_as => "Owner"
-
-    output :gid,
-           :description => "File group",
-           :display_as => "Group"
-
-    output :type,
-           :description => "File type",
-           :display_as => "Type"
-end
-

data/lib/mcollective/data/fstat_data.rb

@@ -1,54 +0,0 @@
-module MCollective
-  module Data
-    class Fstat_data < Base
-      query do |file|
-        result[:name] = file
-        result[:output] = "not present"
-        result[:type] = "unknown"
-        result[:mode] = "0000"
-        result[:present] = 0
-        result[:size] = 0
-        result[:mtime] = 0
-        result[:ctime] = 0
-        result[:atime] = 0
-        result[:mtime_seconds] = 0
-        result[:ctime_seconds] = 0
-        result[:atime_seconds] = 0
-        result[:md5] = 0
-        result[:uid] = 0
-        result[:gid] = 0
-
-        if File.exist?(file)
-          result[:output] = "present"
-          result[:present] = 1
-
-          if File.symlink?(file)
-            stat = File.lstat(file)
-          else
-            stat = File.stat(file)
-          end
-
-          [:size, :uid, :gid].each do |item|
-            result[item] = stat.send(item)
-          end
-
-          [:mtime, :ctime, :atime].each do |item|
-            result[item] = stat.send(item).strftime("%F %T")
-            result["#{item}_seconds".to_sym] = stat.send(item).to_i
-            result["#{item}_age".to_sym] = Time.now.to_i - stat.send(item).to_i
-          end
-
-          result[:mode] = "%o" % [stat.mode]
-          result[:md5] = Digest::MD5.hexdigest(File.read(file)) if stat.file?
-
-          result[:type] = "directory" if stat.directory?
-          result[:type] = "file" if stat.file?
-          result[:type] = "symlink" if stat.symlink?
-          result[:type] = "socket" if stat.socket?
-          result[:type] = "chardev" if stat.chardev?
-          result[:type] = "blockdev" if stat.blockdev?
-        end
-      end
-    end
-  end
-end

data/lib/mcollective/data/result.rb

@@ -1,50 +0,0 @@
-module MCollective
-  module Data
-    class Result
-      # remove some methods that might clash with commonly
-      # used return data to improve the effectiveness of the
-      # method_missing lookup strategy
-      undef :type if method_defined?(:type)
-
-      def initialize(outputs)
-        @data = {}
-
-        outputs.each_key do |output|
-          @data[output] = Marshal.load(Marshal.dump(outputs[output].fetch(:default, nil)))
-        end
-      end
-
-      def include?(key)
-        @data.include?(key.to_sym)
-      end
-
-      def [](key)
-        @data[key.to_sym]
-      end
-
-      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)
-
-        @data[key.to_sym] = val
-      end
-
-      def keys
-        @data.keys
-      end
-
-      def respond_to_missing?(method, *)
-        include?(method)
-      end
-
-      def method_missing(method, *args)
-        key = method.to_sym
-
-        raise NoMethodError, "undefined local variable or method `%s'" % key unless include?(key)
-
-        @data[key]
-      end
-    end
-  end
-end

data/lib/mcollective/ddl/dataddl.rb

@@ -1,56 +0,0 @@
-module MCollective
-  module DDL
-    # A DDL file for the data query plugins.
-    #
-    # Query plugins can today take only one input by convention in the DDL that
-    # is called :query, otherwise the input is identical to the standard input.
-    #
-    # metadata    :name        => "Agent",
-    #             :description => "Meta data about installed MColletive Agents",
-    #             :author      => "R.I.Pienaar <rip@devco.net>",
-    #             :license     => "ASL 2.0",
-    #             :version     => "1.0",
-    #             :url         => "https://docs.puppetlabs.com/mcollective/",
-    #             :timeout     => 1
-    #
-    # dataquery :description => "Agent Meta Data" do
-    #     input :query,
-    #           :prompt => "Agent Name",
-    #           :description => "Valid agent name",
-    #           :type => :string,
-    #           :validation => /^[\w\_]+$/,
-    #           :maxlength => 20
-    #
-    #     [:license, :timeout, :description, :url, :version, :author].each do |item|
-    #       output item,
-    #              :description => "Agent #{item}",
-    #              :display_as => item.to_s.capitalize
-    #     end
-    # end
-    class DataDDL < Base
-      def dataquery(input, &block)
-        raise "Data queries need a :description" unless input.include?(:description)
-        raise "Data queries can only have one definition" if @entities[:data]
-
-        @entities[:data] = {:description => input[:description],
-                            :input => {},
-                            :output => {}}
-
-        @current_entity = :data
-        yield if block_given?
-        @current_entity = nil
-      end
-
-      def input(argument, properties)
-        raise "The only valid input name for a data query is 'query'" if argument != :query
-
-        super
-      end
-
-      # Returns the interface for the data query
-      def dataquery_interface
-        @entities[:data] || {}
-      end
-    end
-  end
-end

data/lib/mcollective/discovery/choria.rb

@@ -1,223 +0,0 @@
-require "net/http"
-require_relative "../util/choria"
-
-module MCollective
-  class Discovery
-    class Choria
-      def self.discover(filter, timeout, limit=0, client=nil)
-        Choria.new(filter, timeout, limit, client).discover
-      end
-
-      attr_reader :timeout, :limit, :client, :config
-      attr_accessor :filter
-
-      def initialize(filter, timeout, limit, client)
-        @filter = filter
-        @timeout = timeout
-        @limit = limit
-        @client = client
-        @config = Config.instance
-      end
-
-      # Search for nodes
-      #
-      # @return [Array<String>] list of certnames found
-      def discover
-        queries = []
-
-        if choria.proxied_discovery?
-          Log.debug("Performing discovery against a PuppetDB Proxy")
-
-          choria.proxy_discovery_query(proxy_request)
-        else
-          Log.debug("Performing direct discovery against PuppetDB")
-          queries << discover_collective(filter["collective"]) if filter["collective"]
-          queries << discover_nodes(filter["identity"]) unless filter["identity"].empty?
-          queries << discover_classes(filter["cf_class"]) unless filter["cf_class"].empty?
-          queries << discover_facts(filter["fact"]) unless filter["fact"].empty?
-          queries << discover_agents(filter["agent"]) unless filter["agent"].empty?
-
-          choria.pql_query(node_search_string(queries.compact), true)
-        end
-      end
-
-      # Creates a request hash for the discovery proxy
-      #
-      # @return [Hash]
-      def proxy_request
-        request = {}
-
-        request["collective"] = filter["collective"] if filter["collective"]
-        request["identities"] = filter["identity"] unless filter["identity"].empty?
-        request["classes"] = filter["cf_class"] unless filter["cf_class"].empty?
-        request["facts"] = filter["fact"] unless filter["fact"].empty?
-        request["agents"] = filter["agent"] unless filter["agent"].empty?
-
-        request
-      end
-
-      # Discovers nodes in a specific collective
-      #
-      # @param filter [String] a collective name
-      # @return [String] a query string
-      def discover_collective(filter)
-        'certname in inventory[certname] { facts.mcollective.server.collectives.match("\d+") = "%s" }' % filter
-      end
-
-      # Searches for facts
-      #
-      # Nodes are searched using an `and` operator via the discover_classes method
-      #
-      # When the `rpcutil` or `scout` agent is required it will look for `Mcollective` class
-      # otherwise `Mcollective_avent_agentname` thus it will only find plugins
-      # installed using the `choria/mcollective` AIO plugin packager
-      #
-      # @param filter [Array<String>] agent names
-      # @return [Array<String>] list of nodes found
-      def discover_agents(filter)
-        pql = filter.map do |agent|
-          if ["rpcutil", "scout"].include?(agent)
-            "(%s or %s)" % [discover_classes(["mcollective::service"]), discover_classes(["choria::service"])]
-          elsif agent =~ /^\/(.+)\/$/
-            'resources {type = "File" and tag ~ "mcollective_agent_.*?%s.*?_server"}' % [string_regexi($1)]
-          else
-            'resources {type = "File" and tag = "mcollective_agent_%s_server"}' % [agent]
-          end
-        end
-
-        pql.join(" and ") unless pql.empty?
-      end
-
-      # Turns a string into a case insensitive regex string
-      #
-      # @param value [String]
-      # @return [String]
-      def string_regexi(value)
-        value =~ /^\/(.+)\/$/ ? derived_value = $1 : derived_value = value.dup
-
-        derived_value.each_char.map do |char|
-          if char =~ /[[:alpha:]]/
-            "[%s%s]" % [char.downcase, char.upcase]
-          else
-            char
-          end
-        end.join
-      end
-
-      # Capitalize a Puppet Resource
-      #
-      # foo::bar => Foo::Bar
-      #
-      # @param resource [String] a resource title
-      # @return [String]
-      def capitalize_resource(resource)
-        resource.split("::").map(&:capitalize).join("::")
-      end
-
-      # Searches for facts
-      #
-      # Nodes are searched using an `and` operator
-      #
-      # @param filter [Array<Hash>] hashes with :fact, :operator and :value
-      # @return [Array<String>] list of nodes found
-      def discover_facts(filter)
-        pql = filter.map do |q|
-          fact = q[:fact]
-          operator = q[:operator]
-          value = q[:value]
-
-          case operator
-          when "=~"
-            regex = string_regexi(value)
-
-            'inventory {facts.%s ~ "%s"}' % [fact, regex]
-          when "=="
-            if ["true", "false"].include?(value) || numeric?(value)
-              'inventory {facts.%s = %s or facts.%s = "%s"}' % [fact, value, fact, value]
-            else
-              'inventory {facts.%s = "%s"}' % [fact, value]
-            end
-          when "!="
-            if ["true", "false"].include?(value) || numeric?(value)
-              'inventory {!(facts.%s = %s or facts.%s = "%s")}' % [fact, value, fact, value]
-            else
-              'inventory {!(facts.%s = "%s")}' % [fact, value]
-            end
-          when ">=", ">", "<=", "<"
-            raise("Do not know how to do string fact comparisons using the '%s' operator with PuppetDB" % operator) unless numeric?(value)
-
-            "inventory {facts.%s %s %s}" % [fact, operator, value]
-          else
-            raise("Do not know how to do fact comparisons using the '%s' operator with PuppetDB" % operator)
-          end
-        end
-
-        pql.join(" and ") unless pql.empty?
-      end
-
-      # Searches for classes
-      #
-      # Nodes are searched using an `and` operator
-      #
-      # @return [Array<String>] list of nodes found
-      def discover_classes(filter)
-        pql = filter.map do |klass|
-          if klass =~ /^\/(.+)\/$/
-            'resources {type = "Class" and title ~ "%s"}' % [string_regexi($1)]
-          else
-            'resources {type = "Class" and title = "%s"}' % [capitalize_resource(klass)]
-          end
-        end
-
-        pql.join(" and ") unless pql.empty?
-      end
-
-      # Searches for nodes
-      #
-      # Nodes are searched using an `or` operator
-      #
-      # @return [Array<String>] list of nodes found
-      def discover_nodes(filter)
-        if filter.empty?
-          Log.debug("Empty node filter found, discovering all nodes")
-          nil
-        else
-          pql = filter.map do |ident|
-            case ident
-            when /^pql:\s*(.+)$/
-              "certname in %s" % $1
-            when /^\/(.+)\/$/
-              'certname ~ "%s"' % string_regexi($1)
-            else
-              'certname = "%s"' % ident
-            end
-          end
-
-          pql.join(" or ") unless pql.empty?
-        end
-      end
-
-      # Produce a nodes query with the supplied sub query included
-      #
-      # @param queries [Array<String>] PQL queries to be used as a sub query
-      # @return [String] nodes search string
-      def node_search_string(queries)
-        filter_queries = queries.map {|q| "(%s)" % q}.join(" and ")
-
-        "nodes[certname, deactivated] { %s }" % [filter_queries]
-      end
-
-      # Determines if a string is a number, either float or integer
-      #
-      # @param string [String]
-      # @return [boolean]
-      def numeric?(string)
-        true if Float(string) rescue false
-      end
-
-      def choria
-        @_choria ||= Util::Choria.new(false)
-      end
-    end
-  end
-end