stomp 1.3.5 → 1.4.0

data/adhoc/payload_generator_adhoctest.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+if Kernel.respond_to?(:require_relative)
+  require_relative("payload_generator")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "payload_generator"
+end
+#
+cmin, cmax = 1292, 67782
+ffmts = "%16.6f"
+#
+PayloadGenerator::initialize(min= cmin, max= cmax)
+
+to, nmts, nts, umps = 0.0, Time.now.to_f, 100, 5.6
+# p [ "nmts", nmts ]
+tslt = 1.0 / umps
+# p [ "tslt", tslt ]
+nts.times do |i|
+  ns = PayloadGenerator::payload()
+  to += ns.bytesize
+  # puts "t: #{i+1}, len: #{ns.bytesize}, tslt: #{tslt}"
+  sleep(tslt)
+  # puts "Done sleep!"
+end
+#
+te = Time.now.to_f
+# p [ "te", te ]
+et = te - nmts
+avgsz = to / nts
+mps = nts.to_f / et
+#
+fet = sprintf(ffmts, et)
+favgsz = sprintf(ffmts, avgsz)
+fmps = sprintf(ffmts, mps)
+#
+puts "=" * 48
+puts "\tNumber of payloads generated: #{nts}"
+puts "\tMin Length: #{cmin}, Max Length: #{cmax}"
+puts "\tAVG_SIZE: #{favgsz}, ELAPS_SEC: #{fet}(seconds)"
+puts "\tNMSGS_PER_SEC: #{fmps}"
+#

data/adhoc/stomp_adhoc_common.rb

@@ -0,0 +1,99 @@
+# -*- encoding: utf-8 -*-
+
+#
+# Common Stomp 1.1 code.
+#
+require "rubygems" if RUBY_VERSION < "1.9"
+require "stomp"
+#
+module Stomp11Common
+  # Port Constants locally
+  STOMP_AMQ_PORT = ENV['STOMP_AMQ_PORT'] ? ENV['STOMP_AMQ_PORT'].to_i : 61613
+  STOMP_APOLLO_PORT = ENV['STOMP_APOLLO_PORT'] ? ENV['STOMP_APOLLO_PORT'].to_i : 62613
+  STOMP_ARTEMIS_PORT = ENV['STOMP_ARTEMIS_PORT'] ? ENV['STOMP_ARTEMIS_PORT'].to_i : 31613
+  STOMP_SSNG_PORT = ENV['STOMP_SSNG_PORT'] ? ENV['STOMP_SSNG_PORT'].to_i : 51613
+  STOMP_RMQ_PORT = ENV['STOMP_RMQ_PORT'] ? ENV['STOMP_RMQ_PORT'].to_i : 41613
+
+  # Vhost Constants
+  STOMP_RMQ_VHOST = ENV['STOMP_RMQ_VHOST'] || '/'
+  STOMP_VHOST = ENV['STOMP_VHOST'] || 'localhost'
+
+  # Client Protocol List
+  STOMP_PROTOCOL = ENV['STOMP_PROTOCOL'] || "1.2"
+
+  # 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()
+    if ENV['STOMP_AMQ']
+      STOMP_AMQ_PORT
+    elsif ENV['STOMP_APOLLO']
+      STOMP_APOLLO_PORT
+    elsif ENV['STOMP_RMQ']
+      STOMP_RMQ_PORT
+    elsif ENV['STOMP_SSNG']
+      STOMP_SSNG_PORT
+    elsif ENV['STOMP_PORT']
+      ENV['STOMP_PORT'].to_i
+    else
+      61613 # The default ActiveMQ stomp listener port
+    end
+  end
+  # Required vhost name
+  def virt_host()
+    if ENV['STOMP_RMQ']
+      STOMP_RMQ_VHOST
+    else
+      STOMP_VHOST
+    end
+  end
+  # Create a 1.1 commection
+  def get_connection()
+    conn_hdrs = {"accept-version" => STOMP_PROTOCOL,
+      "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
+
+  # Queue / Topic Name
+  def make_destination(right_part = nil, topic = false)
+    if ENV['STOMP_DOTQUEUE']
+      right_part.gsub!('/', '.')
+    end
+    if topic
+      "/topic/#{right_part}"
+    else
+      "/queue/#{right_part}"
+    end
+  end
+
+  # True if client should supply a receipt block on 'publish'
+  def cli_block()
+    ENV['STOMP_CLI_BLOCK']
+  end
+
+  # True if connection should ask for a receipt
+  def conn_receipt()
+    ENV['STOMP_RECEIPT']
+  end
+end # module

data/examples/consume_file.rb

@@ -0,0 +1,63 @@
+# -*- encoding: utf-8 -*-
+
+require 'rubygems'
+require 'stomp'
+
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+  require_relative("./lflogger")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+  require "./lflogger"
+end
+include Stomp11Common
+#
+# Used primarily for testing performance when receiving "large" messages.
+# "large" => YMMV
+#
+class FileReader
+  # Initialize.
+  def initialize(pto)
+    @parse_timeout = pto
+  end
+  # Run example.
+  def run
+    conlogger = Slogger::new
+    start_time = Time.now.to_f
+    #
+    connection_hdrs = {"accept-version" => "1.1",
+      "host" => virt_host(),
+    }
+    connection_hash = { :hosts => [
+        {:login => login(), :passcode => passcode(),
+          :host => host(), :port => port()},
+      ],
+      :connect_headers => connection_hdrs,
+      :logger => conlogger,
+      :reliable => false,
+      :parse_timeout => @parse_timeout,
+    }
+    #
+    # p [ "ch", connection_hash ]
+    connection = Stomp::Connection.new(connection_hash)
+    qname = ENV['STOMP_DEST'] ? ENV['STOMP_DEST'] : "/queue/a.big.file"
+    puts "CONF: Qname is: #{qname}"
+    ## connection.subscribe(qname, {:destination => qname}, "bigFileSubscriptionID")
+    connection.subscribe(qname, {:destination => qname}, connection.uuid())
+    ## connection.subscribe(qname, {:destination => qname}, "0")
+    msg = connection.receive()
+    puts "CONF: Message Command: #{msg.command}"
+    puts "CONF: Message Headers: #{msg.headers}"
+    body_length_bytes = msg.body.respond_to?(:bytesize) ? msg.body.bytesize : msg.body.length
+    puts "CONF: Received: #{body_length_bytes} bytes"
+    connection.disconnect
+    end_time = Time.now.to_f
+    ppt = sprintf("%20.6f", end_time - start_time)
+    puts "CONF: File consumed: #{ppt} seconds"
+  end
+end
+#
+e = FileReader.new(60)
+e.run
+

data/examples/contrib.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+#
+# git log --reverse --all --date=short --pretty --format='%aI;%cI;%cn;%ce' | \
+git log --reverse --all --date=short --pretty --format='%ad;%cd;%cn;%ce' | \
+    ruby examples/contributors.rb
+ 

data/examples/contributors.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+#
+class UserData
+
+  public
+  attr_accessor :count
+  attr_reader   :ad, :cd
+  #
+  def initialize(ad = nil, cd = nil)
+    @count, @ad, @cd = 1, ad, cd
+  end
+  #  
+  def to_s
+    "UserData: AuthorDate=>#{@ad}, CommitDate=>#{@cd}, CommitCount =>#{@count}"
+  end
+end
+# tABLE Data
+ttab_s = "<table border=\"1\" style=\"width:100%;border: 1px solid black;\">\n"
+ttab_e = "</table>\n"
+# Row Data
+trow_s = "<tr>\n"
+trow_e = "</tr>\n"
+# Header Data
+th_s = "<th style=\"border: 1px solid black;padding-left: 10px;\" >\n"
+th_c1 = "First Author Date"
+th_c1b = "First Commit Date"
+th_c2 = "(Commit Count)"
+th_c3 = "Name / E-mail"
+th_e = "</th>\n"
+# User Data (partial)
+td_s = "<td style=\"border: 1px solid black;padding-left: 10px;\" >\n"
+td_e = "</td>\n"
+#
+puts ttab_s # table start
+#
+userList = {}
+while s = gets do
+  s.chomp!
+  ad, cd, n, e = s.split(";")
+  hk = "#{n}|#{e}"
+  if userList.has_key?(hk)
+    userList[hk].count += 1
+  else
+    userList[hk] = UserData.new(ad, cd)
+=begin
+    if ad != cd
+      puts "NE: #{ad}, #{cd}, #{n}, #{e}"
+    end
+=end
+  end
+
+end
+#
+puts trow_s
+#
+puts th_s
+puts th_c1
+puts th_e
+#
+=begin
+puts th_s
+puts th_c1b
+puts th_e
+=end
+#
+puts th_s
+puts th_c2
+puts th_e
+#
+puts th_s
+puts th_c3
+puts th_e
+#
+puts trow_e
+#
+userList.each do |k, v|
+  n, e = k.split("|")
+  oc = "(" + sprintf("%04d", v.count) + ")"
+  # puts "# #{v.time} (#{oc}) #{n} #{e}"
+  puts trow_s
+  #
+  puts td_s
+  puts "#{v.ad}"
+  puts td_e
+=begin
+  #
+  puts td_s
+  puts "#{v.cd}"
+  puts td_e
+=end
+  #
+  puts td_s
+  puts oc
+  puts td_e
+  #
+  puts td_s
+  puts "<span style=\"font-weight: bold;\" >\n"
+  puts "#{n}\n"
+  puts "</span>\n"
+  puts " / #{e}"
+  puts td_e
+  #  
+  puts trow_e  
+end
+#
+puts ttab_e # table end

data/examples/lflogger.rb

@@ -0,0 +1,316 @@
+# -*- encoding: utf-8 -*-
+
+require 'logger'	# use the standard Ruby logger .....
+
+# == Example STOMP call back logger class.
+#
+# Optional callback methods:
+#
+# *    on_connecting: connection starting
+# *    on_connected: successful connect
+# *    on_connectfail: unsuccessful connect (will usually be retried)
+# *    on_disconnect: successful disconnect
+#
+# *    on_miscerr: on miscellaneous xmit/recv errors
+#
+# *    on_publish: publish called
+# *    on_subscribe: subscribe called
+# *    on_unsubscribe: unsubscribe called
+#
+# *    on_begin: begin called
+# *    on_ack: ack called
+# *    on_nack: nack called
+# *    on_commit: commit called
+# *    on_abort: abort called
+#
+# *    on_receive: receive called and successful
+#
+# *    on_ssl_connecting: SSL connection starting
+# *    on_ssl_connected: successful SSL connect
+# *    on_ssl_connectfail: unsuccessful SSL connect (will usually be retried)
+#
+# *    on_hbread_fail: unsuccessful Heartbeat read
+# *    on_hbwrite_fail: unsuccessful Heartbeat write
+# *    on_hbfire: on any send or receive heartbeat
+#
+# All methods are optional, at the user's requirements.
+#
+# If a method is not provided, it is not called (of course.)
+# 
+# IMPORTANT NOTE:  in general, call back logging methods *SHOULD* not raise exceptions, 
+# otherwise the underlying STOMP connection may fail in mysterious ways.
+# There are, however, exceptions to this 'rule'.
+#
+# Useful exceptions to this rule are:
+#
+# *    on_connectfail
+# *    on_ssl_connectfail
+#
+# These two methods can raise a Stomp::Errors::LoggerConnectionError.  If this
+# exception is raised, it is passed up the chain to the caller.
+#
+# Callback parameters: are a copy of the @parameters instance variable for
+# the Stomp::Connection.
+#
+# A logger class may optionally inherit from the provided NullLogger
+#
+# # class Slogger < Stomp::NullLogger
+#
+class Slogger
+
+  MAX_BODY_LEN = 1024 # Arbitrary
+
+  # Initialize a new callback logger instance.
+  def initialize(init_parms = nil)
+    _init
+    @log.info("Logger initialization complete.")
+  end
+
+  def _init
+    @log = Logger::new(STDOUT)		# User preference
+    @log.level = Logger::DEBUG		# User preference
+  end
+
+  def marshal_dump
+    []
+  end
+
+  def marshal_load(array)
+    _init
+  end
+
+  # Log connecting events
+  def on_connecting(parms)
+    begin
+      @log.debug "Connecting: #{info(parms)}"
+    rescue
+      @log.debug "Connecting oops #{$!}"
+    end
+  end
+
+  # Log connected events
+  def on_connected(parms)
+    begin
+      @log.debug "Connected Info: #{info(parms)}"
+      @log.debug "Connected Parms: #{parms}"
+    rescue
+      @log.debug "Connected oops #{$!}"
+    end
+  end
+
+  # Log connectfail events
+  def on_connectfail(parms)
+    begin
+      @log.debug "Connect Fail #{info(parms)}"
+    rescue
+      @log.debug "Connect Fail oops #{$!}"
+    end
+=begin
+    # An example LoggerConnectionError raise
+    @log.debug "Connect Fail, will raise"
+    raise Stomp::Error::LoggerConnectionError.new("quit from connect fail")
+=end
+  end
+
+  # Log disconnect events
+  def on_disconnect(parms)
+    begin
+      @log.debug "Disconnected #{info(parms)}"
+    rescue
+      @log.debug "Disconnected oops #{$!}"
+    end
+  end
+
+  # Log miscellaneous errors
+  def on_miscerr(parms, errstr)
+    begin
+      @log.debug "Miscellaneous Error Info: #{info(parms)}"
+      @log.debug "Miscellaneous Error String: #{errstr}"
+      @log.debug "Miscellaneous Error Parms: #{parms}"
+    rescue
+      @log.debug "Miscellaneous Error oops #{$!}"
+      # Most clients will want to know about this. YMMV
+      raise
+    end
+  end
+
+  # Log 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
+
+  # Log UnSubscribe
+  def on_unsubscribe(parms, headers)
+    begin
+      @log.debug "UnSubscribe Parms #{info(parms)}"
+      @log.debug "UnSubscribe Headers #{headers}"
+    rescue
+      @log.debug "UnSubscribe oops #{$!}"
+    end
+  end
+
+  # Log Publish
+  def on_publish(parms, body, headers)
+    begin
+      @log.debug "Publish Parms #{info(parms)}"
+      body_length_bytes = body.respond_to?(:bytesize) ? body.bytesize : body.length
+      @log.debug "Publish Message Body #{body}" if body_length_bytes <= MAX_BODY_LEN
+      @log.debug "Publish Headers #{headers}"
+    rescue
+      @log.debug "Publish oops #{$!}"
+    end
+  end
+
+  # Log Receive
+  def on_receive(parms, result)
+    begin
+      @log.debug "Receive Parms #{info(parms)}"
+      @log.debug result.is_a? Stomp::Message
+      ## @log.debug "Receive Result #{result}"
+    rescue
+      @log.debug "Receive oops #{$!}"
+    end
+  end
+
+  # Log Begin
+  def on_begin(parms, headers)
+    begin
+      @log.debug "Begin Parms #{info(parms)}"
+      @log.debug "Begin Result #{headers}"
+    rescue
+      @log.debug "Begin oops #{$!}"
+    end
+  end
+
+  # Log Ack
+  def on_ack(parms, headers)
+    begin
+      @log.debug "Ack Parms #{info(parms)}"
+      @log.debug "Ack Result #{headers}"
+    rescue
+      @log.debug "Ack oops #{$!}"
+    end
+  end
+
+  # Log NAck
+  def on_nack(parms, headers)
+    begin
+      @log.debug "NAck Parms #{info(parms)}"
+      @log.debug "NAck Result #{headers}"
+    rescue
+      @log.debug "NAck oops #{$!}"
+    end
+  end
+
+  # Log Commit
+  def on_commit(parms, headers)
+    begin
+      @log.debug "Commit Parms #{info(parms)}"
+      @log.debug "Commit Result #{headers}"
+    rescue
+      @log.debug "Commit oops #{$!}"
+    end
+  end
+
+  # Log Abort
+  def on_abort(parms, headers)
+    begin
+      @log.debug "Abort Parms #{info(parms)}"
+      @log.debug "Abort Result #{headers}"
+    rescue
+      @log.debug "Abort 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.inspect}"
+    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.inspect}"
+    rescue
+      @log.debug "Hbwritef oops #{$!}"
+    end
+  end
+
+  # Log SSL connection start.
+  def on_ssl_connecting(parms)
+    begin
+      @log.debug "SSL Connecting Parms #{info(parms)}"
+    rescue
+      @log.debug "SSL Connecting oops #{$!}"
+    end
+  end
+
+  # Log a successful SSL connect.
+  def on_ssl_connected(parms)
+    begin
+      @log.debug "SSL Connected Parms #{info(parms)}"
+    rescue
+      @log.debug "SSL Connected oops #{$!}"
+    end
+  end
+
+  # Log an unsuccessful SSL connect.
+  def on_ssl_connectfail(parms)
+    begin
+      @log.debug "SSL Connect Fail Parms #{info(parms)}"
+      @log.debug "SSL Connect Fail Exception #{parms[:ssl_exception]}, #{parms[:ssl_exception].message}"
+    rescue
+      @log.debug "SSL Connect Fail oops #{$!}"
+    end
+=begin
+    # An example LoggerConnectionError raise
+    @log.debug "SSL Connect Fail, will raise"
+    raise Stomp::Error::LoggerConnectionError.new("quit from SSL connect")
+=end
+  end
+
+  # Log heart beat fires
+  def on_hbfire(parms, srind, firedata = {})
+    begin
+      @log.debug "HeartBeat Fire Parms #{info(parms)}"
+      @log.debug "HeartBeat Fire Send/Receive #{srind}"
+    rescue
+      @log.debug "HeartBeat Fire oops #{$!}"
+    end
+  end
+
+  private
+
+  # Example information extract.
+  def info(parms)
+    #
+    # Available in the parms Hash:
+    # parms[:cur_host]
+    # parms[:cur_port]
+    # parms[:cur_login]
+    # parms[:cur_passcode]
+    # parms[:cur_ssl]
+    # parms[:cur_recondelay]
+    # parms[:cur_parseto]
+    # parms[:cur_conattempts]
+    # parms[:cur_failure]
+    # parms[:openstat]
+    #
+    # For the on_ssl_connectfail callback these are also available:
+    # parms[:ssl_exception]
+    #
+    "Host: #{parms[:cur_host]}, Port: #{parms[:cur_port]}, Login: #{parms[:cur_login]}, Passcode: #{parms[:cur_passcode]}, ssl: #{parms[:cur_ssl]}"
+  end
+end # of class
+

data/examples/publish_file.rb

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+
+require 'rubygems'
+require 'stomp'
+
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+  require_relative("./lflogger")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+  require "./lflogger"
+end
+include Stomp11Common
+#
+# Used primarily for testing performance when sending "large" messages.
+# "large" => YMMV
+#
+class FileSender
+  # Initialize.
+  def initialize
+  end
+  # Run example.
+  def run
+    p [ "pub001", Thread.current ]
+    publogger = Slogger::new
+    start_time = Time.now.to_f
+    fname = ARGV[0]
+    puts "PUBF: File Name: #{fname}"
+    file = open(fname, "r")
+    rs = Time.now.to_f
+    buff = file.read
+    re = Time.now.to_f
+    ppt = sprintf("%20.6f", re - rs)
+    puts "PUBF: File size: #{buff.respond_to?(:bytesize) ? buff.bytesize : buff.length}"
+    puts "PUBF: File read: #{ppt} seconds"
+    file.close
+    #
+    client_hdrs = {"accept-version" => "1.1",
+      "host" => virt_host(),
+    }
+    client_hash = { :hosts => [
+        {:login => login(), :passcode => passcode(),
+          :host => host(), :port => port()},
+      ],
+      :connect_headers => client_hdrs,
+      :logger => publogger,	
+      :reliable => false, ### *NOTE*
+    }
+    #
+    # p [ "ch", client_hash ]
+    client = Stomp::Client.new(client_hash)
+    qname = ENV['STOMP_DEST'] ? ENV['STOMP_DEST'] : "/queue/a.big.file"
+    puts "PUBF: Qname is: #{qname}"
+    # Try to gracefully handle files that exceed broker size limits.
+    ph = {:presistent => true}
+    ph['suppress_content_length'] = 'yes' if suppresscl()
+    puts "PUBF: Headers are: #{ph.inspect}"
+    begin
+      client.publish(qname, buff, ph)
+    rescue
+      puts "PUBF: exception on publish: #{$!}"
+    end
+    sleep 0.1
+    e = client.poll() # Check for unsolicited messages from broker
+    puts "PUBF: unexpected broker message: #{e}" if e
+    client.close
+    end_time = Time.now.to_f
+    ppt = sprintf("%20.6f", end_time - start_time)
+    puts "PUBF: File published: #{ppt} seconds"
+  end
+end
+#
+e = FileSender.new
+e.run
+