emissary 1.3.0

data/lib/emissary/identity/ec2.rb

@@ -0,0 +1,64 @@
+#   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 'net/http'
+require 'socket'
+
+module Emissary
+  class Identity::Ec2 < Identity
+    register :ec2, :priority => 25
+
+    QUERY_IP         = '169.254.169.254'
+    INSTANCE_ID_PATH = '/latest/meta-data/instance-id'
+    LOCAL_IPV4_PATH  = '/latest/meta-data/local-ipv4'
+    PUBLIC_IPV4_PATH = '/latest/meta-data/public-ipv4'
+
+    def initialize
+      @instance_id = nil
+      @local_ipv4  = nil
+      @public_ipv4 = nil
+    end
+    
+    def instance_id
+      @instance_id ||= get(INSTANCE_ID_PATH)
+    end
+
+    alias :queue_name :instance_id
+    
+    def local_ip
+      @local_ipv4 ||= get(LOCAL_IPV4_PATH)
+    end
+
+    def public_ip
+      @public_ipv4 ||= get(PUBLIC_IPV4_PATH)
+    end
+    
+    private
+    
+    def get uri
+      begin
+        http = Net::HTTP.new(QUERY_IP)
+        http.open_timeout = 0.5 
+        http.read_timeout = 0.5
+        http.start do |http|
+          http.get(uri).body
+        end
+      rescue Exception => e
+        ::Emissary.logger.debug "Passing identifier request to next identity handler due to failed HTTP#get request: #{e.class.name}: #{e.message}"
+        throw :pass
+      end
+    end
+  end
+end

data/lib/emissary/identity/unix.rb

@@ -0,0 +1,67 @@
+#   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.
+#
+#
+module Emissary
+  class Identity::Unix < Identity
+    # defaults to priority 0 (which means, it's the last option if nothing else takes it)
+    register :unix 
+
+    def name
+      @hostname ||= `hostname`.strip
+    end
+
+    alias :queue_name :name
+
+    def roles
+      ENV['ROLES'] || ''
+    end
+    
+    def instance_id
+      ENV['INSTANCE_ID'] || -1
+    end
+    
+    def server_id
+      ENV['SERVER_ID'] || -1
+    end
+    
+    def cluster_id
+      ENV['CLUSTER_ID'] || -1
+    end
+
+    def account_id
+      ENV['ACCOUNT_ID'] || -1
+    end
+    
+    def local_ip
+      @ip_local ||= begin
+        # turn off reverse DNS resolution temporarily
+        orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  
+        @ip_local = UDPSocket.open { |s| s.connect IP_CHECK_DOMAIN, 1; s.addr.last }
+      rescue
+        nil
+      ensure
+        Socket.do_not_reverse_lookup = orig rescue nil
+      end
+    end
+  
+    def public_ip
+      @ip_public ||= begin
+        Net::HTTP.get(URI.parse(IP_CHECK_URL)).gsub(/.*?((\d{1,3}\.){3}\d{1,3}).*/m, '\1')
+      rescue
+        nil
+      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.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])
+        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