celldee-bunny 0.0.1

data/lib/amqp.rb

@@ -0,0 +1,5 @@
+module AMQP
+	%w[ spec buffer protocol frame client ].each do |file|
+    require "amqp/#{file}"
+  end
+end

data/lib/bunny/exchange.rb

@@ -0,0 +1,49 @@
+class Exchange
+	
+	include AMQP
+	
+  attr_reader :client, :type, :name, :opts, :key
+
+  def initialize(client, type, name, opts = {})
+    @client, @type, @name, @opts = client, type, name, opts
+    @key = opts[:key]
+
+    unless name == "amq.#{type}" or name == ''
+      client.send_frame(
+        Protocol::Exchange::Declare.new(
+          { :exchange => name, :type => type, :nowait => true }.merge(opts)
+        )
+      )
+    end
+  end
+
+  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)
+
+    client.send_frame(*out)
+  end
+
+  def delete(opts = {})
+    client.send_frame(
+      Protocol::Exchange::Delete.new({ :exchange => name, :nowait => true }.merge(opts))
+    )
+  end
+
+  def reset
+    initialize(client, type, name, opts)
+  end
+end

data/lib/bunny/header.rb

@@ -0,0 +1,30 @@
+class Header
+	
+	include AMQP
+	
+	attr_reader :client
+	
+  def initialize(client, header_obj)
+    @client = client
+    @header = header_obj
+  end
+
+  # Acknowledges the receipt of this message with the server.
+  def ack
+    client.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 = {})
+    client.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

data/lib/bunny/logger.rb

@@ -0,0 +1,89 @@
+class MQ
+  class Logger
+    def initialize *args, &block
+      opts = args.pop if args.last.is_a? Hash
+      opts ||= {}
+
+      printer(block) if block
+
+      @prop = opts
+      @tags = ([:timestamp] + args).uniq
+    end
+
+    attr_reader :prop
+    alias :base :prop
+
+    def log severity, *args
+      opts = args.pop if args.last.is_a? Hash and args.size != 1
+      opts ||= {}
+      opts = @prop.clone.update(opts)
+
+      data = args.shift
+
+      data = {:type => :exception,
+              :name => data.class.to_s.intern,
+              :backtrace => data.backtrace,
+              :message => data.message} if data.is_a? Exception
+
+      (@tags + args).each do |tag|
+        tag = tag.to_sym
+        case tag
+        when :timestamp
+          opts.update :timestamp => Time.now
+        when :hostname
+          @hostname ||= { :hostname => `hostname`.strip }
+          opts.update @hostname
+        when :process
+          @process_id ||= { :process_id => Process.pid,
+                            :process_name => $0,
+                            :process_parent_id => Process.ppid,
+                            :thread_id => Thread.current.object_id }
+          opts.update :process => @process_id
+        else
+          (opts[:tags] ||= []) << tag
+        end
+      end
+
+      opts.update(:severity => severity,
+                  :msg => data)
+
+      print(opts)
+      unless Logger.disabled?
+        MQ.fanout('logging', :durable => true).publish Marshal.dump(opts)
+      end
+
+      opts
+    end
+    alias :method_missing :log
+
+    def print data = nil, &block
+      if block
+        @printer = block
+      elsif data.is_a? Proc
+        @printer = data
+      elsif data
+        (pr = @printer || self.class.printer) and pr.call(data)
+      else
+        @printer
+      end
+    end
+    alias :printer :print
+    
+    def self.printer &block
+      @printer = block if block
+      @printer
+    end
+
+    def self.disabled?
+      !!@disabled
+    end
+    
+    def self.enable
+      @disabled = false
+    end
+    
+    def self.disable
+      @disabled = true
+    end
+  end
+end

data/lib/bunny/queue.rb

@@ -0,0 +1,93 @@
+	class Queue
+		
+		include AMQP
+		
+	  attr_reader :name, :client
+	  attr_accessor :delivery_tag
+
+	  def initialize(client, name, opts = {})
+	    @client = client
+	    @opts   = opts
+	    @name   = name
+	    client.send_frame(
+	      Protocol::Queue::Declare.new({ :queue => name, :nowait => true }.merge(opts))
+	    )
+	  end
+
+	  def pop(opts = {})
+	    self.delivery_tag = nil
+	    client.send_frame(
+	      Protocol::Basic::Get.new({ :queue => name, :consumer_tag => name, :no_ack => !opts.delete(:ack), :nowait => true }.merge(opts))
+	    )
+	    method = client.next_method
+	    return unless method.is_a?(Protocol::Basic::GetOk)
+
+	    self.delivery_tag = method.delivery_tag
+
+	    header = client.next_payload
+	    msg    = client.next_payload
+	    raise 'unexpected length' if msg.length < header.size
+
+	    msg
+	  end
+
+	  def ack
+	    client.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)
+	    client.send_frame(
+	      Protocol::Queue::Declare.new({ :queue => name, :passive => true }.merge(opts))
+	    )
+	    method = client.next_method
+	    [method.message_count, method.consumer_count]
+	  end
+
+	  def bind(exchange, opts = {})
+	    exchange           = exchange.respond_to?(:name) ? exchange.name : exchange
+	    bindings[exchange] = opts
+	    client.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)
+
+	    client.send_frame(
+	      Protocol::Queue::Unbind.new({
+	        :queue => name, :exchange => exchange, :routing_key => opts.delete(:key), :nowait => true }.merge(opts)
+	      )
+	    )
+	  end
+
+	  def delete(opts = {})
+	    client.send_frame(
+	      Protocol::Queue::Delete.new({ :queue => name, :nowait => true }.merge(opts))
+	    )
+	  end
+
+	private
+	  def exchange
+	    @exchange ||= Exchange.new(client, :direct, '', :key => name)
+	  end
+
+	  def bindings
+	    @bindings ||= {}
+	  end
+	end

data/lib/bunny.rb

@@ -0,0 +1,57 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+%w[socket thread timeout amqp].each do |file|
+	require file
+end
+
+%w[ exchange queue header ].each do |file|
+  require "bunny/#{file}"
+end
+
+class Bunny
+	
+	attr_reader :client
+
+  class Error < StandardError; end
+
+	def initialize(opts = {})
+		@client = AMQP::Client.new(opts)
+  end
+
+	def start
+		client.start_session
+	end
+
+	def status
+		client.status
+	end
+  
+  def queue(name, opts = {})
+    queues[name] ||= Queue.new(client, name, opts)
+  end
+
+  def stop
+    client.close
+  end
+
+  def queues
+    @queues ||= {}
+  end
+
+  def direct(name = 'amq.direct', opts = {})
+    exchanges[name] ||= Exchange.new(client, :direct, name, opts)
+  end
+
+  def topic(name = 'amq.topic', opts = {})
+    exchanges[name] ||= Exchange.new(client, :topic, name, opts)
+  end
+
+  def headers(name = 'amq.match', opts = {})
+    exchanges[name] ||= Exchange.new(client, :headers, name, opts)
+  end
+
+  def exchanges
+    @exchanges ||= {}
+  end
+
+end