celldee-bunny 0.0.1

data/README.markdown

@@ -0,0 +1,43 @@
+# bunny README
+
+This project was started to enable me to interact with RabbitMQ using Ruby. It has borrowed heavily from two projects:
+ 
+1. **amqp** by *tmm1* (http://github.com/tmm1/amqp/tree/master)
+2. **carrot** by *famoseagle* (http://github.com/famoseagle/carrot/tree/master)
+ 
+I will be creating tests, examples and generally tinkering, so please bear with me.
+ 
+## Quick Start
+
+    require 'bunny'
+
+    b = Bunny.new(:logging => true)
+
+    # start a communication session with the amqp server
+    begin
+      b.start
+    rescue Exception => e
+      puts 'ERROR - Could not start a session: ' + e
+      exit
+    end
+
+    # declare a queue
+    q = Queue.new(b.client, 'test1')
+
+    # create a direct exchange
+    exchange = Exchange.new(b.client, :direct, 'test_ex')
+
+    # bind the queue to the exchange
+    q.bind(exchange)
+
+    # publish a message to the exchange
+    exchange.publish('Hello everybody!')
+
+    # get message from the queue
+    msg = q.pop
+
+    puts 'This is the message: ' + msg + "\n\n"
+
+## LICENSE
+
+Copyright (c) 2009 Chris Duncan; Published under The MIT License, see License

data/Rakefile

@@ -0,0 +1,12 @@
+task :codegen do
+  sh 'ruby protocol/codegen.rb > lib/amqp/spec.rb'
+	sh 'ruby lib/amqp/spec.rb'
+end
+
+task :spec do
+	require 'spec/rake/spectask'
+	Spec::Rake::SpecTask.new do |t|
+		t.spec_opts = ['--color']
+	end
+end
+	

data/examples/simple.rb

@@ -0,0 +1,30 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'bunny'
+
+b = Bunny.new(:logging => true)
+
+# start a communication session with the amqp server
+begin
+	b.start
+rescue Exception => e
+	puts 'ERROR - Could not start a session: ' + e
+	exit
+end
+
+# declare a queue
+q = Queue.new(b.client, 'test1')
+
+# create a direct exchange
+exchange = Exchange.new(b.client, :direct, 'test_ex')
+
+# bind the queue to the exchange
+q.bind(exchange)
+
+# publish a message to the exchange
+exchange.publish('Hello everybody!')
+
+# get message from the queue
+msg = q.pop
+
+puts 'This is the message: ' + msg + "\n\n"

data/lib/amqp/buffer.rb

@@ -0,0 +1,276 @@
+if [].map.respond_to? :with_index
+  class Array #:nodoc:
+    def enum_with_index
+      each.with_index
+    end
+  end
+else
+  require 'enumerator'
+end
+
+module AMQP
+  class Buffer #:nodoc: all
+    class Overflow < StandardError; end
+    class InvalidType < StandardError; 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 83 # 'S'
+                         table.read(:longstr)
+                       when 73 # 'I'
+                         table.read(:long)
+                       when 68 # 'D'
+                         exp = table.read(:octet)
+                         num = table.read(:long)
+                         num / 10.0**exp
+                       when 84 # 'T'
+                         table.read(:timestamp)
+                       when 70 # '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, 83) # 'S'
+                            table.write(:longstr, value.to_s)
+                          when Fixnum
+                            table.write(:octet, 73) # 'I'
+                            table.write(:long, value)
+                          when Float
+                            table.write(:octet, 68) # 'D'
+                            # XXX there's gotta be a better way to do this..
+                            exp = value.to_s.split('.').last.length
+                            num = value * 10**exp
+                            table.write(:octet, exp)
+                            table.write(:long, num)
+                          when Time
+                            table.write(:octet, 84) # 'T'
+                            table.write(:timestamp, value)
+                          when Hash
+                            table.write(:octet, 70) # '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 @data.is_a?(Client)
+        raw = @data.read(size)
+        return raw if raw.nil? or pack.nil? 
+        return raw.unpack(pack).first
+      end
+
+      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

data/lib/amqp/client.rb

@@ -0,0 +1,160 @@
+module AMQP
+  class Client
+    CONNECT_TIMEOUT = 1.0
+    RETRY_DELAY     = 10.0
+
+    attr_reader   :status
+    attr_accessor :channel, :host, :logging, :port, :ticket
+
+    class ServerDown      < StandardError; end
+    class ProtocolError   < StandardError; end
+
+    def initialize(opts = {})
+			@host = opts[:host] || 'localhost'
+			@port = opts[:port] || AMQP::PORT
+      @user   = opts[:user]  || 'guest'
+      @pass   = opts[:pass]  || 'guest'
+      @vhost  = opts[:vhost] || '/'
+			@logging = opts[:logging] || false
+      @insist = opts[:insist]
+      @status = 'NOT CONNECTED'
+    end
+
+    def send_frame(*args)
+      args.each do |data|
+        data.ticket  = ticket if ticket and data.respond_to?(:ticket=)
+        data         = data.to_frame(channel) unless data.is_a?(Frame)
+        data.channel = channel
+
+        log :send, data
+        write(data.to_s)
+      end
+      nil
+    end
+
+    def next_frame
+      frame = Frame.parse(buffer)
+      log :received, frame
+      frame
+    end
+
+    def next_method
+      next_payload
+    end
+
+    def next_payload
+      frame = next_frame
+      frame and frame.payload
+    end
+
+    def close
+      send_frame(
+        Protocol::Channel::Close.new(:reply_code => 200, :reply_text => 'bye', :method_id => 0, :class_id => 0)
+      )
+      puts "Error closing channel #{channel}" unless next_method.is_a?(Protocol::Channel::CloseOk)
+
+      self.channel = 0
+      send_frame(
+        Protocol::Connection::Close.new(:reply_code => 200, :reply_text => 'Goodbye', :class_id => 0, :method_id => 0)
+      )
+      puts "Error closing connection" unless next_method.is_a?(Protocol::Connection::CloseOk)
+
+      close_socket
+    end
+
+    def read(*args)
+      send_command(:read, *args)
+    end
+
+    def write(*args)
+      send_command(:write, *args)
+    end
+
+		def start_session
+      @channel = 0
+      write(HEADER)
+      write([1, 1, VERSION_MAJOR, VERSION_MINOR].pack('C4'))
+      raise ProtocolError, 'bad start connection' unless next_method.is_a?(Protocol::Connection::Start)
+
+      send_frame(
+        Protocol::Connection::StartOk.new(
+          {:platform => 'Ruby', :product => 'Bunny', :information => 'http://github.com/celldee/bunny', :version => VERSION},
+          'AMQPLAIN',
+          {:LOGIN => @user, :PASSWORD => @pass},
+          'en_US'
+        )
+      )
+
+      if next_method.is_a?(Protocol::Connection::Tune)
+        send_frame(
+          Protocol::Connection::TuneOk.new( :channel_max => 0, :frame_max => 131072, :heartbeat => 0)
+        )
+      end
+
+      send_frame(
+        Protocol::Connection::Open.new(:virtual_host => @vhost, :capabilities => '', :insist => @insist)
+      )
+      raise ProtocolError, 'Cannot open connection' unless next_method.is_a?(Protocol::Connection::OpenOk)
+
+      @channel = 1
+      send_frame(Protocol::Channel::Open.new)
+      raise ProtocolError, "Cannot open channel #{channel}" unless next_method.is_a?(Protocol::Channel::OpenOk)
+
+      send_frame(
+        Protocol::Access::Request.new(:realm => '/data', :read => true, :write => true, :active => true, :passive => true)
+      )
+      method = next_method
+      raise ProtocolError, 'Access denied' unless method.is_a?(Protocol::Access::RequestOk)
+      self.ticket = method.ticket
+    end
+
+  private
+
+    def buffer
+      @buffer ||= Buffer.new(self)
+    end
+
+    def send_command(cmd, *args)
+      begin
+        socket.__send__(cmd, *args)
+      rescue Errno::EPIPE, IOError => e
+        raise ServerDown, e.message
+      end
+    end
+
+    def socket
+      return @socket if @socket and not @socket.closed?
+
+      begin
+        # Attempt to connect.
+        @socket = timeout(CONNECT_TIMEOUT) do
+          TCPSocket.new(host, port)
+        end
+
+        if Socket.constants.include? 'TCP_NODELAY'
+          @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+        end
+        @status   = 'CONNECTED'
+      rescue SocketError, SystemCallError, IOError, Timeout::Error => e
+        raise ServerDown, e.message
+      end
+
+      @socket
+    end
+
+    def close_socket(reason=nil)
+      # Close the socket. The server is not considered dead.
+      @socket.close if @socket and not @socket.closed?
+      @socket   = nil
+      @status   = "NOT CONNECTED"
+    end
+
+    def log(*args)
+      return unless logging
+      require 'pp'
+      pp args
+      puts
+    end
+
+  end
+end

data/lib/amqp/frame.rb

@@ -0,0 +1,62 @@
+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