stomp 1.1 → 1.1.3

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 1.1.3 2009-24-11
+
+* Failover support
+* SSL support
+* Stomp::Connection and Stomp::Client accept a hash on their constructor
+
 == 1.1 2009-27-02
 
 * Ruby 1.9 Support

data/README.rdoc

@@ -15,6 +15,45 @@ An implementation of the Stomp protocol (http://stomp.codehaus.org/Protocol) for
       p msg
     end
 
+===Failover + SSL Example URL Usage
+
+    options = "initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false"
+    
+    #remotehost1 uses SSL, remotehost2 doesn't
+    client = Stomp::Client.new("failover:(stomp+ssl://login1:passcode1@remotehost1:61612,stomp://login2:passcode2@remotehost2:61613)?#{options}")
+    
+    client.send("/my/queue", "hello world!")
+    client.subscribe("/my/queue") do |msg|
+      p msg
+    end
+
+===Hash Example Usage
+
+  hash = {
+      :hosts => [
+        {:login => "login1", :passcode => "passcode1", :host => "remotehost1", :port => 61612, :ssl => true},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost2", :port => 61613, :ssl => false},
+        
+      ],
+      # These are the default parameters, don't need to be set
+      :initial_reconnect_delay => 0.01,
+      :max_reconnect_delay => 30.0,
+      :use_exponential_back_off => true,
+      :back_off_multiplier => 2,
+      :max_reconnect_attempts => 0,
+      :randomize => false,
+      :backup => false,
+      :timeout => -1,
+      :connect_headers => {}
+    }
+    
+    # for client
+    client = Stomp::Client.new(hash)
+    
+    # for connection
+    connection = Stomp::Connection.new(hash)
+    
+
 ===Contact info 
 
 Up until March 2009 the project was maintained and primarily developed by Brian McCallister. 

data/lib/stomp/client.rb

@@ -7,7 +7,8 @@ module Stomp
   # in that thread if you have much message volume.
   class Client
 
-    attr_reader :login, :passcode, :host, :port, :reliable, :running
+    attr_reader :login, :passcode, :host, :port, :reliable, :running, :parameters
+    alias :obj_send :send
 
     # A new Client object can be initialized using two forms:
     #
@@ -30,22 +31,46 @@ module Stomp
     #
     def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false)
 
-      # Parse stomp:// URL's or set positional params
-      case login
-      when /stomp:\/\/([\w\.]+):(\d+)/ # e.g. stomp://host:port
-        # grabs the matching positions out of the regex which are stored as
-        # $1 (host), $2 (port), etc
-        @login = ''
-        @passcode = ''
-        @host = $1
-        @port = $2.to_i
-        @reliable = false
-      when /stomp:\/\/([\w\.]+):(\w+)@([\w\.]+):(\d+)/ # e.g. stomp://login:passcode@host:port
-        @login = $1
-        @passcode = $2
-        @host = $3
-        @port = $4.to_i
+      # Parse stomp:// URL's or set params
+      if login.is_a?(Hash)
+        @parameters = login
+        
+        first_host = @parameters[:hosts][0]
+        
+        @login = first_host[:login]
+        @passcode = first_host[:passcode]
+        @host = first_host[:host]
+        @port = first_host[:port] || default_port(first_host[:ssl])
+        
+        @reliable = true
+        
+      elsif login =~ /^stomp:\/\/(([\w\.]+):(\w+)@)?([\w\.]+):(\d+)/ # e.g. stomp://login:passcode@host:port or stomp://host:port
+        @login = $2 || ""
+        @passcode = $3 || ""
+        @host = $4
+        @port = $5.to_i
         @reliable = false
+      elsif login =~ /^failover:(\/\/)?\(stomp(\+ssl)?:\/\/(([\w\.]*):(\w*)@)?([\w\.]+):(\d+)(,stomp(\+ssl)?:\/\/(([\w\.]*):(\w*)@)?([\w\.]+):(\d+)\))+(\?(.*))?$/ # e.g. failover://(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)?option1=param
+
+        first_host = {}
+        first_host[:ssl] = !$2.nil?
+        @login = first_host[:login] = $4 || ""
+        @passcode = first_host[:passcode] = $5 || ""
+        @host = first_host[:host] = $6
+        @port = first_host[:port] = $7.to_i || default_port(first_host[:ssl])
+        
+        options = $16 || ""
+        parts = options.split(/&|=/)
+        options = Hash[*parts]
+        
+        hosts = [first_host] + parse_hosts(login)
+        
+        @parameters = {}
+        @parameters[:hosts] = hosts
+        
+        @parameters.merge! filter_options(options)
+                
+        @reliable = true
       else
         @login = login
         @passcode = passcode
@@ -54,38 +79,21 @@ module Stomp
         @reliable = reliable
       end
 
-      raise ArgumentError if @host.nil? || @host.empty?
-      raise ArgumentError if @port.nil? || @port == '' || @port < 1 || @port > 65535
-      raise ArgumentError unless @reliable.is_a?(TrueClass) || @reliable.is_a?(FalseClass)
+      check_arguments!
 
       @id_mutex = Mutex.new
       @ids = 1
-      @connection = Connection.new(@login, @passcode, @host, @port, @reliable)
-      @listeners = {}
-      @receipt_listeners = {}
-      @running = true
-      @replay_messages_by_txn = {}
-
-      @listener_thread = Thread.start do
-        while @running
-          message = @connection.receive
-          case
-          when message.nil?
-            break
-          when message.command == 'MESSAGE'
-            if listener = @listeners[message.headers['destination']]
-              listener.call(message)
-            end
-          when message.command == 'RECEIPT'
-            if listener = @receipt_listeners[message.headers['receipt-id']]
-              listener.call(message)
-            end
-          end
-        end
+
+      if @parameters
+        @connection = Connection.new(@parameters)
+      else
+        @connection = Connection.new(@login, @passcode, @host, @port, @reliable)
       end
+      
+      start_listeners
 
     end
-
+    
     # Syntactic sugar for 'Client.new' See 'initialize' for usage.
     def self.open(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false)
       Client.new(login, passcode, host, port, reliable)
@@ -201,7 +209,76 @@ module Stomp
         @receipt_listeners[id] = listener
         id
       end
+      
+      def default_port(ssl)
+        return 61612 if ssl
+        
+        61613
+      end
+      
+      def parse_hosts(url)
+        hosts = []
+        
+        host_match = /stomp(\+ssl)?:\/\/(([\w\.]*):(\w*)@)?([\w\.]+):(\d+)\)/
+        url.scan(host_match).each do |match|
+          host = {}
+          host[:ssl] = !match[0].nil?
+          host[:login] =  match[2] || ""
+          host[:passcode] = match[3] || ""
+          host[:host] = match[4]
+          host[:port] = match[5].to_i
+          
+          hosts << host
+        end
+        
+        hosts
+      end
+      
+      def check_arguments!
+        raise ArgumentError if @host.nil? || @host.empty?
+        raise ArgumentError if @port.nil? || @port == '' || @port < 1 || @port > 65535
+        raise ArgumentError unless @reliable.is_a?(TrueClass) || @reliable.is_a?(FalseClass)
+      end
+      
+      def filter_options(options)
+        new_options = {}
+        new_options[:initial_reconnect_delay] = (options["initialReconnectDelay"] || 10).to_f / 1000 # In ms
+        new_options[:max_reconnect_delay] = (options["maxReconnectDelay"] || 30000 ).to_f / 1000 # In ms
+        new_options[:use_exponential_back_off] = !(options["useExponentialBackOff"] == "false") # Default: true
+        new_options[:back_off_multiplier] = (options["backOffMultiplier"] || 2 ).to_i
+        new_options[:max_reconnect_attempts] = (options["maxReconnectAttempts"] || 0 ).to_i
+        new_options[:randomize] = options["randomize"] == "true" # Default: false
+        new_options[:backup] = false # Not implemented yet: I'm using a master X slave solution
+        new_options[:timeout] = -1 # Not implemented yet: a "timeout(5) do ... end" would do the trick, feel free
+        
+        new_options
+      end
+      
+      def start_listeners
+        @listeners = {}
+        @receipt_listeners = {}
+        @running = true
+        @replay_messages_by_txn = {}
 
+        @listener_thread = Thread.start do
+          while @running
+            message = @connection.receive
+            case
+            when message.nil?
+              break
+            when message.command == 'MESSAGE'
+              if listener = @listeners[message.headers['destination']]
+                listener.call(message)
+              end
+            when message.command == 'RECEIPT'
+              if listener = @receipt_listeners[message.headers['receipt-id']]
+                listener.call(message)
+              end
+            end
+          end
+        end
+        
+      end
   end
 end
 

data/lib/stomp/connection.rb

@@ -4,7 +4,7 @@ module Stomp
   # synchronous receives
   class Connection
 
-
+    alias :obj_send :send
     # A new Connection object accepts the following parameters:
     #
     #   login             (String,  default : '')
@@ -14,9 +14,28 @@ module Stomp
     #   reliable          (Boolean, default : false)
     #   reconnect_delay   (Integer, default : 5)
     #
-    #   e.g. c = Client.new("username", "password", "localhost", 61613, true)
+    #   e.g. c = Connection.new("username", "password", "localhost", 61613, true)
+    #
+    # Hash:
+    #
+    #   hash = {
+    #     :hosts => [
+    #       {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+    #       {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+    #     ],
+    #     :initial_reconnect_delay => 0.01,
+    #     :max_reconnect_delay => 30.0,
+    #     :use_exponential_back_off => true,
+    #     :back_off_multiplier => 2,
+    #     :max_reconnect_attempts => 0,
+    #     :randomize => false,
+    #     :backup => false,
+    #     :timeout => -1
+    #   }
+    #
+    #   e.g. c = Connection.new(hash)
     #
-# TODO
+    # TODO
     # Stomp URL :
     #   A Stomp URL must begin with 'stomp://' and can be in one of the following forms:
     #
@@ -26,22 +45,42 @@ module Stomp
     #   stomp://user:pass@host.domain.tld:port
     #
     def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
-      @host = host
-      @port = port
-      @login = login
-      @passcode = passcode
+      if login.is_a?(Hash)
+        hashed_initialize(login)
+      else
+        @host = host
+        @port = port
+        @login = login
+        @passcode = passcode
+        @reliable = reliable
+        @reconnect_delay = reconnect_delay
+        @connect_headers = connect_headers
+        @ssl = false
+        @parameters = nil
+      end
+      
       @transmit_semaphore = Mutex.new
       @read_semaphore = Mutex.new
       @socket_semaphore = Mutex.new
-      @reliable = reliable
-      @reconnect_delay = reconnect_delay
-      @connect_headers = connect_headers
-      @closed = false
+      
       @subscriptions = {}
       @failure = nil
+      @connection_attempts = 0
+      
       socket
     end
-
+    
+    def hashed_initialize(params)
+      
+      @parameters = refine_params(params)
+      @reliable = true
+      @reconnect_delay = @parameters[:initial_reconnect_delay]
+      @connect_headers = @parameters[:connect_headers]
+      
+      #sets the first host to connect
+      change_host
+    end
+    
     # Syntactic sugar for 'Connection.new' See 'initialize' for usage.
     def Connection.open(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
       Connection.new(login, passcode, host, port, reliable, reconnect_delay, connect_headers)
@@ -50,30 +89,158 @@ module Stomp
     def socket
       # Need to look into why the following synchronize does not work.
       #@read_semaphore.synchronize do
+      
         s = @socket;
+        
+        s = nil unless connected?
+        
         while s.nil? || !@failure.nil?
           @failure = nil
           begin
-            s = TCPSocket.open @host, @port
-	    headers = @connect_headers.clone
-	    headers[:login] = @login
-	    headers[:passcode] = @passcode
+            s = open_socket
+            @closed = false
+      
+            headers = @connect_headers.clone
+            headers[:login] = @login
+            headers[:passcode] = @passcode
             _transmit(s, "CONNECT", headers)
             @connect = _receive(s)
             # replay any subscriptions.
             @subscriptions.each { |k,v| _transmit(s, "SUBSCRIBE", v) }
+            
+            @connection_attempts = 0
           rescue
             @failure = $!;
             s=nil;
             raise unless @reliable
-            $stderr.print "connect failed: " + $! +" will retry in #{@reconnect_delay}\n";
+            $stderr.print "connect to #{@host} failed: " + $! +" will retry(##{@connection_attempts}) in #{@reconnect_delay}\n";
+
+            raise "Max number of reconnection attempts reached" if max_reconnect_attempts?
+
             sleep(@reconnect_delay);
+            
+            @connection_attempts += 1
+            
+            if @parameters
+              change_host
+              increase_reconnect_delay
+            end
           end
         end
         @socket = s
         return s;
       #end
     end
+    
+    def connected?
+      begin
+        test_socket = TCPSocket.open @host, @port
+        test_socket.close
+        open?
+      rescue
+        false
+      end
+    end
+    
+    def close_socket
+      begin
+        @socket.close
+      rescue
+        #Ignoring if already closed
+      end
+      
+      @closed = true
+    end
+    
+    def open_socket
+      return TCPSocket.open @host, @port unless @ssl
+        
+        ssl_socket
+    end
+  
+    def ssl_socket
+      require 'openssl' unless defined?(OpenSSL)
+      
+      ctx = OpenSSL::SSL::SSLContext.new
+        
+        # For client certificate authentication:
+        # key_path = ENV["STOMP_KEY_PATH"] || "~/stomp_keys"
+        # ctx.cert = OpenSSL::X509::Certificate.new("#{key_path}/client.cer")
+        # ctx.key = OpenSSL::PKey::RSA.new("#{key_path}/client.keystore")
+        
+        # For server certificate authentication:
+        # truststores = OpenSSL::X509::Store.new
+        # truststores.add_file("#{key_path}/client.ts")
+        # ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        # ctx.cert_store = truststores
+        
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE  
+        
+      tcp_socket = TCPSocket.new @host, @port
+      ssl = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx)
+      ssl.connect
+      ssl
+    end
+  
+    def refine_params(params)
+      params = uncamelized_sym_keys(params)
+      
+      {
+        :initial_reconnect_delay => 0.01,
+        :max_reconnect_delay => 30.0,
+        :use_exponential_back_off => true,
+        :back_off_multiplier => 2,
+        :max_reconnect_attempts => 0,
+        :randomize => false,
+        :connect_headers => {},
+        :backup => false,
+        :timeout => -1
+      }.merge(params)
+        
+    end
+    
+    def uncamelized_sym_keys(params)
+      uncamelized = {}
+      params.each_pair do |key, value|
+        key = key.to_s.split(/(?=[A-Z])/).join('_').downcase.to_sym
+        uncamelized[key] = value
+      end
+      
+      uncamelized
+    end
+    
+    def change_host
+      @parameters[:hosts].shuffle! if @parameters[:randomize]
+      
+      # Set first as master and send it to the end of array
+      current_host = @parameters[:hosts].shift
+      @parameters[:hosts] << current_host
+      
+      @ssl = current_host[:ssl]
+      @host = current_host[:host]
+      @port = current_host[:port] || default_port(@ssl)
+      @login = current_host[:login] || ""
+      @passcode = current_host[:passcode] || ""
+      
+    end
+    
+    def default_port(ssl)
+      return 61612 if ssl
+      
+      61613
+    end
+    
+    def max_reconnect_attempts?
+      !(@parameters.nil? || @parameters[:max_reconnect_attempts].nil?) && @parameters[:max_reconnect_attempts] != 0 && @connection_attempts > @parameters[:max_reconnect_attempts]
+    end
+    
+    def increase_reconnect_delay
+
+      @reconnect_delay *= @parameters[:back_off_multiplier] if @parameters[:use_exponential_back_off] 
+      @reconnect_delay = @parameters[:max_reconnect_delay] if @reconnect_delay > @parameters[:max_reconnect_delay]
+      
+      @reconnect_delay
+    end
 
     # Is this connection open?
     def open?
@@ -145,7 +312,8 @@ module Stomp
     # Close this connection
     def disconnect(headers = {})
       transmit("DISCONNECT", headers)
-      @closed = true
+      
+      close_socket
     end
 
     # Return a pending message if one is available, otherwise
@@ -233,7 +401,7 @@ module Stomp
           rescue
             @failure = $!;
             raise unless @reliable
-            $stderr.print "transmit failed: " + $!+"\n";
+            $stderr.print "transmit to #{@host} failed: " + $!+"\n";
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: stomp
 version: !ruby/object:Gem::Version 
-  version: "1.1"
+  version: 1.1.3
 platform: ruby
 authors: 
 - Brian McCallister
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-27 00:00:00 +01:00
+date: 2009-12-03 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -41,6 +41,8 @@ files:
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://stomp.codehaus.org/
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --quiet
@@ -69,9 +71,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Ruby client for the Stomp messaging protocol
 test_files: 
 - test/test_client.rb