torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/get11conn_ex2.rb

@@ -1,77 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-#
-# 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'.
-#
-class Receive11Example2
-  # Initialize.
-  def initialize
-  end
-  # Run example.
-  def run
-    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
-  end
-end
-#
-e = Receive11Example2.new
-e.run
-

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/logexamp.rb

@@ -1,81 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'rubygems'
-require 'stomp'
-require 'logger'  # for the 'local' logger
-#
-if Kernel.respond_to?(:require_relative)
-  require_relative("./slogger")
-else
-  $LOAD_PATH << File.dirname(__FILE__)
-  require "slogger"
-end
-#
-# == A STOMP::Connection program which uses the callback logging facility.
-#
-class LoggerExample
-  # Initialize.
-  def initialize
-  end
-  # Run example.
-  def run
-    llog =        Logger::new(STDOUT)
-    llog.level =  Logger::DEBUG
-    llog.debug "LE Starting"
-
-    # //////////////////////////////////////////////////////////////////////////////
-    mylog = Slogger::new  # The client provided STOMP callback logger
-
-    # //////////////////////////////////////////////////////////////////////////////
-    user =      ENV['STOMP_USER'] ? ENV['STOMP_USER'] : 'guest'
-    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
-    # //////////////////////////////////////////////////////////////////////////////
-    # A hash type connect *MUST* be used to enable callback logging.
-    # //////////////////////////////////////////////////////////////////////////////
-    hash = { :hosts => [
-        {:login => user, :passcode => password, :host => 'noonehome', :port => 2525},
-        {:login => user, :passcode => password, :host => host, :port => port},
-      ],
-      :logger => mylog,	# This enables callback logging!
-      :max_reconnect_attempts => 5,
-    }
-
-    # //////////////////////////////////////////////////////////////////////////////
-    # For a Connection:
-    llog.debug "LE Connection processing starts"
-    conn = Stomp::Connection.new(hash)
-    conn.disconnect
-    # //////////////////////////////////////////////////////////////////////////////
-    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"
-
-    # //////////////////////////////////////////////////////////////////////////////
-    # 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"
-  end
-end
-e = LoggerExample.new
-e.run
-
-

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/logexamp_ssl.rb

@@ -1,81 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'rubygems'
-require 'stomp'
-require 'logger'  # for the 'local' logger
-#
-if Kernel.respond_to?(:require_relative)
-  require_relative("./slogger")
-else
-  $LOAD_PATH << File.dirname(__FILE__)
-  require "slogger"
-end
-#
-# == A STOMP::Connection program which uses the callback logging facility.
-#
-class SSLLoggerExample
-  # Initialize.
-  def initialize
-  end
-  # Run example.
-  def run
-    llog =        Logger::new(STDOUT)
-    llog.level =  Logger::DEBUG
-    llog.debug "LESSL Starting"
-
-    # //////////////////////////////////////////////////////////////////////////////
-    mylog = Slogger::new  # The client provided STOMP callback logger
-
-    # //////////////////////////////////////////////////////////////////////////////
-    user =      ENV['STOMP_USER'] ? ENV['STOMP_USER'] : 'guest'
-    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 : 61612
-    # //////////////////////////////////////////////////////////////////////////////
-    # A hash type connect *MUST* be used to enable callback logging.
-    # //////////////////////////////////////////////////////////////////////////////
-    hash = { :hosts => [
-        {:login => user, :passcode => password, :host => host, :port => port,
-        :ssl => true}, # Or provide your insance of SSLParams instead
-      ],
-      :logger => mylog,	# This enables callback logging!
-      :max_reconnect_attempts => 2,
-    }
-
-    # //////////////////////////////////////////////////////////////////////////////
-    # For a Connection:
-    llog.debug "LESSL Connection processing starts"
-    conn = Stomp::Connection.new(hash)
-    conn.disconnect
-    # //////////////////////////////////////////////////////////////////////////////
-    llog.debug "LESSL Connection processing complete"
-
-    # //////////////////////////////////////////////////////////////////////////////
-    # For a Client:
-    llog.debug "LESSL Client processing starts"
-    conn = Stomp::Client.new(hash)
-    conn.close
-    # //////////////////////////////////////////////////////////////////////////////
-    llog.debug "LESSL Client processing complete"
-
-    # //////////////////////////////////////////////////////////////////////////////
-    # For a Connection with other calls:
-    llog.debug "LESSL 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 "LESSL Connection Enhanced processing complete"
-
-    # //////////////////////////////////////////////////////////////////////////////
-    llog.debug "LESSL Ending"
-  end
-end
-#
-e = SSLLoggerExample.new
-e.run
-

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/publisher.rb

@@ -1,30 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'rubygems'
-require 'stomp'
-#
-# == Example message publisher
-#
-class ExamplePublisher
-  # 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("/queue/ronaldo", "#{i}: #{message}", {:persistent => true})
-      puts "(#{Time.now})Message sent: #{i}"
-      sleep 0.2
-    end
-  end
-end
-#
-e = ExamplePublisher.new
-e.run
-
-
-

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/put11conn_ex1.rb

@@ -1,56 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-#
-# 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.
-#
-class Publish11Example1
-  # Initialize.
-  def initialize
-  end
-  # Run example.
-  def run
-    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
-    #
-    puts "Writing #{nmsgs()} messages."
-    1.upto(nmsgs()) do |i|
-      msg = "#{data}: #{i}"
-      conn.publish qname, msg , headers
-      puts "Sent data: #{msg}"
-    end
-    #
-    # And finally, disconnect.
-    #
-    conn.disconnect
-  end
-end
-#
-e = Publish11Example1.new
-e.run
-
-

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/putget11_rh1.rb

@@ -1,93 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-#
-# 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
-#
-class RepeatedHeadersExample
-  # Initialize.
-  def initialize
-  end
-  # Run example.
-  def run
-    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
-  end
-end
-#
-e = RepeatedHeadersExample.new
-e.run
-

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/examples/slogger.rb

@@ -1,222 +0,0 @@
-# -*- 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_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 two useful exceptions to this rule for:
-#
-# *    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.
-#
-class Slogger
-
-  # Initialize a new callback logger instance.
-  def initialize(init_parms = nil)
-    @log = Logger::new(STDOUT)		# User preference
-    @log.level = Logger::DEBUG		# User preference
-    @log.info("Logger initialization complete.")
-  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(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")
-=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(parms)}"
-      @log.debug "Miscellaneous Error String #{errstr}"
-    rescue
-      @log.debug "Miscellaneous Error oops"
-    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 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
-
-  # Log 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
-
-  # 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, curt)
-    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[: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
-