ivanvanderbyl-amqp 0.6.13.1

data/lib/amqp/client.rb

@@ -0,0 +1,225 @@
+require File.expand_path('../frame', __FILE__)
+
+module AMQP
+  class Error < StandardError; end
+
+  module BasicClient
+    def process_frame frame
+      if mq = channels[frame.channel]
+        mq.process_frame(frame)
+        return
+      end
+
+      case frame
+      when Frame::Method
+        case method = frame.payload
+        when Protocol::Connection::Start
+          send Protocol::Connection::StartOk.new({:platform => 'Ruby/EventMachine',
+                                                  :product => 'AMQP',
+                                                  :information => 'http://github.com/tmm1/amqp',
+                                                  :version => VERSION},
+                                                 'AMQPLAIN',
+                                                 {:LOGIN => @settings[:user],
+                                                  :PASSWORD => @settings[:pass]},
+                                                 'en_US')
+
+        when Protocol::Connection::Tune
+          send Protocol::Connection::TuneOk.new(:channel_max => 0,
+                                                :frame_max => 131072,
+                                                :heartbeat => @settings[:heartbeat] || 0)
+
+          send Protocol::Connection::Open.new(:virtual_host => @settings[:vhost],
+                                              :capabilities => '',
+                                              :insist => @settings[:insist])
+
+        when Protocol::Connection::OpenOk
+          succeed(self)
+
+        when Protocol::Connection::Close
+          # raise Error, "#{method.reply_text} in #{Protocol.classes[method.class_id].methods[method.method_id]}"
+          STDERR.puts "#{method.reply_text} in #{Protocol.classes[method.class_id].methods[method.method_id]}"
+
+        when Protocol::Connection::CloseOk
+          @on_disconnect.call if @on_disconnect
+        end
+        
+      when Frame::Heartbeat
+        @last_server_heartbeat = Time.now
+      end
+    end
+  end
+
+  def self.client
+    @client ||= BasicClient
+  end
+
+  def self.client= mod
+    mod.__send__ :include, AMQP
+    @client = mod
+  end
+
+  module Client
+    include EM::Deferrable
+
+    def initialize opts = {}
+      @settings = opts
+      extend AMQP.client
+
+      @on_disconnect ||= proc{ raise Error, "Could not connect to server #{opts[:host]}:#{opts[:port]}" }
+
+      timeout @settings[:timeout] if @settings[:timeout]
+      errback{ @on_disconnect.call } unless @reconnecting
+
+      @connected = false
+    end
+
+    def connection_completed
+      start_tls if @settings[:ssl]
+      log 'connected'
+      # @on_disconnect = proc{ raise Error, 'Disconnected from server' }
+      unless @closing
+        @on_disconnect = method(:disconnected)
+        @reconnecting = false
+      end
+
+      @connected = true
+      @connection_status.call(:connected) if @connection_status
+
+      @buf = Buffer.new
+      send_data HEADER
+      send_data [1, 1, VERSION_MAJOR, VERSION_MINOR].pack('C4')
+      
+      if heartbeat = @settings[:heartbeat]
+        init_heartbeat if (@settings[:heartbeat] = heartbeat.to_i) > 0
+      end
+    end
+    
+    def init_heartbeat
+      @last_server_heartbeat = Time.now
+
+      @timer ||= EM::PeriodicTimer.new(@settings[:heartbeat]) do
+        if connected?
+          if @last_server_heartbeat < (Time.now - (@settings[:heartbeat] * 2))
+            log "Reconnecting due to missing server heartbeats"
+            reconnect(true)
+          else
+            send AMQP::Frame::Heartbeat.new
+          end
+        end
+      end
+    end
+
+    def connected?
+      @connected
+    end
+
+    def unbind
+      log 'disconnected'
+      @connected = false
+      EM.next_tick{ @on_disconnect.call }
+    end
+
+    def add_channel mq
+      (@_channel_mutex ||= Mutex.new).synchronize do
+        channels[ key = (channels.keys.max || 0) + 1 ] = mq
+        key
+      end
+    end
+
+    def channels
+      @channels ||= {}
+    end
+
+    def receive_data data
+      # log 'receive_data', data
+      @buf << data
+
+      while frame = Frame.parse(@buf)
+        log 'receive', frame
+        process_frame frame
+      end
+    end
+
+    def process_frame frame
+      # this is a stub meant to be
+      # replaced by the module passed into initialize
+    end
+
+    def send data, opts = {}
+      channel = opts[:channel] ||= 0
+      data = data.to_frame(channel) unless data.is_a? Frame
+      data.channel = channel
+
+      log 'send', data
+      send_data data.to_s
+    end
+
+    def close &on_disconnect
+      if on_disconnect
+        @closing = true
+        @on_disconnect = proc{
+          on_disconnect.call
+          @closing = false
+        }
+      end
+
+      callback{ |c|
+        if c.channels.any?
+          c.channels.each do |ch, mq|
+            mq.close
+          end
+        else
+          send Protocol::Connection::Close.new(:reply_code => 200,
+                                               :reply_text => 'Goodbye',
+                                               :class_id => 0,
+                                               :method_id => 0)
+        end
+      }
+    end
+
+    def reconnect force = false
+      if @reconnecting and not force
+        # wait 1 second after first reconnect attempt, in between each subsequent attempt
+        EM.add_timer(1){ reconnect(true) }
+        return
+      end
+
+      unless @reconnecting
+        @reconnecting = true
+
+        @deferred_status = nil
+        initialize(@settings)
+
+        mqs = @channels
+        @channels = {}
+        mqs.each{ |_,mq| mq.reset } if mqs
+      end
+
+      log 'reconnecting'
+      EM.reconnect @settings[:host], @settings[:port], self
+    end
+
+    def self.connect opts = {}
+      opts = AMQP.settings.merge(opts)
+      EM.connect opts[:host], opts[:port], self, opts
+    end
+
+    def connection_status &blk
+      @connection_status = blk
+    end
+
+    private
+
+    def disconnected
+      @connection_status.call(:disconnected) if @connection_status
+      reconnect
+    end
+
+    def log *args
+      return unless @settings[:logging] or AMQP.logging
+      require 'pp'
+      pp args
+      puts
+    end
+  end
+end

data/lib/amqp/frame.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../spec', __FILE__)
+require File.expand_path('../buffer', __FILE__)
+require File.expand_path('../protocol', __FILE__)
+
+module AMQP
+  class Frame #:nodoc: all
+    def initialize payload = nil, channel = 0
+      @channel, @payload = channel, payload
+    end
+    attr_accessor :channel, :payload
+
+    def id
+      self.class::ID
+    end
+    
+    def to_binary
+      buf = Buffer.new
+      buf.write :octet, id
+      buf.write :short, channel
+      buf.write :longstr, payload
+      buf.write :octet, FOOTER
+      buf.rewind
+      buf
+    end
+
+    def to_s
+      to_binary.to_s
+    end
+
+    def == frame
+      [ :id, :channel, :payload ].inject(true) do |eql, field|
+        eql and __send__(field) == frame.__send__(field)
+      end
+    end
+    
+    class Invalid < StandardError; end
+    
+    class Method
+      def initialize payload = nil, channel = 0
+        super
+        unless @payload.is_a? Protocol::Class::Method or @payload.nil?
+          @payload = Protocol.parse(@payload)
+        end
+      end
+    end
+
+    class Header
+      def initialize payload = nil, channel = 0
+        super
+        unless @payload.is_a? Protocol::Header or @payload.nil?
+          @payload = Protocol::Header.new(@payload)
+        end
+      end
+    end
+
+    class Body; end
+
+    def self.parse buf
+      buf = Buffer.new(buf) unless buf.is_a? Buffer
+      buf.extract do
+        id, channel, payload, footer = buf.read(:octet, :short, :longstr, :octet)
+        Frame.types[id].new(payload, channel) if footer == FOOTER
+      end
+    end
+  end
+end

data/lib/amqp/protocol.rb

@@ -0,0 +1,161 @@
+require File.expand_path('../spec', __FILE__)
+require File.expand_path('../buffer', __FILE__)
+
+module AMQP
+  module Protocol
+    #:stopdoc:
+    class Class::Method
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+        
+        @debug = 1 # XXX hack, p(obj) == '' if no instance vars are set
+        
+        if args.size == 1 and args.first.is_a? Buffer
+          buf = args.shift
+        else
+          buf = nil
+        end
+
+        self.class.arguments.each do |type, name|
+          val = buf ? buf.read(type) :
+                      args.shift || opts[name] || opts[name.to_s]
+          instance_variable_set("@#{name}", val)
+        end
+      end
+
+      def arguments
+        self.class.arguments.inject({}) do |hash, (type, name)|
+          hash.update name => instance_variable_get("@#{name}")
+        end
+      end
+
+      def to_binary
+        buf = Buffer.new
+        buf.write :short, self.class.section.id
+        buf.write :short, self.class.id
+
+        bits = []
+
+        self.class.arguments.each do |type, name|
+          val = instance_variable_get("@#{name}")
+          if type == :bit
+            bits << (val || false)
+          else
+            unless bits.empty?
+              buf.write :bit, bits
+              bits = []
+            end
+            buf.write type, val
+          end
+        end
+
+        buf.write :bit, bits unless bits.empty?
+        buf.rewind
+
+        buf
+      end
+      
+      def to_s
+        to_binary.to_s
+      end
+      
+      def to_frame channel = 0
+        Frame::Method.new(self, channel)
+      end
+    end
+
+    #:startdoc:
+    #
+    # Contains a properties hash that holds some potentially interesting 
+    # information.
+    # * :delivery_mode
+    # 1 equals transient.
+    # 2 equals persistent. Unconsumed persistent messages will survive
+    # a server restart when they are stored in a durable queue.
+    # * :redelivered
+    # True or False
+    # * :routing_key
+    # The routing string used for matching this message to this queue.
+    # * :priority
+    # An integer in the range of 0 to 9 inclusive.
+    # * :content_type
+    # Always "application/octet-stream" (byte stream)
+    # * :exchange
+    # The source exchange which published this message.
+    # * :message_count
+    # The number of unconsumed messages contained in the queue.
+    # * :delivery_tag
+    # A monotonically increasing integer. This number should not be trusted
+    # as a sequence number. There is no guarantee it won't get reset.
+    class Header
+      def initialize *args
+        opts = args.pop if args.last.is_a? Hash
+        opts ||= {}
+        
+        first = args.shift
+        
+        if first.is_a? ::Class and first.ancestors.include? Protocol::Class
+          @klass = first
+          @size = args.shift || 0
+          @weight = args.shift || 0
+          @properties = opts
+
+        elsif first.is_a? Buffer or first.is_a? String
+          buf = first
+          buf = Buffer.new(buf) unless buf.is_a? Buffer
+          
+          @klass = Protocol.classes[buf.read(:short)]
+          @weight = buf.read(:short)
+          @size = buf.read(:longlong)
+
+          props = buf.read(:properties, *klass.properties.map{|type,_| type })
+          @properties = Hash[*klass.properties.map{|_,name| name }.zip(props).reject{|k,v| v.nil? }.flatten]
+
+        else
+          raise ArgumentError, 'Invalid argument'
+        end
+        
+      end
+      attr_accessor :klass, :size, :weight, :properties
+      
+      def to_binary
+        buf = Buffer.new
+        buf.write :short, klass.id
+        buf.write :short, weight # XXX rabbitmq only supports weight == 0
+        buf.write :longlong, size
+        buf.write :properties, (klass.properties.map do |type, name|
+                                 [ type, properties[name] || properties[name.to_s] ]
+                               end)
+        buf.rewind
+        buf
+      end
+      
+      def to_s
+        to_binary.to_s
+      end
+
+      def to_frame channel = 0
+        Frame::Header.new(self, channel)
+      end
+
+      def == header
+        [ :klass, :size, :weight, :properties ].inject(true) do |eql, field|
+          eql and __send__(field) == header.__send__(field)
+        end
+      end
+
+      def method_missing meth, *args, &blk
+        @properties.has_key?(meth) || @klass.properties.find{|_,name| name == meth } ? @properties[meth] :
+                                                                                       super
+      end
+    end
+
+    def self.parse buf
+      buf = Buffer.new(buf) unless buf.is_a? Buffer
+      class_id, method_id = buf.read(:short, :short)
+      classes[class_id].methods[method_id].new(buf)
+    end
+    #:stopdoc:
+  end
+end