choria-mcorpc-support 2.23.1 → 2.24.2

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

data/lib/mcollective/discovery/flatfile.rb

@@ -1,47 +0,0 @@
-# discovers against a flatfile instead of the traditional network discovery
-# the flat file must have a node name per line which should match identities
-# as configured
-module MCollective
-  class Discovery
-    class Flatfile
-      def self.discover(filter, timeout, limit=0, client=nil)
-        if client.options[:discovery_options].empty?
-          raise "The flatfile discovery method needs a path to a text file"
-        else
-          file = client.options[:discovery_options].first
-        end
-
-        raise "Cannot read the file %s specified as discovery source" % file unless File.readable?(file)
-
-        discovered = []
-        hosts = []
-
-        File.readlines(file).each do |host|
-          host = host.chomp.strip
-          next if host.empty? || host.match(/^#/)
-          raise 'Identities can only match /^[\w\.\-]+$/' unless host.match(/^[\w.\-]+$/)
-
-          hosts << host
-        end
-
-        # this plugin only supports identity filters, do regex matches etc against
-        # the list found in the flatfile
-        if !filter["identity"].empty?
-          filter["identity"].each do |identity|
-            identity = Regexp.new(identity.gsub("\/", "")) if identity.match("^/")
-
-            if identity.is_a?(Regexp)
-              discovered = hosts.grep(identity)
-            elsif hosts.include?(identity)
-              discovered << identity
-            end
-          end
-        else
-          discovered = hosts
-        end
-
-        discovered
-      end
-    end
-  end
-end

data/lib/mcollective/discovery/stdin.ddl

@@ -1,11 +0,0 @@
-metadata    :name        => "stdin",
-            :description => "STDIN based discovery for node identities",
-            :author      => "Tomas Doran <bobtfish@bobtfish.net.net>",
-            :license     => "ASL 2.0",
-            :version     => "0.1",
-            :url         => "https://docs.puppetlabs.com/mcollective/",
-            :timeout     => 0
-
-discovery do
-    capabilities :identity
-end