mcollective-client 1.3.3

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,16 @@
+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
+    autoload :Parser, "mcollective/matcher/parser"
+    autoload :Scanner, "mcollective/matcher/scanner"
+  end
+end

data/lib/mcollective/matcher/parser.rb

@@ -0,0 +1,93 @@
+module MCollective
+  module Matcher
+    class Parser
+      attr_reader :scanner, :execution_stack
+
+      def initialize(args)
+        @scanner = Scanner.new(args)
+        @execution_stack = []
+        parse
+      end
+
+      # Parse the input string, one token at a time a contruct the call stack
+      def parse
+        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 "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}'"
+              end
+
+              if p_token == nil
+                raise "Error at column #{scanner.token_index}. \n Expression cannot start with 'and'"
+              elsif (p_token == "and" || p_token == "or")
+                raise "Error at column #{scanner.token_index}. \n #{p_token} cannot be followed by 'and'"
+              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}'"
+              end
+
+              if p_token == nil
+                raise "Error at column #{scanner.token_index}. \n Expression cannot start with 'or'"
+              elsif (p_token == "and" || p_token == "or")
+                raise "Error at column #{scanner.token_index}. \n #{p_token} cannot be followed by 'or'"
+              end
+
+            when "not"
+              unless n_token =~ /statement|\(|not/
+                raise "Error at column #{scanner.token_index}. \nExpected 'statement' or '('. Found '#{n_token_value}'"
+              end
+
+            when "statement"
+              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}'"
+                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}'"
+                end
+              end
+              parenth += 1
+
+            when "("
+              unless n_token =~ /statement|not|\(/
+                raise "Error at column #{scanner.token_index}. \nExpected 'statement', '(',  not. Found '#{n_token_value}'"
+              end
+              parenth -= 1
+
+            else
+              raise "Unexpected token found at column #{scanner.token_index}. '#{c_token_value}'"
+            end
+
+            unless n_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 '('."
+        end
+      end
+    end
+  end
+end

data/lib/mcollective/matcher/scanner.rb

@@ -0,0 +1,123 @@
+module MCollective
+  module Matcher
+    class Scanner
+      attr_accessor :arguments, :token_index
+
+      def initialize(arguments)
+        @token_index = 0
+        @arguments = arguments
+      end
+
+      # Scans the input string and identifies single language tokens
+      def get_token
+        if @token_index >= @arguments.size
+          return nil
+        end
+
+        begin
+          case @arguments.split("")[@token_index]
+          when "("
+            return "(", "("
+
+          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 "not", "not"
+
+          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 " ", " "
+
+          else
+            gen_statement
+          end
+        end
+      rescue NoMethodError => e
+        pp e
+        raise "Cannot end statement with 'and', 'or', 'not'"
+      end
+
+      private
+      # Helper generates a statement token
+      def gen_statement
+        current_token_value = ""
+        j = @token_index
+
+        begin
+          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] =~ /\//)
+          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}'"
+                end
+
+                if current_token_value =~ /^(and|or|not|!)$/
+                    raise "Class name cannot be 'and', 'or', 'not'. Found '#{current_token_value}'"
+                end
+
+                @token_index += current_token_value.size - 1
+                return "statement", current_token_value
+            end
+        end
+    end
+end

data/lib/mcollective/message.rb

@@ -0,0 +1,201 @@
+module MCollective
+  # container for a message, its headers, agent, collective and other meta data
+  class Message
+    attr_reader :message, :request, :validated, :msgtime, :payload, :type, :expected_msgid, :reply_to
+    attr_accessor :headers, :agent, :collective, :filter
+    attr_accessor :requestid, :discovered_hosts, :options, :ttl
+
+    VALIDTYPES = [:message, :request, :direct_request, :reply]
+
+    # payload                  - the message body without headers etc, just the text
+    # message                  - the original message received from the middleware
+    # options[:base64]         - if the body base64 encoded?
+    # options[:agent]          - the agent the message is for/from
+    # options[:collective]     - the collective its for/from
+    # options[:headers]        - the message headers
+    # options[:type]           - an indicator about the type of message, :message, :request, :direct_request or :reply
+    # options[:request]        - if this is a reply this should old the message we are replying to
+    # options[:filter]         - for requests, the filter to encode into the message
+    # options[:options]        - the normal client options hash
+    # options[:ttl]            - the maximum amount of seconds this message can be valid for
+    # options[:expected_msgid] - in the case of replies this is the msgid it is expecting in the replies
+    def initialize(payload, message, options = {})
+      options = {:base64 => false,
+                 :agent => nil,
+                 :headers => {},
+                 :type => :message,
+                 :request => nil,
+                 :filter => Util.empty_filter,
+                 :options => {},
+                 :ttl => 60,
+                 :expected_msgid => nil,
+                 :collective => nil}.merge(options)
+
+      @payload = payload
+      @message = message
+      @requestid = nil
+      @discovered_hosts = nil
+      @reply_to = nil
+
+      @type = options[:type]
+      @headers = options[:headers]
+      @base64 = options[:base64]
+      @filter = options[:filter]
+      @expected_msgid = options[:expected_msgid]
+      @options = options[:options]
+
+      @ttl = @options[:ttl] || Config.instance.ttl
+      @msgtime = 0
+
+      @validated = false
+
+      if options[:request]
+        @request = options[:request]
+        @agent = request.agent
+        @collective = request.collective
+        @type = :reply
+      else
+        @agent = options[:agent]
+        @collective = options[:collective]
+      end
+
+      base64_decode!
+    end
+
+    # Sets the message type to one of the known types.  In the case of :direct_request
+    # the list of hosts to communicate with should have been set with #discovered_hosts
+    # else an exception will be raised.  This is for extra security, we never accidentally
+    # want to send a direct request without a list of hosts or something weird like that
+    # as it might result in a filterless broadcast being sent.
+    #
+    # Additionally you simply cannot set :direct_request if direct_addressing was not enabled
+    # this is to force a workflow that doesnt not yield in a mistake when someone might assume
+    # direct_addressing is enabled when its not.
+    def type=(type)
+      if type == :direct_request
+        raise "Direct requests is not enabled using the direct_addressing config option" unless Config.instance.direct_addressing
+
+        unless @discovered_hosts && !@discovered_hosts.empty?
+          raise "Can only set type to :direct_request if discovered_hosts have been set"
+        end
+      end
+
+      raise "Unknown message type #{type}" unless VALIDTYPES.include?(type)
+
+      @type = type
+    end
+
+    # Sets a custom reply-to target for requests.  The connector plugin should inspect this
+    # when constructing requests and set this header ensuring replies will go to the custom target
+    # otherwise the connector should just do what it usually does
+    def reply_to=(target)
+      raise "Custom reply targets can only be set on requests" unless [:request, :direct_request].include?(@type)
+
+      @reply_to = target
+    end
+
+    # in the case of reply messages we are expecting replies to a previously
+    # created message.  This stores a hint to that previously sent message id
+    # and can be used by other classes like the security plugins as a means
+    # of optimizing their behavior like by ignoring messages not directed
+    # at us.
+    def expected_msgid=(msgid)
+      raise "Can only store the expected msgid for reply messages" unless @type == :reply
+      @expected_msgid = msgid
+    end
+
+    def base64_decode!
+      return unless @base64
+
+      @payload = SSL.base64_decode(@payload)
+      @base64 = false
+    end
+
+    def base64_encode!
+      return if @base64
+
+      @payload = SSL.base64_encode(@payload)
+      @base64 = true
+    end
+
+    def base64?
+      @base64
+    end
+
+    def encode!
+      case type
+        when :reply
+          raise "Cannot encode a reply message if no request has been associated with it" unless request
+          raise 'callerid in original request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(request.payload[:callerid])
+
+          @requestid = request.payload[:requestid]
+          @payload = PluginManager["security_plugin"].encodereply(agent, payload, requestid, request.payload[:callerid])
+        when :request, :direct_request
+          @requestid = create_reqid
+          @payload = PluginManager["security_plugin"].encoderequest(Config.instance.identity, payload, requestid, filter, agent, collective, ttl)
+        else
+          raise "Cannot encode #{type} messages"
+      end
+    end
+
+    def decode!
+      raise "Cannot decode message type #{type}" unless [:request, :reply].include?(type)
+
+      @payload = PluginManager["security_plugin"].decodemsg(self)
+
+      if type == :request
+        raise 'callerid in request is not valid, surpressing reply to potentially forged request' unless PluginManager["security_plugin"].valid_callerid?(payload[:callerid])
+      end
+
+      [:collective, :agent, :filter, :requestid, :ttl, :msgtime].each do |prop|
+        instance_variable_set("@#{prop}", payload[prop]) if payload.include?(prop)
+      end
+    end
+
+    # Perform validation against the message by checking filters and ttl
+    def validate
+      raise "Can only validate request messages" unless type == :request
+
+      msg_age = Time.now.utc.to_i - msgtime
+
+      if msg_age > ttl
+        cid = ""
+        cid += payload[:callerid] + "@" if payload.include?(:callerid)
+        cid += payload[:senderid]
+
+        if msg_age > ttl
+          PluginManager["global_stats"].ttlexpired
+
+          raise(MsgTTLExpired, "Message #{requestid} from #{cid} created at #{msgtime} is #{msg_age} seconds old, TTL is #{ttl}")
+        end
+      end
+
+      raise(NotTargettedAtUs, "Received message is not targetted to us") unless PluginManager["security_plugin"].validate_filter?(payload[:filter])
+
+      @validated = true
+    end
+
+    # publish a reply message by creating a target name and sending it
+    def publish
+      Timeout.timeout(2) do
+        # If we've been specificaly told about hosts that were discovered
+        # use that information to do P2P calls if appropriate else just
+        # send it as is.
+        if @discovered_hosts && Config.instance.direct_addressing
+          if @discovered_hosts.size <= Config.instance.direct_addressing_threshold
+            @type = :direct_request
+            Log.debug("Handling #{requestid} as a direct request")
+          end
+
+          PluginManager["connector_plugin"].publish(self)
+        else
+          PluginManager["connector_plugin"].publish(self)
+        end
+      end
+    end
+
+    def create_reqid
+      Digest::MD5.hexdigest("#{Config.instance.identity}-#{Time.now.to_f}-#{agent}-#{collective}")
+    end
+  end
+end