choria-mcorpc-support 0.0.1

data/lib/mcollective/logger/syslog_logger.rb

@@ -0,0 +1,53 @@
+module MCollective
+  module Logger
+    # Implements a syslog based logger using the standard ruby syslog class
+    class Syslog_logger<Base
+      require 'syslog'
+
+      include Syslog::Constants
+
+      def start
+        config = Config.instance
+
+        facility = syslog_facility(config.logfacility)
+        level = config.loglevel.to_sym
+
+        Syslog.close if Syslog.opened?
+        Syslog.open(File.basename($0), 3, facility)
+
+        set_level(level)
+      end
+
+      def syslog_facility(facility)
+        begin
+          Syslog.const_get("LOG_#{facility.upcase}")
+        rescue NameError => e
+          STDERR.puts "Invalid syslog facility #{facility} supplied, reverting to USER"
+          Syslog::LOG_USER
+        end
+      end
+
+      def set_logging_level(level)
+        # noop
+      end
+
+      def valid_levels
+        {:info  => :info,
+         :warn  => :warning,
+         :debug => :debug,
+         :fatal => :crit,
+         :error => :err}
+      end
+
+      def log(level, from, msg)
+        if @known_levels.index(level) >= @known_levels.index(@active_level)
+          Syslog.send(map_level(level), "#{from} #{msg}")
+        end
+      rescue
+        # if this fails we probably cant show the user output at all,
+        # STDERR it as last resort
+        STDERR.puts("#{level}: #{msg}")
+      end
+    end
+  end
+end

data/lib/mcollective/matcher.rb

@@ -0,0 +1,224 @@
+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.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"]
+        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
+        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)
+      r_compare = function_hash["r_compare"]
+      operator = function_hash["operator"]
+
+      # Break out early and return false if the function returns nil
+      if l_compare.nil?
+        return false
+      end
+
+      # 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
+        unless l_compare.is_a?(String)
+          Log.debug("Cannot do a regex check on a non string value.")
+          return false
+        else
+          result = l_compare.match(r_compare)
+          # Flip return value for != operator
+          if function_hash["operator"] == "!=~"
+            return !result
+          else
+            return !!result
+          end
+        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
+          if l_compare.is_a? Numeric
+            r_compare = r_compare.strip
+            begin
+              r_compare = Integer(r_compare)
+            rescue ArgumentError
+              begin
+                r_compare = Float(r_compare)
+              rescue ArgumentError
+                raise ArgumentError, "invalid numeric value: #{r_compare}"
+              end
+            end
+          elsif l_compare.is_a? TrueClass or l_compare.is_a? FalseClass
+            r_compare = r_compare.strip
+            if r_compare == true.to_s
+              r_compare = true
+            elsif r_compare == false.to_s
+              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
+        result = l_compare.send(operator, r_compare)
+        return 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

@@ -0,0 +1,128 @@
+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 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
+
+        while (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
+
+              if p_token == nil
+                @parse_errors << [pre_index - c_token.size, scanner.token_index]
+              elsif (p_token == "and" || p_token == "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
+
+              if p_token == nil
+                @parse_errors << [pre_index - c_token.size, scanner.token_index]
+              elsif (p_token == "and" || p_token == "or")
+                @parse_errors << [pre_index - 1 - p_token.size, pre_index - 1]
+              end
+
+            when "not"
+              unless n_token =~ /fstatement|statement|\(|not/ && !(n_token == nil)
+                @parse_errors << [pre_index, scanner.token_index]
+              end
+
+            when "statement","fstatement"
+              unless n_token =~ /and|or|\)/
+                unless scanner.token_index == scanner.arguments.size
+                  @parse_errors << [pre_index, scanner.token_index]
+                end
+              end
+
+            when ")"
+              unless (n_token =~ /|and|or|not|\(/)
+                unless(scanner.token_index == scanner.arguments.size)
+                  @parse_errors << [pre_index, scanner.token_index]
+                end
+              end
+              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 =~ /fstatement|statement|not|\(/
+                @parse_errors << [pre_index, scanner.token_index]
+              end
+              @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
+
+            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
+          pre_index = @scanner.token_index
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/matcher/scanner.rb

@@ -0,0 +1,241 @@
+module MCollective
+  module Matcher
+    class Scanner
+      attr_accessor :arguments, :token_index
+
+      def initialize(arguments)
+        @token_index = 0
+        @arguments = arguments.split("")
+        @seperation_counter = 0
+        @white_spaces = 0
+      end
+
+      # Scans the input string and identifies single language tokens
+      def get_token
+        if @token_index >= @arguments.size
+          return nil
+        end
+
+        case @arguments[@token_index]
+        when "("
+          return "(", "("
+
+        when ")"
+          return ")", ")"
+
+        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 "!"
+          return "not", "not"
+
+        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
+      end
+
+      private
+      # Helper generates a statement token
+      def gen_statement
+        func = false
+        current_token_value = ""
+        j = @token_index
+        escaped = false
+
+        begin
+          if (@arguments[j] == "/")
+            begin
+              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
+            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] =~ /\//)
+              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] != '/')
+                  if  @arguments[j] == '\\'
+                    # eat the escape char
+                    current_token_value << @arguments[j]
+                    j += 1
+                    escaped = true
+                  end
+
+                  current_token_value << @arguments[j]
+                  j += 1
+                end
+                current_token_value << @arguments[j] if @arguments[j]
+                break
+              end
+
+              if @arguments[j] == "("
+                func = true
+
+                current_token_value << @arguments[j]
+                j += 1
+
+                while j < @arguments.size
+                  current_token_value << @arguments[j]
+                  if @arguments[j] == ')'
+                    j += 1
+                    break
+                  end
+                  j += 1
+                end
+              elsif @arguments[j] == '"' || @arguments[j] == "'"
+                escaped = true
+                escaped_with = @arguments[j]
+
+                j += 1 # step over first " or '
+                @white_spaces += 1
+                # identified "..." or '...'
+                while j < @arguments.size
+                  if  @arguments[j] == '\\'
+                    # eat the escape char but don't add it to the token, or we
+                    # end up with \\\"
+                    j += 1
+                    @white_spaces += 1
+                    unless j < @arguments.size
+                      break
+                    end
+                  elsif @arguments[j] == escaped_with
+                    j += 1
+                    @white_spaces += 1
+                    break
+                  end
+                  current_token_value << @arguments[j]
+                  j += 1
+                end
+              else
+                current_token_value << @arguments[j]
+                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 + @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
+            if escaped
+              return "statement", current_token_value
+            end
+            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