adamh-amqp 0.6.3.1

data/lib/amqp/client.rb

@@ -0,0 +1,210 @@
+require 'amqp/frame'
+
+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 => 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
+      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')
+    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
+
+    #:stopdoc:
+    # def send_data data
+    #   log 'send_data', data
+    #   super
+    # end
+    #:startdoc:
+
+    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,124 @@
+require 'amqp/spec'
+require 'amqp/buffer'
+require 'amqp/protocol'
+
+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
+
+if $0 =~ /bacon/ or $0 == __FILE__
+  require 'bacon'
+  include AMQP
+
+  describe Frame do
+    should 'handle basic frame types' do
+      Frame::Method.new.id.should == 1
+      Frame::Header.new.id.should == 2
+      Frame::Body.new.id.should == 3
+    end
+
+    should 'convert method frames to binary' do
+      meth = Protocol::Connection::Secure.new :challenge => 'secret'
+
+      frame = Frame::Method.new(meth)
+      frame.to_binary.should.be.kind_of? Buffer
+      frame.to_s.should == [ 1, 0, meth.to_s.length, meth.to_s, 206 ].pack('CnNa*C')
+    end
+
+    should 'convert binary to method frames' do
+      orig = Frame::Method.new Protocol::Connection::Secure.new(:challenge => 'secret')
+
+      copy = Frame.parse(orig.to_binary)
+      copy.should == orig
+    end
+
+    should 'ignore partial frames until ready' do
+      frame = Frame::Method.new Protocol::Connection::Secure.new(:challenge => 'secret')
+      data = frame.to_s
+
+      buf = Buffer.new
+      Frame.parse(buf).should == nil
+      
+      buf << data[0..5]
+      Frame.parse(buf).should == nil
+      
+      buf << data[6..-1]
+      Frame.parse(buf).should == frame
+      
+      Frame.parse(buf).should == nil
+    end
+
+    should 'convert header frames to binary' do
+      head = Protocol::Header.new(Protocol::Basic, :priority => 1)
+      
+      frame = Frame::Header.new(head)
+      frame.to_s.should == [ 2, 0, head.to_s.length, head.to_s, 206 ].pack('CnNa*C')
+    end
+
+    should 'convert binary to header frame' do
+      orig = Frame::Header.new Protocol::Header.new(Protocol::Basic, :priority => 1)
+      
+      copy = Frame.parse(orig.to_binary)
+      copy.should == orig
+    end
+  end
+end

data/lib/amqp/protocol.rb

@@ -0,0 +1,212 @@
+require 'amqp/spec'
+require 'amqp/buffer'
+
+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.amqp_parent.amqp_id
+        buf.write :short, self.class.amqp_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.amqp_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
+
+if $0 =~ /bacon/ or $0 == __FILE__
+  require 'bacon'
+  include AMQP
+
+  describe Protocol do
+    should 'instantiate methods with arguments' do
+      meth = Protocol::Connection::StartOk.new nil, 'PLAIN', nil, 'en_US'
+      meth.locale.should == 'en_US'
+    end
+
+    should 'instantiate methods with named parameters' do
+      meth = Protocol::Connection::StartOk.new :locale => 'en_US',
+                                               :mechanism => 'PLAIN'
+      meth.locale.should == 'en_US'
+    end
+
+    should 'convert methods to binary' do
+      meth = Protocol::Connection::Secure.new :challenge => 'secret'
+      meth.to_binary.should.be.kind_of? Buffer
+
+      meth.to_s.should == [ 10, 20, 6, 'secret' ].pack('nnNa*')
+    end
+
+    should 'convert binary to method' do
+      orig = Protocol::Connection::Secure.new :challenge => 'secret'
+      copy = Protocol.parse orig.to_binary
+      orig.should == copy
+    end
+
+    should 'convert headers to binary' do
+      head = Protocol::Header.new Protocol::Basic,
+                                  size = 5,
+                                  weight = 0,
+                                  :content_type => 'text/json',
+                                  :delivery_mode => 1,
+                                  :priority => 1
+      head.to_s.should == [ 60, weight, 0, size, 0b1001_1000_0000_0000, 9, 'text/json', 1, 1 ].pack('nnNNnCa*CC')
+    end
+
+    should 'convert binary to header' do
+      orig = Protocol::Header.new Protocol::Basic,
+                                  size = 5,
+                                  weight = 0,
+                                  :content_type => 'text/json',
+                                  :delivery_mode => 1,
+                                  :priority => 1
+      Protocol::Header.new(orig.to_binary).should == orig
+    end
+  end
+end