amqp 0.5.0

data/README

@@ -0,0 +1,30 @@
+Simple AMQP client for Ruby/EventMachine.
+
+To use with RabbitMQ, first run the server:
+
+  hg clone http://hg.rabbitmq.com/rabbitmq-codegen
+  hg clone http://hg.rabbitmq.com/rabbitmq-server
+  cd rabbitmq-server
+  make run
+
+Then run the example client:
+
+  ruby examples/simple.rb
+
+To run the specs:
+
+  rake spec
+
+The lib/amqp/spec.rb file is generated automatically based on the AMQP specification. To generate it:
+
+  rake codegen
+
+This project was inspired by py-amqplib, rabbitmq, qpid and rubbyt.
+Special thanks to Dmitriy Samovskiy, Ben Hood and Tony Garnock-Jones.
+
+Other AMQP resources:
+
+  Barry Pederson's py-amqplib: http://barryp.org/software/py-amqplib/
+  Ben Hood's article on writing an AMQP article: http://hopper.squarespace.com/blog/2008/6/21/build-your-own-amqp-client.html
+  Dmitriy Samovskiy's introduction to ruby+rabbitmq: http://somic-org.homelinux.org/blog/2008/06/24/ruby-amqp-rabbitmq-example/
+  Ben Hood's AMQP client in AS3: http://github.com/0x6e6562/as3-amqp

data/examples/clock.rb

@@ -0,0 +1,53 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'mq'
+
+EM.run{
+
+  def log *args
+    p args
+  end
+
+  # AMQP.logging = true
+
+  EM.add_periodic_timer(1){
+    puts
+
+    log :publishing, time = Time.now
+    MQ.new.fanout('clock').publish(Marshal.dump(time))
+  }
+
+  MQ.new.queue('every second').bind('clock').subscribe{ |time|
+    log 'every second', :received, Marshal.load(time)
+  }
+
+  MQ.new.queue('every 5 seconds').bind('clock').subscribe{ |time|
+    time = Marshal.load(time)
+    log 'every 5 seconds', :received, time if time.strftime('%S').to_i%5 == 0
+  }
+
+}
+
+__END__
+
+[:publishing, Thu Jul 17 20:14:00 -0700 2008]
+["every 5 seconds", :received, Thu Jul 17 20:14:00 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:00 -0700 2008]
+
+[:publishing, Thu Jul 17 20:14:01 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:01 -0700 2008]
+
+[:publishing, Thu Jul 17 20:14:02 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:02 -0700 2008]
+
+[:publishing, Thu Jul 17 20:14:03 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:03 -0700 2008]
+
+[:publishing, Thu Jul 17 20:14:04 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:04 -0700 2008]
+
+[:publishing, Thu Jul 17 20:14:05 -0700 2008]
+["every 5 seconds", :received, Thu Jul 17 20:14:05 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:05 -0700 2008]
+
+[:publishing, Thu Jul 17 20:14:06 -0700 2008]
+["every second", :received, Thu Jul 17 20:14:06 -0700 2008]

data/examples/hashtable.rb

@@ -0,0 +1,52 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'mq'
+
+EM.run{
+
+  def log *args
+    p args
+  end
+
+  # AMQP.logging = true
+
+  class HashTable < Hash
+    def get key
+      log 'HashTable', :get, key
+      self[key]
+    end
+    
+    def set key, value
+      log 'HashTable', :set, key => value
+      self[key] = value
+    end
+
+    def keys
+      log 'HashTable', :keys
+      super
+    end
+  end
+
+  server = MQ.new.rpc('hash table node', HashTable.new)
+
+  client = MQ.new.rpc('hash table node')
+  client.set(:now, time = Time.now)
+  client.get(:now) do |res|
+    log 'client', :now => res, :eql? => res == time
+  end
+
+  client.set(:one, 1)
+  client.keys do |res|
+    log 'client', :keys => res
+    EM.stop_event_loop
+  end
+
+}
+
+__END__
+
+["HashTable", :set, {:now=>Thu Jul 17 21:04:53 -0700 2008}]
+["HashTable", :get, :now]
+["HashTable", :set, {:one=>1}]
+["HashTable", :keys]
+["client", {:eql?=>true, :now=>Thu Jul 17 21:04:53 -0700 2008}]
+["client", {:keys=>[:one, :now]}]

data/examples/pingpong.rb

@@ -0,0 +1,53 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'mq'
+
+EM.run{
+
+  def log *args
+    p [ Time.now, *args ]
+  end
+  
+  # AMQP.logging = true
+
+  amq = MQ.new
+  amq.queue('one').subscribe{ |headers, msg|
+    log 'one', :received, msg, :from => headers.reply_to
+
+    if headers.reply_to
+      msg[1] = 'o'
+
+      log 'one', :sending, msg, :to => headers.reply_to
+      amq.direct.publish(msg, :key => headers.reply_to)
+    else
+      puts
+    end
+  }
+  
+  amq = MQ.new
+  amq.queue('two').subscribe{ |msg|
+    log 'two', :received, msg
+    puts
+  }
+
+  amq = MQ.new
+  amq.direct.publish('ding', :key => 'one')
+  EM.add_periodic_timer(1){
+    log :sending, 'ping', :to => 'one', :from => 'two'
+    amq.direct.publish('ping', :key => 'one', :reply_to => 'two')
+  }
+
+}
+
+__END__
+
+[Thu Jul 17 21:23:55 -0700 2008, "one", :received, "ding", {:from=>nil}]
+
+[Thu Jul 17 21:23:56 -0700 2008, :sending, "ping", {:from=>"two", :to=>"one"}]
+[Thu Jul 17 21:23:56 -0700 2008, "one", :received, "ping", {:from=>"two"}]
+[Thu Jul 17 21:23:56 -0700 2008, "one", :sending, "pong", {:to=>"two"}]
+[Thu Jul 17 21:23:56 -0700 2008, "two", :received, "pong"]
+
+[Thu Jul 17 21:23:57 -0700 2008, :sending, "ping", {:from=>"two", :to=>"one"}]
+[Thu Jul 17 21:23:57 -0700 2008, "one", :received, "ping", {:from=>"two"}]
+[Thu Jul 17 21:23:57 -0700 2008, "one", :sending, "pong", {:to=>"two"}]
+[Thu Jul 17 21:23:57 -0700 2008, "two", :received, "pong"]

data/examples/simple.rb

@@ -0,0 +1,77 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'amqp'
+
+module SimpleClient
+  def process_frame frame
+    case frame
+    when Frame::Body
+      EM.stop_event_loop
+
+    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 => '0.1.0'},
+                                               'AMQPLAIN',
+                                               {:LOGIN => 'guest',
+                                                :PASSWORD => 'guest'},
+                                               '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 => '/',
+                                            :capabilities => '',
+                                            :insist => false)
+
+      when Protocol::Connection::OpenOk
+        send Protocol::Channel::Open.new, :channel => 1
+
+      when Protocol::Channel::OpenOk
+        send Protocol::Access::Request.new(:realm => '/data',
+                                           :read => true,
+                                           :write => true,
+                                           :active => true), :channel => 1
+
+      when Protocol::Access::RequestOk
+        @ticket = method.ticket
+        send Protocol::Queue::Declare.new(:ticket => @ticket,
+                                          :queue => '',
+                                          :exclusive => false,
+                                          :auto_delete => true), :channel => 1
+
+      when Protocol::Queue::DeclareOk
+        @queue = method.queue
+        send Protocol::Queue::Bind.new(:ticket => @ticket,
+                                       :queue => @queue,
+                                       :exchange => '',
+                                       :routing_key => 'test_route'), :channel => 1
+
+      when Protocol::Queue::BindOk
+        send Protocol::Basic::Consume.new(:ticket => @ticket,
+                                          :queue => @queue,
+                                          :no_local => false,
+                                          :no_ack => true), :channel => 1
+
+      when Protocol::Basic::ConsumeOk
+        data = "this is a test!"
+
+        send Protocol::Basic::Publish.new(:ticket => @ticket,
+                                          :exchange => '',
+                                          :routing_key => 'test_route'), :channel => 1
+        send Protocol::Header.new(Protocol::Basic, data.length, :content_type => 'application/octet-stream',
+                                                                :delivery_mode => 1,
+                                                                :priority => 0), :channel => 1
+        send Frame::Body.new(data), :channel => 1
+      end
+    end
+  end
+end
+
+AMQP.logging = true
+AMQP.client = SimpleClient
+AMQP.start

data/examples/stocks.rb

@@ -0,0 +1,56 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'mq'
+
+EM.run{
+
+  def log *args
+    p [ Time.now, *args ]
+  end
+
+  # AMQP.logging = true
+
+  EM.add_periodic_timer(1){
+    puts
+
+    log :publishing, 'stock.usd.appl', price = 170+rand(1000)/100.0
+    MQ.topic(:key => 'stock.usd.appl').publish(price, :headers => {:symbol => 'appl'})
+
+    log :publishing, 'stock.usd.msft', price = 22+rand(500)/100.0
+    MQ.topic.publish(price, :key => 'stock.usd.msft', :headers => {:symbol => 'msft'})
+  }
+
+  Thread.new{
+    amq = MQ.new
+    amq.queue('apple stock').bind(amq.topic, :key => 'stock.usd.appl').subscribe{ |price|
+      log 'apple stock', price
+    }
+  }
+
+  Thread.new{
+    amq = MQ.new
+    amq.queue('us stocks').bind(amq.topic, :key => 'stock.usd.*').subscribe{ |info, price|
+      log 'us stock', info.headers[:symbol], price
+    }
+  }
+
+}
+
+__END__
+
+[Thu Jul 17 14:51:07 -0700 2008, :publishing, "stock.usd.appl", 170.84]
+[Thu Jul 17 14:51:07 -0700 2008, :publishing, "stock.usd.msft", 23.68]
+[Thu Jul 17 14:51:07 -0700 2008, "apple stock", "170.84"]
+[Thu Jul 17 14:51:07 -0700 2008, "us stock", "appl", "170.84"]
+[Thu Jul 17 14:51:07 -0700 2008, "us stock", "msft", "23.68"]
+
+[Thu Jul 17 14:51:08 -0700 2008, :publishing, "stock.usd.appl", 173.61]
+[Thu Jul 17 14:51:08 -0700 2008, :publishing, "stock.usd.msft", 25.8]
+[Thu Jul 17 14:51:08 -0700 2008, "apple stock", "173.61"]
+[Thu Jul 17 14:51:08 -0700 2008, "us stock", "appl", "173.61"]
+[Thu Jul 17 14:51:08 -0700 2008, "us stock", "msft", "25.8"]
+
+[Thu Jul 17 14:51:09 -0700 2008, :publishing, "stock.usd.appl", 173.94]
+[Thu Jul 17 14:51:09 -0700 2008, :publishing, "stock.usd.msft", 24.88]
+[Thu Jul 17 14:51:09 -0700 2008, "apple stock", "173.94"]
+[Thu Jul 17 14:51:09 -0700 2008, "us stock", "appl", "173.94"]
+[Thu Jul 17 14:51:09 -0700 2008, "us stock", "msft", "24.88"]

data/lib/amqp.rb

@@ -0,0 +1,14 @@
+module AMQP
+  DIR = File.expand_path(File.dirname(File.expand_path(__FILE__)))
+  
+  $:.unshift DIR
+  
+  %w[ buffer spec protocol frame client ].each do |file|
+    require "amqp/#{file}"
+  end
+
+  class << self
+    @logging = false
+    attr_accessor :logging
+  end
+end

data/lib/amqp/buffer.rb

@@ -0,0 +1,387 @@
+require 'enumerator'
+
+module AMQP
+  class Buffer
+    class Overflow < Exception; end
+    class InvalidType < Exception; end
+    
+    def initialize data = ''
+      @data = data
+      @pos = 0
+    end
+
+    attr_reader :pos
+    
+    def data
+      @data.clone
+    end
+    alias :contents :data
+    alias :to_s :data
+
+    def << data
+      @data << data.to_s
+      self
+    end
+    
+    def length
+      @data.length
+    end
+    
+    def empty?
+      pos == length
+    end
+    
+    def rewind
+      @pos = 0
+    end
+    
+    def read_properties *types
+      types.shift if types.first == :properties
+      
+      i = 0
+      values = []
+
+      while props = read(:short)
+        (0..14).each do |n|
+          # no more property types
+          break unless types[i]
+          
+          # if flag is set
+          if props & (1<<(15-n)) != 0
+            if types[i] == :bit
+              # bit values exist in flags only
+              values << true
+            else
+              # save type name for later reading
+              values << types[i]
+            end
+          else
+            # property not set or is false bit
+            values << (types[i] == :bit ? false : nil)
+          end
+
+          i+=1
+        end
+
+        # bit(0) == 0 means no more property flags
+        break unless props & 1 == 1
+      end
+
+      values.map do |value|
+        value.is_a?(Symbol) ? read(value) : value
+      end
+    end
+
+    def read *types
+      if types.first == :properties
+        return read_properties(*types)
+      end
+
+      values = types.map do |type|
+        case type
+        when :octet
+          _read(1, 'C')
+        when :short
+          _read(2, 'n')
+        when :long
+          _read(4, 'N')
+        when :longlong
+          upper, lower = _read(8, 'NN')
+          upper << 32 | lower
+        when :shortstr
+          _read read(:octet)
+        when :longstr
+          _read read(:long)
+        when :timestamp
+          Time.at read(:longlong)
+        when :table
+          t = Hash.new
+
+          table = Buffer.new(read(:longstr))
+          until table.empty?
+            key, type = table.read(:shortstr, :octet)
+            key = key.intern
+            t[key] ||= case type
+                       when ?S
+                         table.read(:longstr)
+                       when ?I
+                         table.read(:long)
+                       when ?D
+                         exp = table.read(:octet)
+                         num = table.read(:long)
+                         num / 10.0**exp
+                       when ?T
+                         table.read(:timestamp)
+                       when ?F
+                         table.read(:table)
+                       end
+          end
+
+          t
+        when :bit
+          if (@bits ||= []).empty?
+            val = read(:octet)
+            @bits = (0..7).map{|i| (val & 1<<i) != 0 }
+          end
+
+          @bits.shift
+        else
+          raise InvalidType, "Cannot read data of type #{type}"
+        end
+      end
+      
+      types.size == 1 ? values.first : values
+    end
+    
+    def write type, data
+      case type
+      when :octet
+        _write(data, 'C')
+      when :short
+        _write(data, 'n')
+      when :long
+        _write(data, 'N')
+      when :longlong
+        lower =  data & 0xffffffff
+        upper = (data & ~0xffffffff) >> 32
+        _write([upper, lower], 'NN')
+      when :shortstr
+        data = (data || '').to_s
+        _write([data.length, data], 'Ca*')
+      when :longstr
+        if data.is_a? Hash
+          write(:table, data)
+        else
+          data = (data || '').to_s
+          _write([data.length, data], 'Na*')
+        end
+      when :timestamp
+        write(:longlong, data.to_i)
+      when :table
+        data ||= {}
+        write :longstr, (data.inject(Buffer.new) do |table, (key, value)|
+                          table.write(:shortstr, key.to_s)
+
+                          case value
+                          when String
+                            table.write(:octet, ?S)
+                            table.write(:longstr, value.to_s)
+                          when Fixnum
+                            table.write(:octet, ?I)
+                            table.write(:long, value)
+                          when Float
+                            table.write(:octet, ?D)
+                            # XXX there's gotta be a better way to do this..
+                            exp = value.to_s.gsub(/^.+\./,'').length
+                            num = value * 10**exp
+                            table.write(:octet, exp)
+                            table.write(:long, num)
+                          when Time
+                            table.write(:octet, ?T)
+                            table.write(:timestamp, value)
+                          when Hash
+                            table.write(:octet, ?F)
+                            table.write(:table, value)
+                          end
+
+                          table
+                        end)
+      when :bit
+        [*data].to_enum(:each_slice, 8).each{|bits|
+          write(:octet, bits.enum_with_index.inject(0){ |byte, (bit, i)|
+            byte |= 1<<i if bit
+            byte
+           })
+         }
+      when :properties
+        values = []
+        data.enum_with_index.inject(0) do |short, ((type, value), i)|
+          n = i % 15
+          last = i+1 == data.size
+
+          if (n == 0 and i != 0) or last
+            if data.size > i+1
+              short |= 1<<0
+            elsif last and value
+              values << [type,value]
+              short |= 1<<(15-n)
+            end
+
+            write(:short, short)
+            short = 0
+          end
+
+          if value and !last
+            values << [type,value] 
+            short |= 1<<(15-n)
+          end
+
+          short
+        end
+        
+        values.each do |type, value|
+          write(type, value) unless type == :bit
+        end
+      else
+        raise InvalidType, "Cannot write data of type #{type}"
+      end
+      
+      self
+    end
+
+    def extract
+      begin
+        cur_data, cur_pos = @data.clone, @pos
+        yield self
+      rescue Overflow
+        @data, @pos = cur_data, cur_pos
+        nil
+      end
+    end
+
+    def _read size, pack = nil
+      if @pos + size > length
+        raise Overflow
+      else
+        data = @data[@pos,size]
+        @data[@pos,size] = ''
+        if pack
+          data = data.unpack(pack)
+          data = data.pop if data.size == 1
+        end
+        data
+      end
+    end
+    
+    def _write data, pack = nil
+      data = [*data].pack(pack) if pack
+      @data[@pos,0] = data
+      @pos += data.length
+    end
+  end
+end
+
+if $0 =~ /bacon/ or $0 == __FILE__
+  require 'bacon'
+  include AMQP
+
+  describe Buffer do
+    before do
+      @buf = Buffer.new
+    end
+
+    should 'have contents' do
+      @buf.contents.should == ''
+    end
+
+    should 'initialize with data' do
+      @buf = Buffer.new('abc')
+      @buf.contents.should == 'abc'
+    end
+
+    should 'append raw data' do
+      @buf << 'abc'
+      @buf << 'def'
+      @buf.contents.should == 'abcdef'
+    end
+
+    should 'append other buffers' do
+      @buf << Buffer.new('abc')
+      @buf.data.should == 'abc'
+    end
+
+    should 'have a position' do
+      @buf.pos.should == 0
+    end
+
+    should 'have a length' do
+      @buf.length.should == 0
+      @buf << 'abc'
+      @buf.length.should == 3
+    end
+
+    should 'know the end' do
+      @buf.empty?.should == true
+    end
+
+    should 'read and write data' do
+      @buf._write('abc')
+      @buf.rewind
+      @buf._read(2).should == 'ab'
+      @buf._read(1).should == 'c'
+    end
+
+    should 'raise on overflow' do
+      lambda{ @buf._read(1) }.should.raise Buffer::Overflow
+    end
+
+    should 'raise on invalid types' do
+      lambda{ @buf.read(:junk) }.should.raise Buffer::InvalidType
+      lambda{ @buf.write(:junk, 1) }.should.raise Buffer::InvalidType
+    end
+  
+    { :octet => 0b10101010,
+      :short => 100,
+      :long => 100_000_000,
+      :longlong => 666_555_444_333_222_111,
+      :shortstr => 'hello',
+      :longstr => 'bye'*500,
+      :timestamp => time = Time.at(Time.now.to_i),
+      :table => { :this => 'is', :a => 'hash', :with => {:nested => 123, :and => time, :also => 123.456} },
+      :bit => true
+    }.each do |type, value|
+
+      should "read and write a #{type}" do
+        @buf.write(type, value)
+        @buf.rewind
+        @buf.read(type).should == value
+        @buf.should.be.empty
+      end
+
+    end
+    
+    should 'read and write multiple bits' do
+      bits = [true, false, false, true, true, false, false, true, true, false]
+      @buf.write(:bit, bits)
+      @buf.write(:octet, 100)
+      
+      @buf.rewind
+      
+      bits.map do
+        @buf.read(:bit)
+      end.should == bits
+      @buf.read(:octet).should == 100
+    end
+
+    should 'read and write properties' do
+      properties = ([
+        [:octet, 1],
+        [:shortstr, 'abc'],
+        [:bit, true],
+        [:bit, false],
+        [:shortstr, nil],
+        [:timestamp, nil],
+        [:table, { :a => 'hash' }],
+      ]*5).sort_by{rand}
+      
+      @buf.write(:properties, properties)
+      @buf.rewind
+      @buf.read(:properties, *properties.map{|type,_| type }).should == properties.map{|_,value| value }
+      @buf.should.be.empty
+    end
+
+    should 'do transactional reads with #extract' do
+      @buf.write :octet, 8
+      orig = @buf.to_s
+
+      @buf.rewind
+      @buf.extract do |b|
+        b.read :octet
+        b.read :short
+      end
+
+      @buf.pos.should == 0
+      @buf.data.should == orig
+    end
+  end
+end