stomp 1.1.10 → 1.2.0

data/examples/consumer.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 require 'rubygems'
 require 'stomp'
 

data/examples/get11conn_ex1.rb

@@ -0,0 +1,107 @@
+#
+# The current require dance for different Ruby versions.
+# Change this to suit your requirements.
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+end
+include Stomp11Common
+#
+# Stomp 1.1 Receive Example 1
+# ===========================
+#
+# Purpose: to demonstrate receiving messages using Stomp 1.1.
+#
+conn = get_connection() # Use helper method to obtain a Stomp#connection
+raise "Unexpected protocol level" if conn.protocol != Stomp::SPL_11
+#
+# To start receiving messages, you must first subscribe.  This is similar
+# to using Stomp 1.0.
+#
+# However, with Stomp 1.1:
+#
+# * for subscribe, the 'id' header is now _required_
+# * for unsubscribe, the 'id' header is now _required_
+#
+# The 'id' header specifies a 'subscription id' that must be unique for
+# the current session.
+#
+qname = "/queue/nodea.nodeb.nodec"
+#
+# Here is an example of allowed functionality in 1.0 that is not allowed in 1.1:
+#
+begin
+  conn.subscribe qname
+rescue RuntimeError => sre
+  puts "Rescue: #{sre}, #{sre.message}"
+end
+#
+# So, you must specify an 'id' header.  And it must be unique within the
+# current session.
+#
+# You can build your own unique ids of course.  That is a valid option.
+# In order to provide you with some assistance in generating unique ids,
+# two convenience methods are provided with the connection:
+#
+# * sha1 - generate a sha1 hash of some data you supply.  This may be sufficient for many purposes.
+# * uuid - generate a type 4 UUID.  This would be sufficient in all cases.
+#
+# Get a sha1:
+#
+sha1 = conn.sha1(qname) # sha1 of the queue name perhaps
+puts "Queue name: #{qname}, sha1: #{sha1}"
+#
+# Or perhaps a different sha1:
+#
+tn = Time.now.to_f.to_s # Maybe unique itself.
+sha1 = conn.sha1(tn)
+puts "Time now: #{tn}, sha1: #{sha1}"
+#
+# Or a Type 4 UUID:
+#
+uuid = conn.uuid()
+puts "Type 4 UUID: #{uuid}"
+#
+# You can specify the 'id' in the subscribe call in one of two ways:
+#
+# a) In the headers parameter
+# b) In the third positional parameter, the subId
+#
+# So, using the 'uuid', either:
+#
+# a) conn.subscribe qname, {'id' => uuid}
+# b) conn.subscribe qname, {}, uuid
+#
+conn.subscribe qname, {'id' => uuid} # First style
+#
+# Within a session, you may not subscribe to the same subscription id.
+#
+begin
+  conn.subscribe qname, {'id' => uuid} # Second time
+rescue RuntimeError => sre
+  puts "Rescue: #{sre}, #{sre.message}"
+end
+#
+# Once you have subscribed, you may receive as usual
+#
+1.upto(nmsgs()) do
+  received = conn.receive
+  puts "Received data: #{received.body}"
+end
+#
+# For unsubscribe, you must use the 'id' you used on subscribe.
+#
+# You have the same options for placing this id in the headers or in the 3rd
+# positional parameter.
+#
+conn.unsubscribe qname, {}, uuid # Second style
+#
+# And finally, disconnect.
+#
+conn.disconnect
+
+
+

data/examples/get11conn_ex2.rb

@@ -0,0 +1,67 @@
+#
+# The current require dance for different Ruby versions.
+# Change this to suit your requirements.
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+end
+include Stomp11Common
+#
+# Stomp 1.1 Receive Example 2
+# ===========================
+#
+# Purpose: to demonstrate receiving messages using Stomp 1.1, and using
+# 'ack => client'.
+#
+conn = get_connection() # Use helper method to obtain a Stomp#connection
+raise "Unexpected protocol level" if conn.protocol != Stomp::SPL_11
+#
+qname = "/queue/nodea.nodeb.nodec"
+#
+uuid = conn.uuid()
+puts "Subscribe id: #{uuid}"
+#
+# Subscribe with client ack mode
+#
+conn.subscribe qname, {'id' => uuid, 'ack' => 'client'} #
+#
+# Once you have subscribed, you may receive as usual
+#
+1.upto(nmsgs()) do
+  received = conn.receive
+  puts "Received data: #{received.body}"
+  #
+  # We want now to ACK this message.  In Stomp 1.0, a 'message-id' header was 
+  # required for the ACK.  In Stomp 1.1, and additional header is required:
+  #
+  # * 'subscription' => id
+  #
+  msgid = received.headers['message-id']
+  #
+  # What you cannot do:
+  #
+  begin
+    conn.ack msgid
+  rescue RuntimeError => sre
+    puts "Rescue: #{sre}, #{sre.message}"
+  end
+  #
+  # Try a valid 1.1 ACK
+  #
+  conn.ack msgid, {'subscription' => uuid}
+  puts "ACK - msgid: #{msgid}, subscription: #{uuid}"
+end
+#
+# Unsubscribe
+#
+conn.unsubscribe qname, {}, uuid # Second style
+#
+# And finally, disconnect.
+#
+conn.disconnect
+
+
+

data/examples/logexamp.rb

@@ -14,10 +14,11 @@ llog.debug "LE Starting"
 
 # //////////////////////////////////////////////////////////////////////////////
 mylog = Slogger::new  # The client provided STOMP callback logger
+# -*- encoding: utf-8 -*-
 
 # //////////////////////////////////////////////////////////////////////////////
 user =      ENV['STOMP_USER'] ? ENV['STOMP_USER'] : 'guest'
-password =  ENV['STOMP_PASSWORD'] ? ENV['STOMP_PASSWORD'] : 'guestpw'
+password =  ENV['STOMP_PASSWORD'] ? ENV['STOMP_PASSWORD'] : 'guest'
 host =      ENV['STOMP_HOST'] ? ENV['STOMP_HOST'] : 'localhost'
 port =      ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61613
 # //////////////////////////////////////////////////////////////////////////////
@@ -33,6 +34,7 @@ hash = { :hosts => [
 
 # //////////////////////////////////////////////////////////////////////////////
 # For a Connection:
+llog.debug "LE Connection processing starts"
 conn = Stomp::Connection.new(hash)
 conn.disconnect
 # //////////////////////////////////////////////////////////////////////////////
@@ -40,10 +42,24 @@ llog.debug "LE Connection processing complete"
 
 # //////////////////////////////////////////////////////////////////////////////
 # For a Client:
+llog.debug "LE Client processing starts"
 conn = Stomp::Client.new(hash)
 conn.close
 # //////////////////////////////////////////////////////////////////////////////
-# llog.debug "LE Client processing complete"
+llog.debug "LE Client processing complete"
+
+# //////////////////////////////////////////////////////////////////////////////
+# For a Connection with other calls:
+llog.debug "LE Connection Enhanced processing starts"
+conn = Stomp::Connection.new(hash)
+#
+dest = "/queue/loggerq1"
+conn.publish dest, "a logger message"
+conn.subscribe dest
+msg = conn.receive
+conn.disconnect
+# //////////////////////////////////////////////////////////////////////////////
+llog.debug "LE Connection Enhanced processing complete"
 
 # //////////////////////////////////////////////////////////////////////////////
 llog.debug "LE Ending"

data/examples/publisher.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 require 'rubygems'
 require 'stomp'
 

data/examples/put11conn_ex1.rb

@@ -0,0 +1,43 @@
+#
+# The current require dance for different Ruby versions.
+# Change this to suit your requirements.
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+end
+include Stomp11Common
+#
+# Stomp 1.1 Publish Example
+# =========================
+#
+# Purpose: to demonstrate sending messages using Stomp 1.1.
+#
+conn = get_connection() # Use helper method to obtain a Stomp#connection
+raise "Unexpected protocol level" if conn.protocol != Stomp::SPL_11
+#
+# Publishing simple data is as it was with Stomp 1.0.
+#
+# Note: Stomp 1.1 brokers seem to prefer using '.' as delimiters in queue
+# name spaces. Hence, the queue name used here.
+#
+qname = "/queue/nodea.nodeb.nodec"
+data = "message payload"
+headers = {}
+#
+# The 'data' and 'headers' may be omitted, as with Stomp 1.0
+#
+1.upto(nmsgs()) do |i|
+  msg = "#{data}: #{i}"
+  conn.publish qname, msg , headers
+  puts "Sent data: #{msg}"
+end
+#
+# And finally, disconnect.
+#
+conn.disconnect
+
+
+

data/examples/putget11_rh1.rb

@@ -0,0 +1,81 @@
+#
+# The current require dance for different Ruby versions.
+# Change this to suit your requirements.
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+end
+include Stomp11Common
+#
+# Stomp 1.1 Send/Receive Example - Repeated Headers
+# =================================================
+#
+# Purpose: to demonstrate sending and receiving using Stomp 1.1, and an unusual
+# aspect of the specification.  What is demonstrated here is the use of
+# 'repeated headers'. Note that brokers MAY support repeated headers as
+# demonstrated, but are not required to provide this support. This example 
+# should run against the Apollo broker.  It will *not* currently run against 
+# RabbitMQ.  YMMV depending on your broker.
+#
+# See: http://stomp.github.com/stomp-specification-1.1.html#Repeated_Header_Entries
+#
+conn = get_connection() # Use helper method to obtain a Stomp#connection
+raise "Unexpected protocol level" if conn.protocol != Stomp::SPL_11
+#
+# The gem supports repeated headers by allowing the 'value' part of a header
+# to be an Array instance.
+#
+# On 'publish', all values in the Array are placed on the wire and sent to the
+# broker in order.
+#
+# On 'receive', if repeated headers are detected, an Array instance is created
+# to hold the repeated values.  This is presented the the calling client to
+# be processed per client requirements.
+#
+qname = "/queue/nodea.nodeb.nodec"
+data = "message payload: #{Time.now.to_f}"
+key2_repeats = ["key2val3", "key2val2", "key2val1" ]
+headers = {"key1" => "value1",  # A normal header
+  "key2" => key2_repeats,       # A repeated header
+  "key3" => "value3",           # Another normal header
+}
+#
+# Ship it.
+#
+conn.publish qname, data , headers
+puts "Sent data: #{data}"
+#
+# Receive phase.
+#
+uuid = conn.uuid()
+conn.subscribe qname, {"id" => uuid}
+received = conn.receive
+conn.unsubscribe qname, {"id" => uuid}
+#
+# Check that we received what we sent.
+#
+raise "Unexpected payload" unless data == received.body
+raise "Missing key" unless received.headers["key2"]
+raise "Repeats not present" unless received.headers.has_value?(key2_repeats)
+raise "Unexpected repeat values" unless key2_repeats == received.headers["key2"]
+#
+# Demonstrate how to process repeated headers received by display of those 
+# received headers for a visual check.
+#
+received.headers.each_pair do |k,v|
+  if v.is_a?(Array)
+    v.each do |e|
+      puts "#{k}:#{e}"
+    end
+  else
+    puts "#{k}:#{v}"
+  end
+end
+#
+# And finally, disconnect.
+#
+conn.disconnect
+

data/examples/slogger.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 =begin
 
 Example STOMP call back logger class.
@@ -11,6 +13,10 @@ Optional callback methods:
 
     on_miscerr: on miscellaneous xmit/recv errors
 
+    on_publish: publish called
+    on_subscribe: subscribe called
+    on_receive: receive called and successful
+
 All methods are optional, at the user's requirements.
 
 If a method is not provided, it is not called (of course.)
@@ -69,7 +75,6 @@ class Slogger
     end
   end
 
-
   # Log miscellaneous errors
   def on_miscerr(parms, errstr)
     begin
@@ -80,6 +85,79 @@ class Slogger
     end
   end
 
+  # Subscribe
+  def on_subscribe(parms, headers)
+    begin
+      @log.debug "Subscribe Parms #{info(parms)}"
+      @log.debug "Subscribe Headers #{headers}"
+    rescue
+      @log.debug "Subscribe oops"
+    end
+  end
+
+  # Publish
+  def on_publish(parms, message, headers)
+    begin
+      @log.debug "Publish Parms #{info(parms)}"
+      @log.debug "Publish Message #{message}"
+      @log.debug "Publish Headers #{headers}"
+    rescue
+      @log.debug "Publish oops"
+    end
+  end
+
+  # Receive
+  def on_receive(parms, result)
+    begin
+      @log.debug "Receive Parms #{info(parms)}"
+      @log.debug "Receive Result #{result}"
+    rescue
+      @log.debug "Receive oops"
+    end
+  end
+
+  # Stomp 1.1+ - heart beat read (receive) failed
+  def on_hbread_fail(parms, ticker_data)
+    begin
+      @log.debug "Hbreadf Parms #{info(parms)}"
+      @log.debug "Hbreadf Result #{ticker_data}"
+    rescue
+      @log.debug "Hbreadf oops"
+    end
+  end
+
+  # Stomp 1.1+ - heart beat send (transmit) failed
+  def on_hbwrite_fail(parms, ticker_data)
+    begin
+      @log.debug "Hbwritef Parms #{info(parms)}"
+      @log.debug "Hbwritef Result #{ticker_data}"
+    rescue
+      @log.debug "Hbwritef oops"
+    end
+  end
+
+
+  # Stomp 1.1+ - heart beat read (receive) failed
+  def on_hbread_fail(parms, ticker_data)
+    begin
+      @log.debug "Hbreadf Parms #{info(parms)}"
+      @log.debug "Hbreadf Result #{ticker_data}"
+    rescue
+      @log.debug "Hbreadf oops"
+    end
+  end
+
+  # Stomp 1.1+ - heart beat thread fires
+  def on_hbfire(parms, type, time)
+    begin
+      @log.debug "HBfire #{type} " + "=" * 30
+      @log.debug "HBfire #{type} Parms #{info(parms)}"
+      @log.debug "HBfire #{type} Time #{time}"
+    rescue
+      @log.debug "HBfire #{type} oops"
+    end
+  end
+
   private
 
   def info(parms)