jack_rabbit 0.1.0-java → 0.2.0-java

data/dev/consumer.rb

@@ -2,15 +2,23 @@ $:.push(File.expand_path('../../lib', __FILE__))
 
 require 'uri'
 require 'jack_rabbit'
+require 'logger'
+require 'thread'
+
+$stdout.sync = true
+
+Thread.abort_on_exception = true
 
 subscriptions = [
   # exchange         key              queue
   [ 'jackrabbitdev', 'consumer.test', 'consumer.test', {} ]
 ]
 
-consumer = JackRabbit::Consumer.new
+consumer = JackRabbit::Consumer.new(Logger.new($stdout))
 
-consumer.connect([ URI.parse('amqp://guest:guest@localhost:5672/') ])
+consumer.connect([
+  URI.parse('amqp://guest:guest@localhost:5672/')
+])
 
 subscriptions.each do |exchange, key, queue, options|
   consumer.subscribe(exchange, key, queue, options) do |header, message|

data/dev/producer.rb

@@ -2,12 +2,21 @@ $:.push(File.expand_path('../../lib', __FILE__))
 
 require 'uri'
 require 'jack_rabbit'
+require 'logger'
+require 'thread'
 
-producer = JackRabbit::Producer.new
+$stdout.sync = true
+
+Thread.abort_on_exception = true
+
+producer = JackRabbit::Producer.new(Logger.new($stdout))
 
 producer.connect(URI.parse('amqp://guest:guest@localhost:5672/'))
 
+n = 0
 loop do
-  puts producer.publish('jackrabbitdev', :direct, 'consumer.test', 'foo')
+  message = (n += 1).to_s
+  producer.publish('jackrabbitdev', :direct, 'consumer.test', message)
+  puts(message)
   sleep(1)
 end

data/lib/jack_rabbit/backoff.rb

@@ -0,0 +1,15 @@
+module JackRabbit
+  module Backoff
+    MAX = 16 # seconds
+
+    def with_backoff(exception, f = ->(n) { n < MAX ? 2**n : MAX }, &block)
+      n = 0
+      begin
+        yield
+      rescue exception
+        sleep(n = f[n])
+        retry
+      end
+    end
+  end
+end

data/lib/jack_rabbit/channel.rb

@@ -0,0 +1,56 @@
+require 'jack_rabbit/subscription'
+require 'jack_rabbit/logging'
+
+module JackRabbit
+  class Channel
+    include Logging
+
+    EXCHANGE_OPTIONS = { durable: true, type: :direct }
+
+    QUEUE_OPTIONS = { durable: true }
+
+    def initialize(connection, options)
+      @connection, @options = connection, options
+      @subscriptions = []
+    end
+
+    def open
+      open_channel(@connection, @options)
+      self
+    end
+
+    def close
+      @channel.close
+    end
+
+    def subscribe(exchange, key, queue, options, &block)
+      sub = Subscription.new(self, exchange, key, queue, options, &block)
+      @subscriptions << sub
+      sub.declare
+      sub
+    end
+
+    def reopen
+      open_channel(@connection, @options)
+      @subscriptions.each { |sub| sub.declare }
+    end
+
+    def create_exchange(name, options)
+      @channel.exchange(name, EXCHANGE_OPTIONS.merge(options))
+    end
+
+    def create_queue(name, options)
+      @channel.queue(name, QUEUE_OPTIONS.merge(options))
+    end
+
+    private
+
+    def open_channel(connection, options)
+      debug('opening channel...')
+      channel = connection.create_channel
+      channel.prefetch(options[:prefetch]) if options[:prefetch]
+      channel.add_shutdown_listener { |_reason| connection.reconnect }
+      @channel = channel
+    end
+  end
+end

data/lib/jack_rabbit/client.rb

@@ -0,0 +1,20 @@
+require 'jack_rabbit/connection'
+
+module JackRabbit
+  module Client
+    private
+
+    def open_connection(uri, options)
+      Connection.new(uri, options)
+        .set_logger(@logger)
+        .open
+    end
+
+    def open_channel(connection, options)
+      connection
+        .channel(options)
+        .set_logger(@logger)
+        .open
+    end
+  end
+end

data/lib/jack_rabbit/connection.rb

@@ -0,0 +1,65 @@
+require 'hot_bunnies'
+require 'jack_rabbit/backoff'
+require 'jack_rabbit/channel'
+require 'jack_rabbit/logging'
+
+module JackRabbit
+  class Connection
+    include Backoff
+    include Logging
+
+    DEFAULT_OPTIONS = { connection_timeout: 5, heartbeat_interval: 5 }
+
+    def initialize(uri, options)
+      @uri, @options = uri, options.merge(connection_options(uri))
+      @channels = []
+    end
+
+    def open
+      open_connection(@uri, @options)
+      self
+    end
+
+    def close
+      @connection.close
+    end
+
+    def channel(options)
+      channel = Channel.new(self, options)
+      @channels << channel
+      channel
+    end
+
+    def reopen(reason)
+      debug('%s, reconnecting...' % reason.inspect)
+      open_connection(@uri, @options)
+      @channels.each { |channel| channel.reopen }
+    end
+
+    def create_channel
+      @connection.create_channel
+    end
+
+    private
+
+    def open_connection(uri, options)
+      connection =
+        with_backoff(Java::JavaNet::ConnectException) do
+          info('connecting to %s:%d...' % [ uri.host, uri.port ])
+          HotBunnies.connect(options)
+        end
+      connection.add_shutdown_listener { |reason| reopen(reason) }
+      @connection = connection
+    end
+
+    def connection_options(uri)
+      DEFAULT_OPTIONS.merge({
+        host: uri.host,
+        pass: uri.password,
+        port: uri.port,
+        user: uri.user,
+        vhost: uri.path
+      })
+    end
+  end
+end

data/lib/jack_rabbit/consumer.rb

@@ -1,79 +1,35 @@
-require 'hot_bunnies'
-require 'jack_rabbit/message_header'
+require 'jack_rabbit/client'
 
 module JackRabbit
   class Consumer
-    EXCHANGE_OPTIONS  = { durable: true, type: :direct }
-    QUEUE_OPTIONS     = { durable: true }
-    SUBSCRIBE_OPTIONS = { blocking: false }
+    include Client
 
-    def initialize
-      @connections   = []
-      @channels      = []
-      @subscriptions = []
+    def initialize(logger = nil)
+      @logger = logger
     end
 
     def connect(uris, options = {})
-      uris.inject(@connections) do |memo, uri|
-        memo.push(open_connection(uri, options))
-      end
+      @connections = uris.map { |uri| open_connection(uri, options) }
     end
 
     def subscribe(exchange, key, queue, options = {}, &block)
-      channels = open_channels(options[:prefetch])
-      bind_queues(channels, exchange, key, queue, options) do |meta, message|
-        block.call(MessageHeader.new(meta), message)
+      @connections.each do |connection|
+        channel = open_channel(connection, options)
+        declare_subscription(channel, exchange, key, queue, options, &block)
       end
     end
 
     def disconnect
-      @subscriptions.each(&:shutdown!)
-      (@channels + @connections).each(&:close)
+      @connections.each { |connection| connection.close }
     end
 
     private
 
-    def open_connection(uri, options)
-      connection =
-        HotBunnies.connect(options.merge(
-          host: uri.host,
-          pass: uri.password,
-          port: uri.port,
-          user: uri.user,
-          vhost: uri.path
-        ))
-      connection.add_shutdown_listener { |_reason| exit! }
-      connection
-    end
-
-    def open_channels(prefetch)
-      @connections.inject(@channels) do |memo, connection|
-        channel = connection.create_channel
-        channel.add_shutdown_listener { |_reason| exit! }
-        channel.prefetch = prefetch if prefetch
-        memo.push(channel)
-      end
-    end
-
-    def bind_queues(channels, exchange_name, key, queue_name, options, &block)
-      channels.inject(@subscriptions) do |memo, channel|
-        exchange = declare_exchange(channel, exchange_name, options)
-        queue =
-          bind_queue(channel, exchange, queue_name, key, options).tap do |q|
-            q.subscribe(SUBSCRIBE_OPTIONS.merge(options), &block)
-          end
-        memo.push(queue)
-      end
-    end
-
-    def bind_queue(channel, exchange, name, key, options)
+    def declare_subscription(channel, exchange, key, queue, options, &block)
       channel
-        .queue(name, QUEUE_OPTIONS.merge(Hash(options[:queue])))
-        .tap { |q| q.bind(exchange, { routing_key: key }) }
-    end
-
-    def declare_exchange(channel, name, options)
-      channel.exchange(name, EXCHANGE_OPTIONS.merge(Hash(options[:exchange])))
+        .subscribe(exchange, key, queue, options, &block)
+        .set_logger(@logger)
     end
   end
 end
+

data/lib/jack_rabbit/logging.rb

@@ -0,0 +1,24 @@
+module JackRabbit
+  module Logging
+    TAG = '[jack_rabbit] '
+
+    def set_logger(logger)
+      @logger = logger
+      self
+    end
+
+    private
+
+    def debug(message)
+      log(:debug, message)
+    end
+
+    def info(message)
+      log(:info, message)
+    end
+
+    def log(severity, message)
+      @logger.send(severity, TAG + message) if @logger
+    end
+  end
+end

data/lib/jack_rabbit/producer.rb

@@ -1,50 +1,33 @@
-require 'hot_bunnies'
+require 'jack_rabbit/backoff'
+require 'jack_rabbit/client'
 
 module JackRabbit
   class Producer
-    EXCHANGE_OPTIONS = { auto_delete: false, durable: true }
+    include Backoff
+    include Client
+    include Logging
 
-    def connect(uri, options = {})
-      @channel = (@connection = open_connection(uri, options)).create_channel
+    def initialize(logger = nil)
+      @logger = logger
     end
 
-    def disconnect
-      [ @channel, @connection ].each(&:close)
+    def connect(uri, options = {})
+      @connection = open_connection(uri, options)
+      @channel = open_channel(@connection, options)
     end
 
-    def publish(exchange_name, exchange_type, routing_key, message, headers = {})
-      with_exchange(@channel, exchange_name, exchange_type) do |exchange|
-        exchange.publish(message, headers.merge(routing_key: routing_key))
+    def publish(exchange, type, key, message, headers = {})
+      with_backoff(Java::ComRabbitmqClient::AlreadyClosedException) do
+        debug('publishing to %s:%s with %s...' % [ type, exchange, key ])
+        @channel
+          .create_exchange(exchange, { type: type })
+          .publish(message, headers.merge(routing_key: key))
       end
     end
 
-    private
-
-    def open_connection(uri, options)
-      connection =
-        HotBunnies.connect(options.merge(
-          host: uri.host,
-          pass: uri.password,
-          port: uri.port,
-          user: uri.user,
-          vhost: uri.path
-        ))
-      connection.add_shutdown_listener { |_reason| exit! }
-      connection
-    end
-
-    def open_channel(connection)
-      channel = connection.open_channel
-      channel.add_shutdown_listener { |_reason| exit! }
-      channel
-    end
-
-    def with_exchange(channel, exchange_name, exchange_type, &block)
-      block.call(
-        channel.exchange(exchange_name, EXCHANGE_OPTIONS.merge(
-          type: exchange_type
-        ))
-      )
+    def disconnect
+      @channel.close
+      @connection.close
     end
   end
 end

data/lib/jack_rabbit/subscription.rb

@@ -0,0 +1,26 @@
+require 'jack_rabbit/message_header'
+require 'jack_rabbit/logging'
+
+module JackRabbit
+  class Subscription
+    include Logging
+
+    DEFAULT_OPTIONS = { blocking: false }
+
+    def initialize(channel, exchange, key, queue, options, &block)
+      @channel = channel
+      @exchange, @key, @queue, @options = exchange, key, queue, options
+      @block = block
+    end
+
+    def declare
+      exchange = @channel.create_exchange(@exchange, @options)
+      queue = @channel.create_queue(@queue, @options)
+      queue.bind(exchange, { routing_key: @key })
+      @subscription =
+        queue.subscribe(DEFAULT_OPTIONS.merge(@options)) do |meta, message|
+          @block.call(MessageHeader.new(meta), message)
+        end
+    end
+  end
+end

data/lib/jack_rabbit/version.rb

@@ -1,3 +1,3 @@
 module JackRabbit
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -2,14 +2,14 @@
 name: jack_rabbit
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.1.0
+  version: 0.2.0
 platform: java
 authors:
 - Sebastian Ohm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-11-21 00:00:00.000000000 Z
+date: 2012-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hot_bunnies
@@ -43,9 +43,15 @@ files:
 - dev/producer.rb
 - jack_rabbit.gemspec
 - lib/jack_rabbit.rb
+- lib/jack_rabbit/backoff.rb
+- lib/jack_rabbit/channel.rb
+- lib/jack_rabbit/client.rb
+- lib/jack_rabbit/connection.rb
 - lib/jack_rabbit/consumer.rb
+- lib/jack_rabbit/logging.rb
 - lib/jack_rabbit/message_header.rb
 - lib/jack_rabbit/producer.rb
+- lib/jack_rabbit/subscription.rb
 - lib/jack_rabbit/version.rb
 homepage:
 licenses: []