emissary 1.3.20 → 1.3.21

data/lib/emissary/inifile.rb

@@ -0,0 +1,148 @@
+#
+# This class represents the INI file and can be used to parse INI files.
+# Derived from IniFile gem, found on http://rubyforge.org/projects/inifile/
+#
+class IniFile
+
+  #
+  # call-seq:
+  #    IniFile.load( filename )
+  #    IniFile.load( filename, options )
+  #
+  # Open the given _filename_ and load the contents of the INI file.
+  # The following _options_ can be passed to this method:
+  #
+  #    :comment => ';'      The line comment character(s)
+  #    :parameter => '='    The parameter / value separator
+  #
+  def self.load( filename, opts = {} )
+    if filename 
+      new(filename, opts)
+    else
+      nil
+    end
+  end
+
+  def initialize( filename, opts = {} )
+    @fn = filename
+    @comment = opts[:comment] || '#'
+    @param = opts[:parameter] || '='
+    @ini = Hash.new {|h,k| h[k] = Hash.new}
+
+    @rgxp_comment = /^\s*$|^\s*[#{@comment}]/
+    @rgxp_section = /^\s*\[([^\]]+)\]/
+    @rgxp_param   = /^([^#{@param}]+)#{@param}(.*)$/
+
+    parse
+  end
+
+  #
+  # call-seq:
+  #    each {|section, parameter, value| block}
+  #
+  # Yield each _section_, _parameter_, _value_ in turn to the given
+  # _block_. The method returns immediately if no block is supplied.
+  #
+  def each
+    return unless block_given?
+    @ini.each do |section,hash|
+      hash.each do |param,val|
+        yield section, param, val
+      end
+    end
+    self
+  end
+
+  #
+  # call-seq:
+  #    each_section {|section| block}
+  #
+  # Yield each _section_ in turn to the given _block_. The method returns
+  # immediately if no block is supplied.
+  #
+  def each_section
+    return unless block_given?
+    @ini.each_key {|section| yield section}
+    self
+  end
+
+  #
+  # call-seq:
+  #    ini_file[section]
+  #
+  # Get the hash of parameter/value pairs for the given _section_.
+  #
+  def []( section )
+    return nil if section.nil?
+    @ini[section.to_s]
+  end
+
+  #
+  # call-seq:
+  #    has_section?( section )
+  #
+  # Returns +true+ if the named _section_ exists in the INI file.
+  #
+  def has_section?( section )
+    @ini.has_key? section.to_s
+  end
+
+  #
+  # call-seq:
+  #    sections
+  #
+  # Returns an array of the section names.
+  #
+  def sections
+    @ini.keys
+  end
+
+  private
+
+  def cleanup(str)
+    str = str.strip
+    first = str[0..0]; last = str[-1..-1]
+    str = str[1..-2] if first == last && (first == '"' || first == "'")
+  end
+  #
+  # call-seq
+  #    parse
+  #
+  # Parse the ini file contents.
+  #
+  def parse
+    return unless ::Kernel.test ?f, @fn
+    section = nil
+
+    ::File.open(@fn, 'r') do |f|
+      while line = f.gets
+        line = line.chomp
+
+        case line
+        # ignore blank lines and comment lines
+        when @rgxp_comment: next
+
+        # this is a section declaration
+        when @rgxp_section: section = @ini[$1.strip.downcase]
+
+        # otherwise we have a parameter
+        when @rgxp_param
+          begin
+	    val = $2.strip
+	    val = val[1..-2] if val[0..0] == "'" || val[-1..-1] == '"'
+            section[$1.strip.downcase.to_sym] = val
+          rescue NoMethodError
+            raise "Bad configuration - inifile parameter encountered before first section"
+          end
+
+        else
+          raise "Bad configuration -- inifile could not parse line '#{line}"
+        end
+      end
+    end
+  end
+
+end
+
+
+

data/lib/emissary/logger.rb

@@ -0,0 +1,130 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+#
+# $Id $
+# author: Carl P. corliss
+# Copyright 2009, The New York Times
+#
+require 'syslog'
+require 'fastthread'
+
+module Emissary
+	class Logger
+		
+		LOG_SYSLOG = 0x01
+		LOG_STDOUT = 0x02
+    LOG_STDERR = 0x03
+
+    EMERGENCY = Syslog::Constants::LOG_EMERG
+    EMERG     = Syslog::Constants::LOG_EMERG
+    ALERT     = Syslog::Constants::LOG_ALERT
+    FATAL     = Syslog::Constants::LOG_CRIT
+    CRITICAL  = Syslog::Constants::LOG_CRIT
+    CRIT      = Syslog::Constants::LOG_CRIT
+    ERROR     = Syslog::Constants::LOG_ERR
+    ERR       = Syslog::Constants::LOG_ERR
+    WARNING   = Syslog::Constants::LOG_WARNING
+    WARN      = Syslog::Constants::LOG_WARNING
+    NOTICE    = Syslog::Constants::LOG_NOTICE
+    INFO      = Syslog::Constants::LOG_INFO
+    DEBUG     = Syslog::Constants::LOG_DEBUG
+    
+    CONSTANT_ID_MAP = {
+      EMERGENCY => [ :emergency, :emerg ],
+      ALERT     => [ :alert ],
+      CRITICAL  => [ :fatal, :critical, :crit ],
+      ERROR     => [ :error, :err ],
+      WARNING   => [ :warning, :warn ],
+      NOTICE    => [ :notice ],
+      INFO      => [ :info ],
+      DEBUG     => [ :debug ]
+    }
+
+    CONSTANT_NAME_MAP = CONSTANT_ID_MAP.inject({}) do |mappings,(id,names)|
+      names.each { |name| mappings.merge!({ name => id, name.to_s.upcase => id, name.to_s.downcase => id }) }
+      mappings
+    end
+
+    attr_accessor :mode, :level, :name
+    
+		def self.instance(mode = LOG_STDERR, log_level = NOTICE, name = nil)
+			@@logger ||= Emissary::Logger.new mode, log_level
+		end
+
+		private :initialize
+		
+		def initialize mode, log_level, name = nil
+			@mode  = mode || LOG_STDERR
+			@level = log_level || INFO
+      @name  = name
+      @mutex = Mutex.new
+		end
+
+    def name=(p) @name = n || File.basename($0); end
+    
+    def normalize log_level
+      return log_level unless not log_level.kind_of? Fixnum
+      return CONSTANT_NAME_MAP[log_level.to_s.downcase] rescue INFO
+      return INFO
+    end
+    
+    def level_to_sym
+      CONSTANT_ID_MAP[@level].first
+    end
+    
+    def level_to_s
+      level_to_sym.to_s.upcase
+    end
+    
+		def loggable?(log_level)
+			log_level <= normalize(@level)
+		end
+
+    def syslogger
+      @mutex.synchronize {
+        Syslog.open(name, Syslog::LOG_PID | Syslog::LOG_NDELAY, Syslog::LOG_DAEMON) do |s|
+          s.LOG_UPTO(level)
+          yield s
+        end
+      }
+    end      
+		
+		def log(log_level, message, *args)
+			case @mode
+				when Logger::LOG_SYSLOG
+          messages = "#{CONSTANT_ID_MAP[log_level].first.to_s.upcase}: #{message}".gsub(/\t/, ' '*8).split(/\n/)
+          # some syslog daemons have a hard time with newlines, so split into multiple lines
+					messages.each do |message|
+            syslogger { |s| s.log(log_level, message, *args) }
+					end
+				when Logger::LOG_STDOUT
+					$stdout << sprintf(message << "\n", *args) unless not loggable? log_level
+				when Logger::LOG_STDERR
+					$stderr << sprintf(message << "\n", *args) unless not loggable? log_level
+			end
+			
+			self
+		end
+
+		CONSTANT_ID_MAP.values.flatten.each do |log_level|
+			class_eval %(
+				def #{log_level}(message, *args)
+					log(#{'::Emissary::Logger::' + log_level.to_s.upcase}, message, *args)
+				end
+			)
+		end
+	end
+end

data/lib/emissary/message.rb

@@ -0,0 +1,217 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+require 'uuid'
+require 'bert'
+
+module Emissary
+  class Message
+
+    attr_accessor :sender, :recipient, :replyto, :errors
+    attr_accessor :status, :operation, :thread, :time
+    attr_accessor :account, :agent, :method, :args
+    attr_reader   :uuid, :originator
+    
+    def initialize(payload = {})
+      @recipient  = ''
+      @sender     = Emissary.identity.queue_name
+      @replyto    = Emissary.identity.queue_name
+      @originator = @sender.dup
+      
+      @status    = [ :ok, '' ] # tuple of (status type, status message)
+      @operation = -1
+      @thread    = -1
+      @uuid      = UUID.new.generate
+
+      @errors  = []
+      
+      @agent   = @method = nil
+      @account = Emissary.identity.account_id
+      @args    = []
+
+      @time = {
+        :received => nil,
+        :sent     => nil,
+      }
+      
+      payload = {
+        :headers => {
+          :recipient  => @recipient,
+          :sender     => @sender,
+          :replyto    => @replyto,
+          :originator => @originator,
+          :status     => @status, 
+          :operation  => @operation,
+          :thread     => @thread,
+          :uuid       => @uuid,
+          :time       => @time.merge((payload[:time].symbolize rescue {})),
+        }.merge((payload[:headers].symbolize rescue {})),
+        :data   => {
+          :account => @account,
+          :agent   => @agent,
+          :method  => @method,
+          :args    => @args
+        }.merge((payload[:data].symbolize! rescue {})),
+        :errors => [ ] + (payload[:errors].symbolize rescue [])
+      }
+
+      payload[:headers].merge(payload[:data]).each do |k,v|
+        send("#{k}=".to_sym, v) rescue nil
+      end
+      
+      payload[:errors].each do |e|
+        exception = ::Emissary.klass_const(e[:type]).new(e[:message]) rescue StandardError.new("#{e[:type]}: #{e[:message]}")
+        exception.set_backtrace(e[:backtrace])
+        errors << exception
+      end
+      
+      @agent   = @agent.to_sym rescue nil
+      @method  = @method.to_sym rescue nil
+      @args    = @args || [] rescue []
+    end
+
+    def headers()
+      {
+        :recipient  => recipient,
+        :sender     => sender,
+        :replyto    => replyto,
+        :originator => originator,
+        :status     => status,
+        :operation  => operation,
+        :thread     => thread,
+        :time       => time,
+        :uuid       => uuid
+      }
+    end
+    
+    def data()
+      return { :account => account, :agent => agent, :method => method, :args => args }
+    end
+
+    def errors type = :default
+      case type
+        when :hashes
+          @errors.collect do |e|
+            { :type => e.class.name, :message => e.message, :backtrace => e.backtrace }
+          end
+      else
+        @errors
+      end
+    end
+    
+    def status_type=(t) status[0] = t.to_sym; end
+    def status_type() status[0] || :ok rescue :ok; end
+
+    def status_note=(n) status[1] = n; end
+    def status_note() status[1] || ''  rescue '' ; end
+
+    def route who = :recipient
+      headers[who].split(':') || [] rescue []
+    end
+    
+    def routing_key who = :recipient
+      route(who)[0] || nil rescue nil
+    end
+
+    def exchange who = :recipient
+      [ exchange_type(who), exchange_name(who) ]
+    end
+    
+    def exchange_type who = :recipient
+      route(who)[1].to_sym || :direct rescue :direct
+    end
+    
+    def exchange_name who = :recipient
+      key, type, name = route(who) rescue [ nil, :direct, 'amq.direct' ]
+      name || case type.to_sym
+        when :fanout, :topic, :matches, :headers
+          "amq.#{type}"
+        else
+          'amq.direct'
+      end
+    rescue
+      'amq.direct'
+    end
+    
+    def canonical_route who = :recipient
+      "#{routing_key(who)}:#{exchange(who).join(':')}"
+    end
+    
+    def will_loop?
+      canonical_route(:recipient) == canonical_route(:originator)
+    end
+    
+    def encode
+      BERT.encode({ :headers => headers, :data => data, :errors => errors(:hashes) })
+    end
+
+    def self.decode payload
+      begin
+        self.new BERT.decode(payload)
+      rescue StandardError => e
+        raise e unless e.message =~ /bad magic/i
+        Emissary.logger.error "Unable to decode message - maybe it wasn't encoded with BERT..?"
+        raise ::Emissary::Error::InvalidMessageFormat, "Unable to decode message - maybe it wasn't encoded with BERT? Message: #{payload.inspect}"
+      end
+    end
+
+    def stamp_sent!
+      time[:sent] = Time.now.to_f
+      self
+    end
+    
+    def stamp_received!
+      time[:received] = Time.now.to_f
+      self
+    end
+    
+    def trip_time
+      (time[:sent].to_f - time[:received].to_f rescue 0.0) || 0.0
+    end
+    
+    def response
+      header = {
+        :recipient => replyto || sender,
+        :status    => [ :ok, '' ],
+        :operation => operation,
+        :thread    => thread,
+        :time      => {
+          :received => nil,
+          :sent     => nil
+        }
+      }
+      return Message.new({ :headers => header, :data => data, :errors => errors(:hashes) })
+    end
+
+    def bounce(message = nil)
+      message ||= 'Message failed due to missing handler.'
+      bounced = self.response
+      bounced.status = [ :bounced, message ] 
+      return bounced
+    end
+
+    def error(message = nil)
+      message ||= 'Message failed due to unspecified error.'
+      error = self.response
+      error.status = [ :errored, message.to_s ]
+      if message.is_a? Exception
+        error.errors << message
+      else
+        ::Emissary.logger.warning "#{message.class.name} is not an exception..."
+      end
+      return error
+    end
+  end
+end