stomp 1.2.4 → 1.2.5

data/examples/ssl_uc4_ciphers.rb

@@ -6,30 +6,43 @@
 require "rubygems"
 require "stomp"
 #
+# == SSL Use Case 4 - User Supplied Ciphers
+#
 # If you need your own ciphers list, this is how.
 # Stomp's default list will work in many cases.  If you need to use this, you
 # will know it because SSL connect will fail.  In that case, determining
 # _what_ should be in the list is your responsibility.
 #
-ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], 
-["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
-#
-# SSL Use Case 4
-#
-ssl_opts = Stomp::SSLParams.new(:key_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.key",
-  :cert_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.crt",
-  :ts_files => "/home/gmallard/sslwork/twocas_tj/serverCA/ServerTJCA.crt",
-  :ciphers => ciphers_list)
-#
-hash = { :hosts => [ 
-      {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},
+class ExampleSSL4C
+  # Initialize.
+  def initialize
+  end
+  # Run example.
+  def run
+    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],
+    ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
+    #
+    # SSL Use Case 4
+    #
+    ssl_opts = Stomp::SSLParams.new(:key_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.key",
+    :cert_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.crt",
+    :ts_files => "/home/gmallard/sslwork/twocas_tj/serverCA/ServerTJCA.crt",
+    :ciphers => ciphers_list)
+    #
+    hash = { :hosts => [
+        {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},
       ]
     }
-#
-puts "Connect starts, SSL Use Case 4"
-c = Stomp::Connection.new(hash)
-puts "Connect completed"
-puts "SSL Verify Result: #{ssl_opts.verify_result}"
-# puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}"
-c.disconnect
+    #
+    puts "Connect starts, SSL Use Case 4"
+    c = Stomp::Connection.new(hash)
+    puts "Connect completed"
+    puts "SSL Verify Result: #{ssl_opts.verify_result}"
+    # puts "SSL Peer Certificate:\n#{ssl_opts.peer_cert}"
+    c.disconnect
+  end
+end
+#
+e = ExampleSSL4C.new
+e.run
 

data/examples/ssl_ucx_default_ciphers.rb

@@ -6,23 +6,36 @@
 require "rubygems"
 require "stomp"
 #
+# == Example: Use Ruby Supplied Ciphers
+#
 # If you use SSLParams, and need the _default_ Ruby ciphers, this is how.
 #
 # NOTE: JRuby users may find that this is a *required* action. YMMV.
 #
-ssl_opts = Stomp::SSLParams.new(:use_ruby_ciphers => true) # Plus other parameters as needed
-#
-# SSL Use Case: Using default Stomp ciphers
-#
-hash = { :hosts => [ 
-      {:login => 'guest', :passcode => 'guest', :host => 'localhost', 
+class ExampleRubyCiphers
+  # Initialize.
+  def initialize
+  end
+  # Run example.
+  def run
+    ssl_opts = Stomp::SSLParams.new(:use_ruby_ciphers => true) # Plus other parameters as needed
+    #
+    # SSL Use Case: Using default Stomp ciphers
+    #
+    hash = { :hosts => [
+        {:login => 'guest', :passcode => 'guest', :host => 'localhost',
         :port => 61612, :ssl => ssl_opts},
       ]
     }
-#
-puts "Connect starts, SSL , Use Default Ruby Ciphers"
-c = Stomp::Connection.new(hash)
-puts "Connect completed"
-#
-c.disconnect
+    #
+    puts "Connect starts, SSL , Use Default Ruby Ciphers"
+    c = Stomp::Connection.new(hash)
+    puts "Connect completed"
+    #
+    c.disconnect
+  end
+end
+#
+e = ExampleRubyCiphers.new
+e.run
 

data/examples/stomp11_common.rb

@@ -7,39 +7,40 @@ require "rubygems" if RUBY_VERSION < "1.9"
 require "stomp"
 #
 module Stomp11Common
-  #
+  # User id
   def login()
     ENV['STOMP_USER'] || 'guest'
   end
-  #
+  # Password
   def passcode()
     ENV['STOMP_PASSCODE'] || 'guest'
   end
-  #
+  # Server host
   def host()
     ENV['STOMP_HOST'] || "localhost" # The connect host name
   end
-  #
+  # Server port
   def port()
     (ENV['STOMP_PORT'] || 62613).to_i # !! The author runs Apollo listening here
   end
-  #
+  # Required vhost name
   def virt_host()
-        ENV['STOMP_VHOST'] || "localhost" # The 1.1 virtual host name
+    ENV['STOMP_VHOST'] || "localhost" # The 1.1 virtual host name
   end
-  #
+  # Create a 1.1 commection
   def get_connection()
     conn_hdrs = {"accept-version" => "1.1",    # 1.1 only
-          "host" => virt_host,                 # the vhost
-        }
-    conn_hash = { :hosts => [ 
-          {:login => login, :passcode => passcode, :host => host, :port => port},
-          ],
-          :connect_headers => conn_hdrs,
-        }
+      "host" => virt_host,                     # the vhost
+    }
+    conn_hash = { :hosts => [
+      {:login => login, :passcode => passcode, :host => host, :port => port},
+      ],
+      :connect_headers => conn_hdrs,
+    }
     conn = Stomp::Connection.new(conn_hash)
   end
-  #
+
+  # Number of messages
   def nmsgs()
     (ENV['STOMP_NMSGS'] || 1).to_i # Number of messages
   end

data/examples/topic_consumer.rb

@@ -2,18 +2,31 @@
 
 require 'rubygems'
 require 'stomp'
+#
+# == Example topic consumer.
+#
+class ExampleTopicConsumer
+  # Initialize.
+  def initialize
+  end
+  # Run example.
+  def run
+    client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
 
-client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
+    puts "Subscribing to /topic/ronaldo"
 
-puts "Subscribing to /topic/ronaldo"
+    client.subscribe("/topic/ronaldo") do |msg|
+      puts msg.to_s
+      puts "----------------"
+    end
 
-client.subscribe("/topic/ronaldo") do |msg|
-  puts msg.to_s  
-  puts "----------------"
-end
-
-loop do
-  sleep(1)
-  puts "."
+    loop do
+      sleep(1)
+      puts "."
+    end
+  end
 end
+#
+e = ExampleTopicConsumer.new
+e.run
 

data/examples/topic_publisher.rb

@@ -3,13 +3,27 @@
 require 'rubygems'
 require 'stomp'
 
-client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
-message = "ronaldo #{ARGV[0]}"
-
-for i in (1..300)
-  puts "Sending message"
-  client.publish("/topic/ronaldo", "#{i}: #{message}")
-  puts "(#{Time.now})Message sent: #{i}"
-  sleep 1
+#
+# == Example topic publisher.
+#
+class ExampleTopicPublisher
+  # Initialize.
+  def initialize
+  end
+  # Run example.
+  def run
+    client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
+    message = "ronaldo #{ARGV[0]}"
+
+    for i in (1..50)
+      puts "Sending message"
+      client.publish("/topic/ronaldo", "#{i}: #{message}")
+      puts "(#{Time.now})Message sent: #{i}"
+      sleep 0.2
+    end
+  end
 end
+#
+e = ExampleTopicPublisher.new
+e.run
 

data/lib/client/utils.rb

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+
+require 'thread'
+require 'digest/sha1'
+
+module Stomp
+
+  class Client
+
+    private
+
+    # Set a subscription id in the headers hash if one does not already exist.
+    # For simplicities sake, all subscriptions have a subscription ID.
+    # setting an id in the SUBSCRIPTION header is described in the stomp protocol docs:
+    # http://stomp.github.com/
+    def set_subscription_id_if_missing(destination, headers)
+      headers[:id] = headers[:id] ? headers[:id] : headers['id']
+      if headers[:id] == nil
+        headers[:id] = Digest::SHA1.hexdigest(destination)
+      end
+    end
+
+    # Register a receipt listener.
+    def register_receipt_listener(listener)
+      id = -1
+      @id_mutex.synchronize do
+        id = @ids.to_s
+        @ids = @ids.succ
+      end
+      @receipt_listeners[id] = listener
+      id
+    end
+
+    # url_regex defines a regex for e.g. login:passcode@host:port or host:port
+    def url_regex
+      '(([\w\.\-]*):(\w*)@)?([\w\.\-]+):(\d+)'
+    end
+
+    # Parse a stomp URL.
+    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
+
+    # A very basic check of required arguments.
+    # *NOTE* This method will be made private in the next release.
+    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
+
+    # filter_options returns a new Hash of filtered options.
+    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
+
+    # find_listener returns the listener for a given subscription in a given message.
+    def find_listener(message)
+      subscription_id = message.headers['subscription']
+      if subscription_id == nil
+        # For backward compatibility, some messages may already exist with no
+        # subscription id, in which case we can attempt to synthesize one.
+        set_subscription_id_if_missing(message.headers['destination'], message.headers)
+        subscription_id = message.headers[:id]
+      end
+      @listeners[subscription_id]
+    end
+
+    # Start a single listener thread.  Misnamed I think.
+    def start_listeners()
+      @listeners = {}
+      @receipt_listeners = {}
+      @replay_messages_by_txn = {}
+
+      @listener_thread = Thread.start do
+        while true
+          message = @connection.receive
+          if message.command == Stomp::CMD_MESSAGE
+            if listener = find_listener(message)
+              listener.call(message)
+            end
+          elsif message.command == Stomp::CMD_RECEIPT
+            if listener = @receipt_listeners[message.headers['receipt-id']]
+              listener.call(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/connection/heartbeats.rb

@@ -0,0 +1,173 @@
+# -*- encoding: utf-8 -*-
+
+require 'socket'
+require 'timeout'
+require 'io/wait'
+require 'digest/sha1'
+
+module Stomp
+
+  class Connection
+
+    private
+
+    def _validate_hbheader()
+      return if @connect_headers[:"heart-beat"] == "0,0" # Caller does not want heartbeats.  OK.
+      parts = @connect_headers[:"heart-beat"].split(",")
+      if (parts.size != 2) || (parts[0] != parts[0].to_i.to_s) || (parts[1] != parts[1].to_i.to_s)
+        raise Stomp::Error::InvalidHeartBeatHeaderError
+      end
+    end
+
+    def _init_heartbeats()
+      return if @connect_headers[:"heart-beat"] == "0,0" # Caller does not want heartbeats.  OK.
+
+      # Init.
+
+      #
+      @cx = @cy = @sx = @sy = 0, # Variable names as in spec
+
+      #
+      @hbsend_interval = @hbrecv_interval = 0.0 # Send/Receive ticker interval.
+
+      #
+      @hbsend_count = @hbrecv_count = 0 # Send/Receive ticker counts.
+
+      #
+      @ls = @lr = -1.0 # Last send/receive time (from Time.now.to_f)
+
+      #
+      @st = @rt = nil # Send/receive ticker thread
+
+      # Handle current client / server capabilities.
+
+      #
+      cfh = @connection_frame.headers.symbolize_keys
+      return if cfh[:"heart-beat"] == "0,0" # Server does not want heartbeats
+
+      # Conect header parts.
+      parts = @connect_headers[:"heart-beat"].split(",")
+      @cx = parts[0].to_i
+      @cy = parts[1].to_i
+
+      # Connected frame header parts.
+      parts = cfh[:"heart-beat"].split(",")
+      @sx = parts[0].to_i
+      @sy = parts[1].to_i
+
+      # Catch odd situations like server has used => heart-beat:000,00000
+      return if (@cx == 0 && @cy == 0) || (@sx == 0 && @sy == 0)
+
+      # See if we are doing anything at all.
+
+      #
+      @hbs = @hbr = true # Sending/Receiving heartbeats. Assume yes at first.
+      # Check if sending is possible.
+      @hbs = false if @cx == 0 || @sy == 0
+      # Check if receiving is possible.
+      @hbr = false if @sx == 0 || @cy == 0
+      # Should not do heartbeats at all
+      return if (!@hbs && !@hbr)
+
+      # If sending
+      if @hbs
+        sm = @cx >= @sy ? @cx : @sy     # ticker interval, ms
+        @hbsend_interval = 1000.0 * sm  # ticker interval, μs
+        @ls = Time.now.to_f             # best guess at start
+        _start_send_ticker()
+      end
+
+      # If receiving
+      if @hbr
+        rm = @sx >= @cy ? @sx : @cy     # ticker interval, ms
+        @hbrecv_interval = 1000.0 * rm  # ticker interval, μs
+        @lr = Time.now.to_f             # best guess at start
+        _start_receive_ticker()
+      end
+
+    end
+
+    # _start_send_ticker starts a thread to send heartbeats when required.
+    def _start_send_ticker()
+      sleeptime = @hbsend_interval / 1000000.0 # Sleep time secs
+      @st = Thread.new {
+        while true do
+          sleep sleeptime
+          curt = Time.now.to_f
+          if @logger && @logger.respond_to?(:on_hbfire)
+            @logger.on_hbfire(log_params, "send_fire", curt)
+          end
+          delta = curt - @ls
+          if delta > (@hbsend_interval - (@hbsend_interval/5.0)) / 1000000.0 # Be tolerant (minus)
+            if @logger && @logger.respond_to?(:on_hbfire)
+              @logger.on_hbfire(log_params, "send_heartbeat", curt)
+            end
+            # Send a heartbeat
+            @transmit_semaphore.synchronize do
+              begin
+                @socket.puts
+                @ls = curt      # Update last send
+                @hb_sent = true # Reset if necessary
+                @hbsend_count += 1
+              rescue Exception => sendex
+                @hb_sent = false # Set the warning flag
+                if @logger && @logger.respond_to?(:on_hbwrite_fail)
+                  @logger.on_hbwrite_fail(log_params, {"ticker_interval" => @hbsend_interval,
+                  "exception" => sendex})
+                end
+                raise # Re-raise.  What else could be done here?
+              end
+            end
+          end
+          Thread.pass
+        end
+      }
+    end
+
+    # _start_receive_ticker starts a thread that receives heartbeats when required.
+    def _start_receive_ticker()
+      sleeptime = @hbrecv_interval / 1000000.0 # Sleep time secs
+      @rt = Thread.new {
+        while true do
+          sleep sleeptime
+          curt = Time.now.to_f
+          if @logger && @logger.respond_to?(:on_hbfire)
+            @logger.on_hbfire(log_params, "receive_fire", curt)
+          end
+          delta = curt - @lr
+          if delta > ((@hbrecv_interval + (@hbrecv_interval/5.0)) / 1000000.0) # Be tolerant (plus)
+            if @logger && @logger.respond_to?(:on_hbfire)
+              @logger.on_hbfire(log_params, "receive_heartbeat", curt)
+            end
+            # Client code could be off doing something else (that is, no reading of
+            # the socket has been requested by the caller).  Try to  handle that case.
+            lock = @read_semaphore.try_lock
+            if lock
+              last_char = @socket.getc
+              plc = parse_char(last_char)
+              if plc == "\n" # Server Heartbeat
+                @lr = Time.now.to_f
+              else
+                @socket.ungetc(last_char)
+              end
+              @read_semaphore.unlock
+              @hbrecv_count += 1
+            else
+              # Shrug.  Have not received one.  Just set warning flag.
+              @hb_received = false
+              if @logger && @logger.respond_to?(:on_hbread_fail)
+                @logger.on_hbread_fail(log_params, {"ticker_interval" => @hbrecv_interval})
+              end
+            end
+          else
+            @hb_received = true # Reset if necessary
+          end
+          Thread.pass
+        end
+      }
+    end
+
+  end # class
+
+end # module
+