module HotBunnies java_import com.rabbitmq.client.ConnectionFactory java_import com.rabbitmq.client.Connection java_import java.util.concurrent.ConcurrentHashMap class Session # # API # def self.connect(options={}) cf = ConnectionFactory.new cf.uri = options[:uri] if options[:uri] cf.host = hostname_from(options) if include_host?(options) cf.port = options[:port] if options[:port] cf.virtual_host = vhost_from(options) if include_vhost?(options) cf.connection_timeout = timeout_from(options) if include_timeout?(options) cf.username = username_from(options) if include_username?(options) cf.password = password_from(options) if include_password?(options) cf.requested_heartbeat = heartbeat_from(options) if include_heartbeat?(options) cf.connection_timeout = connection_timeout_from(options) if include_connection_timeout?(options) tls = (options[:ssl] || options[:tls]) case tls when true then cf.use_ssl_protocol when String then if options[:trust_manager] cf.use_ssl_protocol(tls, options[:trust_manager]) else cf.use_ssl_protocol(tls) end end new(cf) end def initialize(connection_factory) @cf = connection_factory @connection = self.new_connection @channels = ConcurrentHashMap.new end def create_channel(n = nil) jc = if n @connection.create_channel(n) else @connection.create_channel end ch = Channel.new(self, jc) register_channel(ch) ch end def close @channels.select { |_, ch| ch.open? }.each do |_, ch| ch.close end @connection.close end def flush @connection.flush end def heartbeat=(n) @connection.heartbeat = n end def method_missing(selector, *args) @connection.__send__(selector, *args) end # # Implementation # def register_channel(ch) @channels[ch.channel_number] = ch end def unregister_channel(ch) @channels.delete(ch.channel_number) end protected def self.hostname_from(options) options[:host] || options[:hostname] || ConnectionFactory.DEFAULT_HOST end def self.include_host?(options) !!(options[:host] || options[:hostname]) end def self.vhost_from(options) options[:virtual_host] || options[:vhost] || ConnectionFactory.DEFAULT_VHOST end def self.include_vhost?(options) !!(options[:virtual_host] || options[:vhost]) end def self.timeout_from(options) options[:connection_timeout] || options[:timeout] end def self.include_timeout?(options) !!(options[:connection_timeout] || options[:timeout]) end def self.username_from(options) options[:username] || options[:user] || ConnectionFactory.DEFAULT_USER end def self.heartbeat_from(options) options[:heartbeat_interval] || options[:requested_heartbeat] || ConnectionFactory.DEFAULT_HEARTBEAT end def self.connection_timeout_from(options) options[:connection_timeout_interval] || options[:connection_timeout] || ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT end def self.include_username?(options) !!(options[:username] || options[:user]) end def self.password_from(options) options[:password] || options[:pass] || ConnectionFactory.DEFAULT_PASS end def self.include_password?(options) !!(options[:password] || options[:pass]) end def self.include_heartbeat?(options) !!(options[:heartbeat_interval] || options[:requested_heartbeat] || options[:heartbeat]) end def self.include_connection_timeout?(options) !!(options[:connection_timeout_interval] || options[:connection_timeout]) end # Executes a block, catching Java exceptions RabbitMQ Java client throws and # transforms them to Ruby exceptions that are then re-raised. # # @private def converting_rjc_exceptions_to_ruby(&block) begin block.call rescue com.rabbitmq.client.PossibleAuthenticationFailureException => e raise PossibleAuthenticationFailureError.new(@cf.username, @cf.virtual_host, @cf.password.bytesize) end end def new_connection converting_rjc_exceptions_to_ruby do @cf.new_connection end end end end