choria-mcorpc-support 2.23.0 → 2.24.1

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

data/lib/mcollective/discovery/stdin.rb

@@ -1,67 +0,0 @@
-# discovers against stdin instead of the traditional network discovery
-# the input must be a flat file with a node name per line which should match identities as configured,
-# or it should be a json string as output by the -j option of mco rpc
-require "mcollective/rpc/helpers"
-
-module MCollective
-  class Discovery
-    class Stdin
-      def self.discover(filter, timeout, limit=0, client=nil)
-        if client.options[:discovery_options].empty?
-          type = "auto"
-        else
-          type = client.options[:discovery_options].first.downcase
-        end
-
-        discovered = []
-
-        file = $stdin.read
-
-        raise("data piped on STDIN contained only whitespace - could not discover hosts from it.") if file =~ /^\s*$/
-
-        if type == "auto"
-          if file =~ /^\s*\[/
-            type = "json"
-          else
-            type = "text"
-          end
-        end
-
-        Log.debug("Parsing STDIN input as type %s" % type)
-
-        case type
-        when "json"
-          hosts = RPC::Helpers.extract_hosts_from_json(file)
-        when "text"
-          hosts = file.split("\n")
-        else
-          raise("stdin discovery plugin only knows the types auto/text/json, not \"#{type}\"")
-        end
-
-        hosts.map do |host|
-          raise 'Identities can only match /\w\.\-/' unless host.match(/^[\w.\-]+$/)
-
-          host
-        end
-
-        # this plugin only supports identity filters, do regex matches etc against
-        # the list found in the flatfile
-        if filter["identity"].empty?
-          discovered = hosts
-        else
-          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
-        end
-
-        discovered
-      end
-    end
-  end
-end

data/lib/mcollective/generators/data_generator.rb

@@ -1,50 +0,0 @@
-module MCollective
-  module Generators
-    class DataGenerator < Base
-      attr_accessor :ddl, :content
-
-      def initialize(plugin_name, outputs=[], name=nil, description=nil, author=nil,
-                     license=nil, version=nil, url=nil, timeout=nil)
-
-        super(name, description, author, license, version, url, timeout)
-        @mod_name = "Data"
-        @pclass = "Base"
-        @plugin_name = plugin_name
-        @outputs = outputs
-        @ddl = create_ddl
-        @content = create_plugin_content
-        @plugin = create_plugin_string
-        write_plugins
-      end
-
-      def create_ddl
-        query_text = "dataquery :description => \"Query information\" do\n"
-        query_text += ERB.new(File.read(File.join(File.dirname(__FILE__), "templates", "data_input_snippet.erb"))).result
-
-        @outputs.each_with_index do |output, i|
-          query_text += "%2s%s" % [" ", "output :#{output},\n"]
-          query_text += "%9s%s" % [" ", ":description => \"%DESCRIPTION%\",\n"]
-          query_text += "%9s%s" % [" ", ":display_as => \"%DESCRIPTION%\"\n"]
-          query_text += "\n" unless @outputs.size == (i + 1)
-        end
-
-        query_text += "end"
-
-        # Use inherited method to create metadata part of the ddl
-        create_metadata_string + query_text
-      end
-
-      def create_plugin_content
-        content_text = "%6s%s" % [" ", "query do |what|\n"]
-
-        @outputs.each do |output|
-          content_text += "%8s%s" % [" ", "result[:#{output}] = nil\n"]
-        end
-        content_text += "%6s%s" % [" ", "end\n"]
-
-        # Add actions to agent file
-        content_text
-      end
-    end
-  end
-end

data/lib/mcollective/generators/templates/data_input_snippet.erb

@@ -1,7 +0,0 @@
-  input :query,
-        :prompt => "%PROMP%",
-        :description => "%DESCRIPTION%",
-        :type => %TYPE%,
-        :validation => %VALIDATION%,
-        :maxlength => %MAXLENGTH%
-

data/lib/mcollective/matcher.rb

@@ -1,220 +0,0 @@
-module MCollective
-  # A parser and scanner that creates a stack machine for a simple
-  # fact and class matching language used on the CLI to facilitate
-  # a rich discovery language
-  #
-  # Language EBNF
-  #
-  # compound = ["("] expression [")"] {["("] expression [")"]}
-  # expression = [!|not]statement ["and"|"or"] [!|not] statement
-  # char = A-Z | a-z | < | > | => | =< | _ | - |* | / { A-Z | a-z | < | > | => | =< | _ | - | * | / | }
-  # int = 0|1|2|3|4|5|6|7|8|9{|0|1|2|3|4|5|6|7|8|9|0}
-  module Matcher
-    require "mcollective/matcher/parser"
-    require "mcollective/matcher/scanner"
-
-    # Helper creates a hash from a function call string
-    def self.create_function_hash(function_call)
-      func_hash = {}
-      f = ""
-      func_parts = function_call.split(/(!=|>=|<=|<|>|=)/)
-      func_hash["r_compare"] = func_parts.pop
-      func_hash["operator"] = func_parts.pop
-      func = func_parts.join
-
-      # Deal with dots in function parameters and functions without dot values
-      if func =~ /^.+\(.*\)$/
-        f = func
-      else
-        func_parts = func.split(".")
-        func_hash["value"] = func_parts.pop
-        f = func_parts.join(".")
-      end
-
-      # Deal with regular expression matches
-      if func_hash["r_compare"] =~ /^\/.*\/$/
-        func_hash["operator"] = "=~" if func_hash["operator"] == "="
-        func_hash["operator"] = "!=~" if func_hash["operator"] == "!="
-        func_hash["r_compare"] = Regexp.new(func_hash["r_compare"].gsub(/^\/|\/$/, ""))
-      # Convert = operators to == so they can be propperly evaluated
-      elsif func_hash["operator"] == "="
-        func_hash["operator"] = "=="
-      end
-
-      # Grab function name and parameters from left compare string
-      func_hash["name"], func_hash["params"] = f.split("(")
-      if func_hash["params"] == ")"
-        func_hash["params"] = nil
-      else
-
-        # Walk the function parameters from the front and from the
-        # back removing the first and last instances of single of
-        # double qoutes. We do this to handle the case where params
-        # contain escaped qoutes.
-        func_hash["params"] = func_hash["params"].gsub(")", "")
-        func_quotes = func_hash["params"].split(/('|")/)
-
-        func_quotes.each_with_index do |item, i|
-          if item =~ /'|"/
-            func_quotes.delete_at(i)
-            break
-          end
-        end
-
-        func_quotes.reverse.each_with_index do |item, i|
-          if item =~ /'|"/
-            func_quotes.delete_at(func_quotes.size - i - 1)
-            break
-          end
-        end
-
-        func_hash["params"] = func_quotes.join
-      end
-
-      func_hash
-    end
-
-    # Returns the result of an executed function
-    def self.execute_function(function_hash)
-      # In the case where a data plugin isn't present there are two ways we can handle
-      # the raised exception. The function result can either be false or the entire
-      # expression can fail.
-      #
-      # In the case where we return the result as false it opens us op to unexpected
-      # negation behavior.
-      #
-      #   !foo('bar').name = bar
-      #
-      # In this case the user would expect discovery to match on all machines where
-      # the name value of the foo function does not equal bar. If a non existent function
-      # returns false then it is posible to match machines where the name value of the
-      # foo function is bar.
-      #
-      # Instead we raise a DDLValidationError to prevent this unexpected behavior from
-      # happening.
-
-      result = Data.send(function_hash["name"], function_hash["params"])
-
-      if function_hash["value"]
-        begin
-          eval_result = result.send(function_hash["value"])
-        rescue
-          # If data field has not been set we set the comparison result to nil
-          eval_result = nil
-        end
-        eval_result
-      else
-        result
-      end
-    rescue NoMethodError
-      Log.debug("cannot execute discovery function '#{function_hash['name']}'. data plugin not found")
-      raise DDLValidationError
-    end
-
-    # Evaluates a compound statement
-    def self.eval_compound_statement(expression)
-      case expression.values.first
-      when /^\//
-        Util.has_cf_class?(expression.values.first)
-      when />=|<=|=|<|>/
-        optype = expression.values.first.match(/>=|<=|=|<|>/)
-        name, value = expression.values.first.split(optype[0])
-        if value.split("")[0] == "/"
-          optype = "=~"
-        else
-          optype[0] == "=" ? optype = "==" : optype = optype[0]
-        end
-
-        Util.has_fact?(name, value, optype).to_s
-      else
-        Util.has_cf_class?(expression.values.first)
-      end
-    end
-
-    # Returns the result of an evaluated compound statement that
-    # includes a function
-    def self.eval_compound_fstatement(function_hash) # rubocop:disable Metrics/MethodLength
-      l_compare = execute_function(function_hash)
-      r_compare = function_hash["r_compare"]
-      operator = function_hash["operator"]
-
-      # Break out early and return false if the function returns nil
-      return false if l_compare.nil?
-
-      # Prevent unwanted discovery by limiting comparison operators
-      # on Strings and Booleans
-      if (l_compare.is_a?(String) || l_compare.is_a?(TrueClass) || l_compare.is_a?(FalseClass)) && function_hash["operator"].match(/<|>/)
-        Log.debug("Cannot do > and < comparison on Booleans and Strings '#{l_compare} #{function_hash['operator']} #{function_hash['r_compare']}'")
-        return false
-      end
-
-      # Prevent backticks in function parameters
-      if function_hash["params"] =~ /`/
-        Log.debug("Cannot use backticks in function parameters")
-        return false
-      end
-
-      # Do a regex comparison if right compare string is a regex
-      if operator =~ /(=~|!=~)/
-        # Fail if left compare value isn't a string
-        if l_compare.is_a?(String)
-          result = l_compare.match(r_compare)
-          # Flip return value for != operator
-          if function_hash["operator"] == "!=~"
-            !result
-          else
-            !!result
-          end
-        else
-          Log.debug("Cannot do a regex check on a non string value.")
-          false
-        end
-        # Otherwise do a normal comparison while taking the type into account
-      else
-        if l_compare.is_a? String
-          r_compare = r_compare.to_s
-        elsif r_compare.is_a? String
-          case l_compare
-          when Numeric
-            r_compare = r_compare.strip
-            begin
-              r_compare = Integer(r_compare)
-            rescue ArgumentError # rubocop:disable Metrics/BlockNesting
-              begin
-                r_compare = Float(r_compare)
-              rescue ArgumentError # rubocop:disable Metrics/BlockNesting
-                raise(ArgumentError, "invalid numeric value: #{r_compare}")
-              end
-            end
-          when TrueClass, FalseClass
-            r_compare = r_compare.strip
-            if r_compare == true.to_s # rubocop:disable Metrics/BlockNesting
-              r_compare = true
-            elsif r_compare == false.to_s # rubocop:disable Metrics/BlockNesting
-              r_compare = false
-            else
-              raise(ArgumentError, "invalid boolean value: #{r_compare}")
-            end
-          end
-        end
-        operator = operator.strip
-        if operator =~ /(?:(!=|<=|>=|<|>)|==?)/
-          operator = $1 ? $1.to_sym : :==
-        else
-          raise(ArgumentError, "invalid operator: #{operator}")
-        end
-        l_compare.send(operator, r_compare)
-
-      end
-    end
-
-    # Creates a callstack to be evaluated from a compound evaluation string
-    def self.create_compound_callstack(call_string)
-      callstack = Matcher::Parser.new(call_string).execution_stack
-      callstack.each_with_index do |statement, i|
-        callstack[i]["fstatement"] = create_function_hash(statement.values.first) if statement.keys.first == "fstatement"
-      end
-      callstack
-    end
-  end
-end

data/lib/mcollective/matcher/parser.rb

@@ -1,118 +0,0 @@
-# rubocop:disable Metrics/BlockNesting
-module MCollective
-  module Matcher
-    class Parser
-      attr_reader :scanner, :execution_stack
-
-      def initialize(args)
-        @scanner = Scanner.new(args)
-        @execution_stack = []
-        @parse_errors = []
-        @token_errors = []
-        @paren_errors = []
-        parse
-        exit_with_token_errors unless @token_errors.empty?
-        exit_with_parse_errors unless @parse_errors.empty?
-        exit_with_paren_errors unless @paren_errors.empty?
-      end
-
-      # Exit and highlight any malformed tokens
-      def exit_with_token_errors
-        @token_errors.each do |error_range|
-          (error_range[0]..error_range[1]).each do |i|
-            @scanner.arguments[i] = Util.colorize(:red, @scanner.arguments[i])
-          end
-        end
-        raise "Malformed token(s) found while parsing -S input #{@scanner.arguments.join}"
-      end
-
-      def exit_with_parse_errors
-        @parse_errors.each do |error_range|
-          (error_range[0]..error_range[1]).each do |i|
-            @scanner.arguments[i] = Util.colorize(:red, @scanner.arguments[i])
-          end
-        end
-        raise "Parse errors found while parsing -S input #{@scanner.arguments.join}"
-      end
-
-      def exit_with_paren_errors
-        @paren_errors.each do |i|
-          @scanner.arguments[i] = Util.colorize(:red, @scanner.arguments[i])
-        end
-        raise "Missing parenthesis found while parsing -S input #{@scanner.arguments.join}"
-      end
-
-      # Parse the input string, one token at a time a contruct the call stack
-      def parse # rubocop:disable Metrics/MethodLength
-        pre_index = @scanner.token_index
-        p_token = nil
-        c_token, c_token_value = @scanner.get_token
-
-        until c_token.nil?
-          @scanner.token_index += 1
-          n_token, n_token_value = @scanner.get_token
-
-          unless n_token == " "
-            case c_token
-            when "bad_token"
-              @token_errors << c_token_value
-
-            when "and"
-              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !n_token.nil?
-                @parse_errors << [pre_index, scanner.token_index]
-              end
-
-              case p_token
-              when nil
-                @parse_errors << [pre_index - c_token.size, scanner.token_index]
-              when "and", "or"
-                @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
-              end
-
-            when "or"
-              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !n_token.nil?
-                @parse_errors << [pre_index, scanner.token_index]
-              end
-
-              case p_token
-              when nil
-                @parse_errors << [pre_index - c_token.size, scanner.token_index]
-              when "and", "or"
-                @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
-              end
-
-            when "not"
-              @parse_errors << [pre_index, scanner.token_index] unless n_token =~ /fstatement|statement|\(|not/ && !n_token.nil?
-
-            when "statement", "fstatement"
-              @parse_errors << [pre_index, scanner.token_index] if n_token !~ /and|or|\)/ && scanner.token_index != scanner.arguments.size
-
-            when ")"
-              @parse_errors << [pre_index, scanner.token_index] if n_token !~ /|and|or|not|\(/ && scanner.token_index != scanner.arguments.size
-              if @paren_errors.empty?
-                @paren_errors.push(n_token.nil? ? scanner.token_index - 1 : scanner.token_index - n_token_value.size)
-              else
-                @paren_errors.pop
-              end
-
-            when "("
-              @parse_errors << [pre_index, scanner.token_index] unless n_token =~ /fstatement|statement|not|\(/
-              @paren_errors.push(n_token.nil? ? scanner.token_index - 1 : scanner.token_index - n_token_value.size)
-
-            else
-              @parse_errors << [pre_index, scanner.token_index]
-            end
-
-            @execution_stack << {c_token => c_token_value} unless n_token == " " || c_token == "bad_token"
-
-            p_token = c_token
-            c_token = n_token
-            c_token_value = n_token_value
-          end
-          pre_index = @scanner.token_index
-        end
-      end
-    end
-  end
-end
-# rubocop:enable Metrics/BlockNesting