sa-carrot 0.7.1

data/lib/amqp/exchange.rb

@@ -0,0 +1,51 @@
+module Carrot::AMQP
+  class Exchange
+    attr_reader :server, :type, :name, :opts, :key, :carrot
+
+    def initialize(carrot, type, name, opts = {})
+      @server, @type, @name, @opts = carrot.server, type, name, opts
+      @key = opts[:key]
+      @carrot = carrot
+
+      unless name == "amq.#{type}" or name == ''
+        server.send_frame(
+          Protocol::Exchange::Declare.new(
+            { :exchange => name, :type => type, :nowait => true }.merge(opts)
+          )
+        )
+      end
+    end
+    attr_reader :name, :type, :key
+
+    def publish(data, opts = {})
+      out = []
+
+      out << Protocol::Basic::Publish.new(
+        { :exchange => name, :routing_key => opts.delete(:key) || key }.merge(opts)
+      )
+      data = data.to_s
+      out << Protocol::Header.new(
+        Protocol::Basic,
+        data.length, {
+          :content_type  => 'application/octet-stream',
+          :delivery_mode => (opts.delete(:persistent) ? 2 : 1),
+          :priority      => 0 
+        }.merge(opts)
+      )
+      out << Frame::Body.new(data)
+
+      server.send_frame(*out)
+    end
+
+    def delete(opts = {})
+      server.send_frame(
+        Protocol::Exchange::Delete.new({ :exchange => name, :nowait => true }.merge(opts))
+      )
+      carrot.exchanges.delete(name)
+    end
+
+    def reset
+      initialize(server, type, name, opts)
+    end
+  end
+end

data/lib/amqp/frame.rb

@@ -0,0 +1,121 @@
+module Carrot::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 'rubygems'
+  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/header.rb

@@ -0,0 +1,27 @@
+module Carrot::AMQP
+  class Header
+    def initialize(server, header_obj)
+      @server = server
+      @header = header_obj
+    end
+
+    # Acknowledges the receipt of this message with the server.
+    def ack
+      @server.send(Protocol::Basic::Ack.new(:delivery_tag => properties[:delivery_tag]))
+    end
+
+    # Reject this message (XXX currently unimplemented in rabbitmq)
+    # * :requeue => true | false (default false)
+    def reject(opts = {})
+      @server.send(Protocol::Basic::Reject.new(opts.merge(:delivery_tag => properties[:delivery_tag])))
+    end
+
+    def method_missing(meth, *args, &blk)
+      @header.send(meth, *args, &blk)
+    end
+
+    def inspect
+      @header.inspect
+    end
+  end
+end

data/lib/amqp/protocol.rb

@@ -0,0 +1,209 @@
+module Carrot::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.parent.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
+
+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

data/lib/amqp/queue.rb

@@ -0,0 +1,97 @@
+module Carrot::AMQP
+  class Queue
+    attr_reader :name, :server, :carrot
+    attr_accessor :delivery_tag
+
+    def initialize(carrot, name, opts = {})
+      @server = carrot.server
+      @opts   = opts
+      @name   = name
+      @carrot = carrot
+      server.send_frame(
+        Protocol::Queue::Declare.new({ :queue => name, :nowait => true }.merge(opts))
+      )
+    end
+
+    def pop(opts = {})
+      self.delivery_tag = nil
+      server.send_frame(
+        Protocol::Basic::Get.new({ :queue => name, :consumer_tag => name, :no_ack => !opts.delete(:ack), :nowait => true }.merge(opts))
+      )
+      method = server.next_method
+      return unless method.is_a?(Protocol::Basic::GetOk)
+
+      self.delivery_tag = method.delivery_tag
+
+      header = server.next_payload
+
+      msg = ''
+      while msg.length < header.size
+        msg << server.next_payload
+      end
+
+      msg
+    end
+
+    def ack
+      server.send_frame(
+        Protocol::Basic::Ack.new(:delivery_tag => delivery_tag)
+      )
+    end
+
+    def publish(data, opts = {})
+      exchange.publish(data, opts)
+    end
+
+    def message_count
+      status.first
+    end
+
+    def consumer_count
+      status.last
+    end
+    
+    def status(opts = {}, &blk)
+      server.send_frame(
+        Protocol::Queue::Declare.new({ :queue => name, :passive => true }.merge(opts))
+      )
+      method = server.next_method
+      [method.message_count, method.consumer_count]
+    end
+
+    def bind(exchange, opts = {})
+      exchange           = exchange.respond_to?(:name) ? exchange.name : exchange
+      bindings[exchange] = opts
+      server.send_frame(
+        Protocol::Queue::Bind.new({ :queue => name, :exchange => exchange, :routing_key => opts.delete(:key), :nowait => true }.merge(opts))
+      )
+    end
+
+    def unbind(exchange, opts = {})
+      exchange = exchange.respond_to?(:name) ? exchange.name : exchange
+      bindings.delete(exchange)
+
+      server.send_frame(
+        Protocol::Queue::Unbind.new({
+          :queue => name, :exchange => exchange, :routing_key => opts.delete(:key), :nowait => true }.merge(opts)
+        )
+      )
+    end
+
+    def delete(opts = {})
+      server.send_frame(
+        Protocol::Queue::Delete.new({ :queue => name, :nowait => true }.merge(opts))
+      )
+      carrot.queues.delete(name)
+    end
+
+  private
+    def exchange
+      @exchange ||= Exchange.new(carrot, :direct, '', :key => name)
+    end
+
+    def bindings
+      @bindings ||= {}
+    end
+  end
+end