amqp 0.7.0 → 0.7.1

data/lib/amqp/client.rb

@@ -1,60 +1,10 @@
 # encoding: utf-8
 
-require File.expand_path('../frame', __FILE__)
+require "amqp/basic_client"
 
 require 'uri'
 
 module AMQP
-  class Error < StandardError; end
-
-  module BasicClient
-    attr_reader :broker
-
-    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
-          @broker = method
-          send Protocol::Connection::StartOk.new({:platform => 'Ruby/EventMachine',
-                                                  :product => 'AMQP',
-                                                  :information => 'http://github.com/ruby-amqp/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])
-
-          @on_disconnect = method(:disconnected)
-
-        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
@@ -78,25 +28,55 @@ module AMQP
       timeout @settings[:timeout] if @settings[:timeout]
       errback { @on_disconnect.call } unless @reconnecting
 
-      @connected = false
+      # TCP connection "openness"
+      @tcp_connection_established = false
+      # AMQP connection "openness"
+      @connected                  = false
     end
 
     def connection_completed
-      start_tls if @settings[:ssl]
+      if @settings[:ssl].is_a? Hash
+        start_tls @settings[:ssl]
+      elsif @settings[:ssl]
+        start_tls
+      end
+
       log 'connected'
       # @on_disconnect = proc { raise Error, 'Disconnected from server' }
       unless @closing
         @reconnecting = false
       end
 
-      @connected = true
-      @connection_status.call(:connected) if @connection_status
+      @tcp_connection_established = true
 
       @buf = Buffer.new
       send_data HEADER
       send_data [1, 1, VERSION_MAJOR, VERSION_MINOR].pack('C4')
+
+      if heartbeat = @settings[:heartbeat]
+        init_heartbeat if (@settings[:heartbeat] = heartbeat.to_i) > 0
+      end
     end
 
+    def init_heartbeat
+      @last_server_heartbeat = Time.now
+
+      @timer ||= EM::PeriodicTimer.new(@settings[:heartbeat]) do
+        if connected?
+          if @last_server_heartbeat < (Time.now - (@settings[:heartbeat] * 2))
+            log "Reconnecting due to missing server heartbeats"
+            reconnect(true)
+          else
+            send AMQP::Frame::Heartbeat.new
+          end
+        end
+      end
+    end
+
+    def tcp_connection_established?
+      @tcp_connection_established
+    end # tcp_connection_established?
+
     def connected?
       @connected
     end
@@ -104,7 +84,7 @@ module AMQP
     def unbind
       log 'disconnected'
       @connected = false
-      EM.next_tick { @on_disconnect.call }
+      EM.next_tick { @on_disconnect.call; @tcp_connection_established = false }
     end
 
     def add_channel(mq)
@@ -198,17 +178,27 @@ module AMQP
       EM.reconnect @settings[:host], @settings[:port], self
     end
 
-    def self.connect amqp_url_or_opts = nil
-      if amqp_url_or_opts.is_a?(String)
-        opts = parse_amqp_url(amqp_url_or_opts)
-      elsif amqp_url_or_opts.is_a?(Hash)
-        opts = amqp_url_or_opts
-      elsif amqp_url_or_opts.nil?
-        opts = Hash.new
+    def self.connect(arg = nil)
+      opts = case arg
+             when String then
+               opts = parse_connection_uri(arg)
+             when Hash then
+               arg
+             else
+               Hash.new
+             end
+
+      options = AMQP.settings.merge(opts)
+
+      if options[:username]
+        options[:user] = options.delete(:username)
       end
 
-      opts = AMQP.settings.merge(opts)
-      EM.connect opts[:host], opts[:port], self, opts
+      if options[:password]
+        options[:pass] = options.delete(:password)
+      end
+
+      EM.connect options[:host], options[:port], self, options
     end
 
     def connection_status(&blk)
@@ -217,6 +207,23 @@ module AMQP
 
     private
 
+    def self.parse_connection_uri(connection_string)
+      uri = URI.parse(connection_string)
+      raise("amqp:// uri required!") unless %w{amqp amqps}.include?(uri.scheme)
+
+      opts = {}
+
+      opts[:user]  = URI.unescape(uri.user) if uri.user
+      opts[:pass]  = URI.unescape(uri.password) if uri.password
+      opts[:vhost] = URI.unescape(uri.path) if uri.path
+      opts[:host]  = uri.host if uri.host
+      opts[:port]  = uri.port || Hash["amqp" => 5672, "amqps" => 5671][uri.scheme]
+      opts[:ssl]   = uri.scheme == "amqps"
+
+      opts
+    end
+
+
     def disconnected
       @connection_status.call(:disconnected) if @connection_status
       reconnect
@@ -228,19 +235,5 @@ module AMQP
       pp args
       puts
     end
-
-    def self.parse_amqp_url(amqp_url)
-      uri = URI.parse(amqp_url)
-      raise("amqp:// uri required!") unless %w{amqp amqps}.include? uri.scheme
-      opts = {}
-      opts[:user] = URI.unescape(uri.user) if uri.user
-      opts[:pass] = URI.unescape(uri.password) if uri.password
-      opts[:vhost] = URI.unescape(uri.path) if uri.path
-      opts[:host] = uri.host if uri.host
-      opts[:port] = uri.port ? uri.port :
-                      {"amqp" => 5672, "amqps" => 5671}[uri.scheme]
-      opts[:ssl] = uri.scheme == "amqps"
-      return opts
-    end
   end
 end

data/lib/{mq → amqp}/collection.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-class MQ
-  # MQ::Collection is used to store named AMQ model entities (exchanges, queues)
+module AMQP
+  # AMQP::Collection is used to store named AMQ model entities (exchanges, queues)
   class Collection < ::Array
     class IncompatibleItemError < ArgumentError
       def initialize(item)
@@ -46,5 +46,15 @@ class MQ
       __push__(item)
       return item
     end
+
+    def include?(name)
+      not self[name].nil?
+    end
+
+    def delete(name)
+      if self.include?(name)
+        self.delete_at(self.index(self[name]))
+      end
+    end
   end
 end

data/lib/amqp/connection.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require "amqp/ext/em"
+
+require "amqp/buffer"
+require "amqp/spec"
+require "amqp/protocol"
+require "amqp/frame"
+require "amqp/client"
+
+module AMQP
+  class << self
+    @logging = false
+    attr_accessor :logging
+    attr_reader :conn, :closing
+    alias :closing? :closing
+    alias :connection :conn
+  end
+
+  def self.connect *args
+    Client.connect *args
+  end
+
+  def self.settings
+    @settings ||= {
+      # server address
+      :host => '127.0.0.1',
+      :port => PORT,
+
+      # login details
+      :user => 'guest',
+      :pass => 'guest',
+      :vhost => '/',
+
+      # connection timeout
+      :timeout => nil,
+
+      # logging
+      :logging => false,
+
+      # ssl
+      :ssl => false
+    }
+  end
+
+  # Must be called to startup the connection to the AMQP server.
+  #
+  # The method takes several arguments and an optional block.
+  #
+  # This takes any option that is also accepted by EventMachine::connect.
+  # Additionally, there are several AMQP-specific options.
+  #
+  # * :user => String (default 'guest')
+  # The username as defined by the AMQP server.
+  # * :pass => String (default 'guest')
+  # The password for the associated :user as defined by the AMQP server.
+  # * :vhost => String (default '/')
+  # The virtual host as defined by the AMQP server.
+  # * :timeout => Numeric (default nil)
+  # Measured in seconds.
+  # * :logging => true | false (default false)
+  # Toggle the extremely verbose logging of all protocol communications
+  # between the client and the server. Extremely useful for debugging.
+  #
+  #  AMQP.start do
+  #    # default is to connect to localhost:5672
+  #
+  #    # define queues, exchanges and bindings here.
+  #    # also define all subscriptions and/or publishers
+  #    # here.
+  #
+  #    # this block never exits unless EM.stop_event_loop
+  #    # is called.
+  #  end
+  #
+  # Most code will use the MQ api. Any calls to AMQP::Channel.direct / AMQP::Channel.fanout /
+  # AMQP::Channel.topic / AMQP::Channel.queue will implicitly call #start. In those cases,
+  # it is sufficient to put your code inside of an EventMachine.run
+  # block. See the code examples in AMQP for details.
+  #
+  def self.start *args, &blk
+    EM.run {
+      @conn ||= connect *args
+      @conn.callback(&blk) if blk
+      @conn
+    }
+  end
+
+  class << self
+    alias :run :start
+  end
+
+  def self.stop
+    if @conn and not @closing
+      @closing = true
+      EM.next_tick do
+        @conn.close {
+          yield if block_given?
+          @conn = nil
+          @closing = false
+        }
+      end
+    end
+  end
+
+  def self.fork workers
+    EM.fork(workers) do
+      # clean up globals in the fork
+      Thread.current[:mq] = nil
+      AMQP.instance_variable_set('@conn', nil)
+
+      yield
+    end
+  end
+end

data/lib/amqp/exceptions.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module AMQP
+  # Raised whenever an illegal operation is attempted.
+  class Error < StandardError; end
+
+  class IncompatibleOptionsError < Error
+    def initialize(name, opts_1, opts_2)
+      super("There is already an instance called #{name} with options #{opts_1.inspect}, you can't define the same instance with different options (#{opts_2.inspect})!")
+    end
+  end # IncompatibleOptionsError
+
+  class ChannelClosedError < Error
+    def initialize(instance)
+      super("The channel #{instance.channel} was closed, you can't use it anymore!")
+    end
+  end # ChannelClosedError
+end # AMQP

data/lib/{mq → amqp}/exchange.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-class MQ
+module AMQP
   # An Exchange acts as an ingress point for all published messages. An
   # exchange may also be described as a router or a matcher. Every
   # published message is received by an exchange which, depending on its
@@ -14,7 +14,7 @@ class MQ
   # As part of the standard, the server _must_ predeclare the direct exchange
   # 'amq.direct' and the fanout exchange 'amq.fanout' (all exchange names
   # starting with 'amq.' are reserved). Attempts to declare an exchange using
-  # 'amq.' as the name will raise an MQ:Error and fail. In practice these
+  # 'amq.' as the name will raise an AMQP::Error and fail. In practice these
   # default exchanges are never used directly by client code.
   #
   # These predececlared exchanges are used when the client code declares
@@ -23,14 +23,6 @@ class MQ
   #
   class Exchange
 
-    #
-    # Behaviors
-    #
-
-    include AMQP
-
-
-
     #
     # API
     #
@@ -45,12 +37,12 @@ class MQ
     # predefined in the system, so you can use it straightaway.
 
     # Example:
-    # MQ.new.queue("tasks")
-    # MQ::Exchange.default.publish("make clean", routing_key: "tasks")
+    # AMQP::Channel.new.queue("tasks")
+    # AMQP::Channel::Exchange.default.publish("make clean", routing_key: "tasks")
 
     # For more info see section 2.1.2.4 Automatic Mode of the AMQP 0.9.1 spec.
-    def self.default
-      @@default ||= self.new(MQ.new, :direct, "", :no_declare => true)
+    def self.default(channel = nil)
+      self.new(channel || AMQP::Channel.new, :direct, "", :no_declare => true)
     end
 
     def self.add_default_options(type, name, opts, block)
@@ -65,7 +57,7 @@ class MQ
     # As part of the standard, the server _must_ predeclare the direct exchange
     # 'amq.direct' and the fanout exchange 'amq.fanout' (all exchange names
     # starting with 'amq.' are reserved). Attempts to declare an exchange using
-    # 'amq.' as the name will raise an MQ:Error and fail. In practice these
+    # 'amq.' as the name will raise an AMQP::Error and fail. In practice these
     # default exchanges are never used directly by client code.
     #
     # == Direct
@@ -80,14 +72,14 @@ class MQ
     # called 'amq.direct'. In this case it needs to use :key to do its matching.
     #
     #  # exchange is named 'foo'
-    #  exchange = MQ::Exchange.new(MQ.new, :direct, 'foo')
+    #  exchange = AMQP::Channel::Exchange.new(AMQP::Channel.new, :direct, 'foo')
     #
     #  # or, the exchange can use the default name (amq.direct) and perform
     #  # routing comparisons using the :key
-    #  exchange = MQ::Exchange.new(MQ.new, :direct, "", :key => 'foo')
+    #  exchange = AMQP::Channel::Exchange.new(AMQP::Channel.new, :direct, "", :key => 'foo')
     #  exchange.publish('some data') # will be delivered to queue bound to 'foo'
     #
-    #  queue = MQ::Queue.new(MQ.new, 'foo')
+    #  queue = AMQP::Channel::Queue.new(AMQP::Channel.new, 'foo')
     #  # can receive data since the queue name and the exchange key match exactly
     #  queue.pop { |data| puts "received data [#{data}]" }
     #
@@ -105,21 +97,21 @@ class MQ
     # In this case it needs to use :key to do its matching.
     #
     #  EM.run do
-    #    clock = MQ::Exchange.new(MQ.new, :fanout, 'clock')
+    #    clock = AMQP::Channel::Exchange.new(AMQP::Channel.new, :fanout, 'clock')
     #    EM.add_periodic_timer(1) do
     #      puts "\npublishing #{time = Time.now}"
     #      clock.publish(Marshal.dump(time))
     #    end
     #
     #    # one way of defining a queue
-    #    amq = MQ::Queue.new(MQ.new, 'every second')
-    #    amq.bind(MQ.fanout('clock')).subscribe do |time|
+    #    amq = AMQP::Channel::Queue.new(AMQP::Channel.new, 'every second')
+    #    amq.bind(AMQP::Channel.fanout('clock')).subscribe do |time|
     #      puts "every second received #{Marshal.load(time)}"
     #    end
     #
     #    # defining a queue using the convenience method
     #    # note the string passed to #bind
-    #    MQ.queue('every 5 seconds').bind('clock').subscribe do |time|
+    #    AMQP::Channel.queue('every 5 seconds').bind('clock').subscribe do |time|
     #      time = Marshal.load(time)
     #      puts "every 5 seconds received #{time}" if time.strftime('%S').to_i%5 == 0
     #    end
@@ -150,7 +142,7 @@ class MQ
     # for matching against the published routing key.
     #
     #  EM.run do
-    #    exch = MQ::Exchange.new(MQ.new, :topic, "stocks")
+    #    exch = AMQP::Channel::Exchange.new(AMQP::Channel.new, :topic, "stocks")
     #    keys = ['stock.us.aapl', 'stock.de.dax']
     #
     #    EM.add_periodic_timer(1) do # every second
@@ -159,17 +151,17 @@ class MQ
     #    end
     #
     #    # match against one dot-separated item
-    #    MQ.queue('us stocks').bind(exch, :key => 'stock.us.*').subscribe do |price|
+    #    AMQP::Channel.queue('us stocks').bind(exch, :key => 'stock.us.*').subscribe do |price|
     #      puts "us stock price [#{price}]"
     #    end
     #
     #    # match against multiple dot-separated items
-    #    MQ.queue('all stocks').bind(exch, :key => 'stock.#').subscribe do |price|
+    #    AMQP::Channel.queue('all stocks').bind(exch, :key => 'stock.#').subscribe do |price|
     #      puts "all stocks: price [#{price}]"
     #    end
     #
     #    # require exact match
-    #    MQ.queue('only dax').bind(exch, :key => 'stock.de.dax').subscribe do |price|
+    #    AMQP::Channel.queue('only dax').bind(exch, :key => 'stock.de.dax').subscribe do |price|
     #      puts "dax price [#{price}]"
     #    end
     #  end
@@ -230,8 +222,8 @@ class MQ
     #
     # == Exceptions
     # Doing any of these activities are illegal and will raise exceptions:
-    # 
-    # * redeclare an already-declared exchange to a different type (raises MQ::IncompatibleOptionsError)
+    #
+    # * redeclare an already-declared exchange to a different type (raises AMQP::Channel::IncompatibleOptionsError)
     # * :passive => true and the exchange does not exist (NOT_FOUND)
     #
     def initialize(mq, type, name, opts = {}, &block)
@@ -270,12 +262,16 @@ class MQ
     attr_reader :name, :type, :key, :status
     attr_accessor :opts, :callback
 
+    def channel
+      @mq
+    end # channel
+
     # This method publishes a staged file message to a specific exchange.
     # The file message will be routed to queues as defined by the exchange
     # configuration and distributed to any active consumers when the
     # transaction, if any, is committed.
     #
-    #  exchange = MQ.direct('name', :key => 'foo.bar')
+    #  exchange = AMQP::Channel.direct('name', :key => 'foo.bar')
     #  exchange.publish("some data")
     #
     # The method takes several hash key options which modify the behavior or
@@ -310,6 +306,8 @@ class MQ
     # message stays in memory and is never persisted to non-volatile (slow)
     # storage.
     #
+    #  * :content_type
+    # Content type you want to send the message with. It defaults to "application/octet-stream".
     def publish(data, opts = {})
       @mq.callback {
         out = []
@@ -320,7 +318,7 @@ class MQ
         data = data.to_s
 
         out << Protocol::Header.new(Protocol::Basic,
-                                    data.bytesize, { :content_type => 'application/octet-stream',
+                                    data.bytesize, { opts[:content_type] || :content_type => "application/octet-stream",
                                                    :delivery_mode => (opts[:persistent] ? 2 : 1),
                                                    :priority => 0 }.merge(opts))
 
@@ -335,9 +333,9 @@ class MQ
     # bindings on the exchange are cancelled.
     #
     # Further attempts to publish messages to a deleted exchange will raise
-    # an MQ::Error due to a channel close exception.
+    # an AMQP::Channel::Error due to a channel close exception.
     #
-    #  exchange = MQ.direct('name', :key => 'foo.bar')
+    #  exchange = AMQP::Channel.direct('name', :key => 'foo.bar')
     #  exchange.delete
     #
     # == Options
@@ -351,7 +349,7 @@ class MQ
     # * :if_unused => true | false (default false)
     # If set, the server will only delete the exchange if it has no queue
     # bindings. If the exchange has queue bindings the server does not
-    # delete it but raises a channel exception instead (MQ:Error).
+    # delete it but raises a channel exception instead (AMQP::Error).
     #
     def delete(opts = {})
       @mq.callback {
@@ -392,4 +390,4 @@ class MQ
       self.callback && self.callback.call(self)
     end # receive_response
   end # Exchange
-end # MQ
+end # AMQP