mcollective-client 2.0.0 → 2.2.0

data/lib/mcollective/matcher.rb

@@ -12,5 +12,172 @@ module MCollective
   module Matcher
     autoload :Parser, "mcollective/matcher/parser"
     autoload :Scanner, "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.match(/^.+\(.*\)$/)
+        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.match(/'|"/)
+            func_quotes.delete_at(i)
+            break
+          end
+        end
+
+        func_quotes.reverse.each_with_index do |item,i|
+          if item.match(/'|"/)
+            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"]
+        eval_result = result.send(function_hash["value"])
+        return eval_result
+      else
+        return 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)
+      if expression.values.first =~ /^\//
+        return Util.has_cf_class?(expression.values.first)
+      elsif expression.values.first =~ />=|<=|=|<|>/
+        optype = expression.values.first.match(/>=|<=|=|<|>/)
+        name, value = expression.values.first.split(optype[0])
+        unless value.split("")[0] == "/"
+          optype[0] == "=" ? optype = "==" : optype = optype[0]
+        else
+          optype = "=~"
+        end
+
+        return Util.has_fact?(name,value, optype).to_s
+      else
+        return 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)
+      l_compare = execute_function(function_hash)
+
+      # 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
+
+      # Escape strings for evaluation
+      function_hash["r_compare"] = "\"#{function_hash["r_compare"]}\"" if(l_compare.is_a?(String)  && !(function_hash["operator"] =~ /=~|!=~/))
+
+      # Do a regex comparison if right compare string is a regex
+      if function_hash["operator"] =~ /(=~|!=~)/
+        # Fail if left compare value isn't a string
+        unless l_compare.is_a?(String)
+          Log.debug("Cannot do a regex check on a non string value.")
+          return false
+        else
+          compare_result = l_compare.match(function_hash["r_compare"])
+          # Flip return value for != operator
+          if function_hash["operator"] == "!=~"
+            !((compare_result.nil?) ? false : true)
+          else
+            (compare_result.nil?) ? false : true
+          end
+        end
+        # Otherwise evaluate the logical comparison
+      else
+        l_compare = "\"#{l_compare}\"" if l_compare.is_a?(String)
+        result = eval("#{l_compare} #{function_hash["operator"]} #{function_hash["r_compare"]}")
+        (result.nil?) ? false : result
+      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|
+        if statement.keys.first == "fstatement"
+          callstack[i]["fstatement"] = create_function_hash(statement.values.first)
+        end
+      end
+      callstack
+    end
   end
 end

data/lib/mcollective/matcher/parser.rb

@@ -6,11 +6,44 @@ module MCollective
       def initialize(args)
         @scanner = Scanner.new(args)
         @execution_stack = []
+        @parse_errors = []
+        @token_errors = []
+        @paren_errors = []
         parse
+        exit_with_token_errors if @token_errors.size > 0
+        exit_with_parse_errors if @parse_errors.size > 0
+        exit_with_paren_errors if @paren_errors.size > 0
+      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
+        pre_index = @scanner.token_index
         p_token,p_token_value = nil
         c_token,c_token_value = @scanner.get_token
         parenth = 0
@@ -21,71 +54,73 @@ module MCollective
 
           unless n_token == " "
             case c_token
+            when "bad_token"
+              @token_errors << c_token_value
+
             when "and"
-              unless (n_token =~ /not|statement|\(/) || (scanner.token_index == scanner.arguments.size)
-                raise "Error at column #{scanner.token_index}. \nExpected 'not', 'statement' or '('. Found '#{n_token_value}'"
+              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !(n_token == nil)
+                @parse_errors << [pre_index, scanner.token_index]
               end
 
               if p_token == nil
-                raise "Error at column #{scanner.token_index}. \n Expression cannot start with 'and'"
+                @parse_errors << [pre_index - c_token.size, scanner.token_index]
               elsif (p_token == "and" || p_token == "or")
-                raise "Error at column #{scanner.token_index}. \n #{p_token} cannot be followed by 'and'"
+                @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
               end
 
             when "or"
-              unless (n_token =~ /not|statement|\(/) || (scanner.token_index == scanner.arguments.size)
-                raise "Error at column #{scanner.token_index}. \nExpected 'not', 'statement', '('. Found '#{n_token_value}'"
+              unless (n_token =~ /not|fstatement|statement|\(/) || (scanner.token_index == scanner.arguments.size) && !(n_token == nil)
+                @parse_errors << [pre_index, scanner.token_index]
               end
 
               if p_token == nil
-                raise "Error at column #{scanner.token_index}. \n Expression cannot start with 'or'"
+                @parse_errors << [pre_index - c_token.size, scanner.token_index]
               elsif (p_token == "and" || p_token == "or")
-                raise "Error at column #{scanner.token_index}. \n #{p_token} cannot be followed by 'or'"
+                @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
               end
 
             when "not"
-              unless n_token =~ /statement|\(|not/
-                raise "Error at column #{scanner.token_index}. \nExpected 'statement' or '('. Found '#{n_token_value}'"
+              unless n_token =~ /fstatement|statement|\(|not/ && !(n_token == nil)
+                @parse_errors << [pre_index, scanner.token_index]
               end
 
-            when "statement"
+            when "statement","fstatement"
               unless n_token =~ /and|or|\)/
                 unless scanner.token_index == scanner.arguments.size
-                  raise "Error at column #{scanner.token_index}. \nExpected 'and', 'or', ')'. Found '#{n_token_value}'"
+                  @parse_errors << [pre_index, scanner.token_index]
                 end
               end
 
             when ")"
               unless (n_token =~ /|and|or|not|\(/)
                 unless(scanner.token_index == scanner.arguments.size)
-                  raise "Error at column #{scanner.token_index}. \nExpected 'and', 'or', 'not' or '('. Found '#{n_token_value}'"
+                  @parse_errors << [pre_index, scanner.token_index]
                 end
               end
-              parenth += 1
+              unless @paren_errors.empty?
+                @paren_errors.pop
+              else
+                @paren_errors.push((n_token.nil?) ? scanner.token_index - 1: scanner.token_index - n_token_value.size)
+              end
 
             when "("
-              unless n_token =~ /statement|not|\(/
-                raise "Error at column #{scanner.token_index}. \nExpected 'statement', '(',  not. Found '#{n_token_value}'"
+              unless n_token =~ /fstatement|statement|not|\(/
+                @parse_errors << [pre_index, scanner.token_index]
               end
-              parenth -= 1
+              @paren_errors.push((n_token.nil?) ? scanner.token_index - 1: scanner.token_index - n_token_value.size)
 
             else
-              raise "Unexpected token found at column #{scanner.token_index}. '#{c_token_value}'"
+              @parse_errors << [pre_index, scanner.token_index]
             end
 
-            unless n_token == " "
+            unless n_token == " " ||c_token == "bad_token"
               @execution_stack << {c_token => c_token_value}
             end
 
             p_token, p_token_value = c_token, c_token_value
             c_token, c_token_value = n_token, n_token_value
           end
-        end
-
-        if parenth < 0
-          raise "Error. Missing parentheses ')'."
-        elsif parenth > 0
-          raise "Error. Missing parentheses '('."
+          pre_index = @scanner.token_index
         end
       end
     end

data/lib/mcollective/matcher/scanner.rb

@@ -5,7 +5,9 @@ module MCollective
 
       def initialize(arguments)
         @token_index = 0
-        @arguments = arguments
+        @arguments = arguments.split("")
+        @seperation_counter = 0
+        @white_spaces = 0
       end
 
       # Scans the input string and identifies single language tokens
@@ -14,110 +16,186 @@ module MCollective
           return nil
         end
 
-        begin
-          case @arguments.split("")[@token_index]
-          when "("
-            return "(", "("
-
-          when ")"
-            return ")", ")"
+        case @arguments[@token_index]
+        when "("
+          return "(", "("
 
-          when "n"
-            if (@arguments.split("")[@token_index + 1] == "o") && (@arguments.split("")[@token_index + 2] == "t") && ((@arguments.split("")[@token_index + 3] == " ") || (@arguments.split("")[@token_index + 3] == "("))
-              @token_index += 2
-              return "not", "not"
-            else
-              gen_statement
-            end
+        when ")"
+          return ")", ")"
 
-          when "!"
+        when "n"
+          if (@arguments[@token_index + 1] == "o") && (@arguments[@token_index + 2] == "t") && ((@arguments[@token_index + 3] == " ") || (@arguments[@token_index + 3] == "("))
+            @token_index += 2
             return "not", "not"
+          else
+            gen_statement
+          end
 
-          when "a"
-            if (@arguments.split("")[@token_index + 1] == "n") && (@arguments.split("")[@token_index + 2] == "d") && ((@arguments.split("")[@token_index + 3] == " ") || (@arguments.split("")[@token_index + 3] == "("))
-              @token_index += 2
-              return "and", "and"
-            else
-              gen_statement
-            end
-
-          when "o"
-            if (@arguments.split("")[@token_index + 1] == "r") && ((@arguments.split("")[@token_index + 2] == " ") || (@arguments.split("")[@token_index + 2] == "("))
-              @token_index += 1
-              return "or", "or"
-            else
-              gen_statement
-            end
+        when "!"
+          return "not", "not"
 
-          when " "
-            return " ", " "
+        when "a"
+          if (@arguments[@token_index + 1] == "n") && (@arguments[@token_index + 2] == "d") && ((@arguments[@token_index + 3] == " ") || (@arguments[@token_index + 3] == "("))
+            @token_index += 2
+            return "and", "and"
+          else
+            gen_statement
+          end
 
+        when "o"
+          if (@arguments[@token_index + 1] == "r") && ((@arguments[@token_index + 2] == " ") || (@arguments[@token_index + 2] == "("))
+            @token_index += 1
+            return "or", "or"
           else
             gen_statement
           end
+
+        when " "
+          return " ", " "
+
+        else
+          gen_statement
         end
-      rescue NoMethodError => e
-        pp e
-        raise "Cannot end statement with 'and', 'or', 'not'"
       end
 
       private
       # Helper generates a statement token
       def gen_statement
+        func = false
         current_token_value = ""
         j = @token_index
 
         begin
-          if (@arguments.split("")[j] == "/")
+          if (@arguments[j] == "/")
             begin
-              current_token_value << @arguments.split("")[j]
+              current_token_value << @arguments[j]
+              j += 1
+            end until (j >= @arguments.size) || (@arguments[j] =~ /\s/)
+          elsif (@arguments[j] =~ /=|<|>/)
+            while !(@arguments[j] =~ /=|<|>/)
+              current_token_value << @arguments[j]
               j += 1
-              if @arguments.split("")[j] == "/"
-                current_token_value << "/"
+            end
+
+            current_token_value << @arguments[j]
+            j += 1
+
+            if @arguments[j] == "/"
+              begin
+                current_token_value << @arguments[j]
+                j += 1
+                if @arguments[j] == "/"
+                  current_token_value << "/"
+                  break
+                end
+              end until (j >= @arguments.size) || (@arguments[j] =~ /\//)
+            else
+              while (j < @arguments.size) && ((@arguments[j] != " ") && (@arguments[j] != ")"))
+                current_token_value << @arguments[j]
+                j += 1
+              end
+            end
+          else
+            begin
+              # Identify and tokenize regular expressions by ignoring everything between /'s
+              if @arguments[j] == '/'
+                current_token_value << '/'
+                j+=1
+                while(j < @arguments.size && @arguments[j] != '/')
+                  current_token_value << @arguments[j]
+                  j += 1
+                end
+                current_token_value << @arguments[j] if @arguments[j]
                 break
               end
-            end until (j >= @arguments.size) || (@arguments.split("")[j] =~ /\//)
-          elsif (@arguments.split("")[j] =~ /=|<|>/)
-                        while !(@arguments.split("")[j] =~ /=|<|>/)
-                            current_token_value << @arguments.split("")[j]
-                            j += 1
-                        end
-
-                        current_token_value << @arguments.split("")[j]
-                        j += 1
-
-                        if @arguments.split("")[j] == "/"
-                            begin
-                                current_token_value << @arguments.split("")[j]
-                                j += 1
-                                if @arguments.split("")[j] == "/"
-                                    current_token_value << "/"
-                                    break
-                                end
-                            end until (j >= @arguments.size) || (@arguments.split("")[j] =~ /\//)
-                        else
-                            while (j < @arguments.size) && ((@arguments.split("")[j] != " ") && (@arguments.split("")[j] != ")"))
-                                current_token_value << @arguments.split("")[j]
-                                j += 1
-                            end
-                        end
-                    else
-                        begin
-                            current_token_value << @arguments.split("")[j]
-                            j += 1
-                        end until (j >= @arguments.size) || (@arguments.split("")[j] =~ /\s|\)/)
-                    end
-                rescue Exception => e
-                    raise "Invalid token found - '#{current_token_value}'"
+              if @arguments[j+1] == "("
+                func = true
+                be_greedy = true
+              end
+              current_token_value << @arguments[j]
+              if be_greedy
+                while !(j+1 >= @arguments.size) && @arguments[j] != ')'
+                  j += 1
+                  current_token_value << @arguments[j]
                 end
-
-                if current_token_value =~ /^(and|or|not|!)$/
-                    raise "Class name cannot be 'and', 'or', 'not'. Found '#{current_token_value}'"
+                j += 1
+                be_greedy = false
+              else
+                j += 1
+              end
+              if(@arguments[j] == ' ')
+                break if(is_klass?(j) && !(@arguments[j-1] =~ /=|<|>/))
+              end
+              if( (@arguments[j] == ' ') && (@seperation_counter < 2) && !(current_token_value.match(/^.+(=|<|>).+$/)) )
+                if((index = lookahead(j)))
+                  j = index
                 end
+              end
+            end until (j >= @arguments.size) || (@arguments[j] =~ /\s|\)/)
+            @seperation_counter = 0
+          end
+        rescue Exception => e
+          raise "An exception was raised while trying to tokenize '#{current_token_value} - #{e}'"
+        end
 
-                @token_index += current_token_value.size - 1
-                return "statement", current_token_value
+        @token_index += current_token_value.size + @white_spaces - 1
+        @white_spaces = 0
+
+        # bar(
+        if current_token_value.match(/.+?\($/)
+          return "bad_token", [@token_index - current_token_value.size + 1, @token_index]
+        # /foo/=bar
+        elsif current_token_value.match(/^\/.+?\/(<|>|=).+/)
+          return "bad_token", [@token_index - current_token_value.size + 1, @token_index]
+        elsif current_token_value.match(/^.+?\/(<|>|=).+/)
+          return "bad_token", [@token_index - current_token_value.size + 1, @token_index]
+        else
+          if func
+            if current_token_value.match(/^.+?\((\s*(')[^']*(')\s*(,\s*(')[^']*('))*)?\)(\.[a-zA-Z0-9_]+)?((!=|<=|>=|=|>|<).+)?$/) ||
+              current_token_value.match(/^.+?\((\s*(")[^"]*(")\s*(,\s*(")[^"]*("))*)?\)(\.[a-zA-Z0-9_]+)?((!=|<=|>=|=|>|<).+)?$/)
+              return "fstatement", current_token_value
+            else
+              return "bad_token", [@token_index - current_token_value.size + 1, @token_index]
             end
+          else
+            slash_err = false
+            current_token_value.split('').each do |c|
+              if c == '/'
+                slash_err = !slash_err
+              end
+            end
+            return "bad_token", [@token_index - current_token_value.size + 1, @token_index] if slash_err
+            return "statement", current_token_value
+          end
+        end
+      end
+
+      # Deal with special puppet class statement
+      def is_klass?(j)
+        while(j < @arguments.size && @arguments[j] == ' ')
+          j += 1
+        end
+
+        if @arguments[j] =~ /=|<|>/
+          return false
+        else
+          return true
+        end
+      end
+
+      # Eat spaces while looking for the next comparison symbol
+      def lookahead(index)
+        index += 1
+        while(index <= @arguments.size)
+          @white_spaces += 1
+          unless(@arguments[index] =~ /\s/)
+            @seperation_counter +=1
+            return index
+          end
+          index += 1
         end
+        return nil
+      end
     end
+  end
 end