RubyGems - activemessaging - Versions diffs - 0.6.0 - Mend

activemessaging 0.6.0

Files changed (46) hide show

data/Rakefile +50 -0
data/generators/a13g_test_harness/a13g_test_harness_generator.rb +19 -0
data/generators/a13g_test_harness/templates/active_messaging_test.rhtml +13 -0
data/generators/a13g_test_harness/templates/active_messaging_test_controller.rb +29 -0
data/generators/a13g_test_harness/templates/index.rhtml +17 -0
data/generators/filter/USAGE +0 -0
data/generators/filter/filter_generator.rb +19 -0
data/generators/filter/templates/filter.rb +12 -0
data/generators/filter/templates/filter_test.rb +28 -0
data/generators/processor/USAGE +8 -0
data/generators/processor/processor_generator.rb +31 -0
data/generators/processor/templates/application.rb +18 -0
data/generators/processor/templates/broker.yml +79 -0
data/generators/processor/templates/jruby_poller +117 -0
data/generators/processor/templates/messaging.rb +12 -0
data/generators/processor/templates/poller +23 -0
data/generators/processor/templates/poller.rb +23 -0
data/generators/processor/templates/processor.rb +8 -0
data/generators/processor/templates/processor_test.rb +20 -0
data/generators/tracer/USAGE +8 -0
data/generators/tracer/templates/controller.rb +14 -0
data/generators/tracer/templates/helper.rb +2 -0
data/generators/tracer/templates/index.rhtml +4 -0
data/generators/tracer/templates/layout.rhtml +16 -0
data/generators/tracer/templates/trace_processor.rb +100 -0
data/generators/tracer/tracer_generator.rb +25 -0
data/lib/activemessaging.rb +133 -0
data/lib/activemessaging/adapter.rb +21 -0
data/lib/activemessaging/adapters/asqs.rb +412 -0
data/lib/activemessaging/adapters/base.rb +82 -0
data/lib/activemessaging/adapters/jms.rb +237 -0
data/lib/activemessaging/adapters/reliable_msg.rb +190 -0
data/lib/activemessaging/adapters/stomp.rb +99 -0
data/lib/activemessaging/adapters/test.rb +155 -0
data/lib/activemessaging/adapters/wmq.rb +202 -0
data/lib/activemessaging/filter.rb +29 -0
data/lib/activemessaging/gateway.rb +422 -0
data/lib/activemessaging/message_sender.rb +30 -0
data/lib/activemessaging/named_base.rb +54 -0
data/lib/activemessaging/processor.rb +45 -0
data/lib/activemessaging/support.rb +17 -0
data/lib/activemessaging/test_helper.rb +194 -0
data/lib/activemessaging/trace_filter.rb +34 -0
data/messaging.rb.example +5 -0
data/tasks/start_consumers.rake +8 -0
metadata +123 -0

data/generators/processor/templates/messaging.rb ADDED Viewed

@@ -0,0 +1,12 @@
+#
+# Add your destination definitions here
+# can also be used to configure filters, and processor groups
+#
+ActiveMessaging::Gateway.define do |s|
+  #s.destination :orders, '/queue/Orders'
+  #s.filter :some_filter, :only=>:orders
+  #s.processor_group :group1, :order_processor
+  s.destination :<%= singular_name %>, '/queue/<%= class_name %>'
+end

data/generators/processor/templates/poller ADDED Viewed

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'daemons'
+require 'activesupport'
+require 'activemessaging'
+APP_ROOT = File.expand_path(File.dirname(__FILE__) + '/..')
+script_file = File.join(File.dirname(__FILE__)+'/../lib/poller.rb')
+tmp_dir = File.join(File.expand_path(APP_ROOT), 'tmp')
+options = {
+  :app_name   => "poller",
+  :dir_mode   => :normal,
+  :dir        => tmp_dir,
+  :multiple   => true,
+  :ontop      => false,
+  :mode       => :load,
+  :backtrace  => true,
+  :monitor    => true,
+  :log_output => true
+}
+Daemons.run(script_file,options)

data/generators/processor/templates/poller.rb ADDED Viewed

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# Make sure stdout and stderr write out without delay for using with daemon like scripts
+STDOUT.sync = true; STDOUT.flush
+STDERR.sync = true; STDERR.flush
+#Try to Load Merb
+begin
+  require File.expand_path(File.dirname(__FILE__)+'/../config/boot')
+  #need this because of the CWD
+  Merb.root = MERB_ROOT
+  require File.expand_path(File.dirname(__FILE__)+'/../config/merb_init')
+rescue LoadError
+  # Load Rails
+  RAILS_ROOT=File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  require File.join(RAILS_ROOT, 'config', 'boot')
+  require File.join(RAILS_ROOT, 'config', 'environment')
+end
+# Load ActiveMessaging processors
+#ActiveMessaging::load_processors
+# Start it up!
+ActiveMessaging::start

data/generators/processor/templates/processor.rb ADDED Viewed

@@ -0,0 +1,8 @@
+class <%= class_name %>Processor < ApplicationProcessor
+  subscribes_to :<%= singular_name %>
+  def on_message(message)
+    logger.debug "<%= class_name %>Processor received: " + message
+  end
+end

data/generators/processor/templates/processor_test.rb ADDED Viewed

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../vendor/plugins/activemessaging/lib/activemessaging/test_helper'
+require File.dirname(__FILE__) + '/../../app/processors/application'
+class <%= class_name %>ProcessorTest < Test::Unit::TestCase
+  include ActiveMessaging::TestHelper
+  def setup
+    load File.dirname(__FILE__) + "/../../app/processors/<%= file_name %>_processor.rb"
+    @processor = <%= class_name %>Processor.new
+  end
+  def teardown
+    @processor = nil
+  end
+  def test_<%= file_name %>_processor
+    @processor.on_message('Your test message here!')
+  end
+end

data/generators/tracer/USAGE ADDED Viewed

@@ -0,0 +1,8 @@
+Description:
+    Generates a stub ActiveMessaging Tracing Controller.
+Examples:
+    ./script/generate tracer Tracer
+    will create:
+        /app/processors/tracer_processor.rb
+        /app/views/tracer/index.rhtml

data/generators/tracer/templates/controller.rb ADDED Viewed

@@ -0,0 +1,14 @@
+class <%= class_name %>Controller < ApplicationController
+  include ActiveMessaging::MessageSender
+  publishes_to :trace
+  def index
+  end
+  def clear
+    publish :trace, "<trace-control>clear</trace-control>"
+    redirect_to :action=>'index'
+  end
+end

data/generators/tracer/templates/helper.rb ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ module <%= class_name %>Helper
2	+ end

data/generators/tracer/templates/index.rhtml ADDED Viewed

@@ -0,0 +1,4 @@
+<%=button_to 'Clear', :action=>'clear'%>
+<%=image_tag '../trace.png', :id => 'graph'  %>

data/generators/tracer/templates/layout.rhtml ADDED Viewed

@@ -0,0 +1,16 @@
+<html>
+	<head>
+		<meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+		<title>Tracer</title>
+		<%=javascript_include_tag :defaults %>
+    </head>
+	<body>
+		<h2>Tracer</h2>
+		<% if @flash[:note] -%>
+		<div id="flash"><%= @flash[:note] %></div>
+		<% end -%>
+		<%= @content_for_layout %>
+	</body>
+</html>

data/generators/tracer/templates/trace_processor.rb ADDED Viewed

@@ -0,0 +1,100 @@
+require 'mpath'
+require 'active_support'
+class Dot
+  attr_accessor :name, :nodes, :edges, :clean_names
+  def initialize name
+    @name = name
+    @nodes = {}
+    @clean_names = {}
+    @edges = []
+    yield self
+  end
+  def node name, params = {}
+    @nodes[clean_name(name)] = params.stringify_keys.reverse_merge "label"=>name
+  end
+  def clean_name name
+    @clean_names[name] = "node#{@clean_names.length+1}" if @clean_names[name].nil?
+    @clean_names[name]
+  end
+  def edge from, to
+    edge = [clean_name(from), clean_name(to)]
+    @edges << edge unless @edges.member? edge
+  end
+  def to_s
+    dot = "digraph #{@name} {\n"
+    @nodes.each do |node_name, options|
+      dot += "\t#{node_name.to_s}"
+      optionstrings = []
+      options.keys.sort.each do |key|
+        optionstrings << "#{key}=\"#{options[key]}\""
+      end
+      dot += " [#{optionstrings.join(', ')}]" if optionstrings.length>0
+      dot += ";\n"
+    end
+    @edges.each {|e| dot += "\t#{e[0].to_s}->#{e[1].to_s};\n"}
+    dot += "}\n"
+  end
+  def == other
+    (other.name == name) && (other.nodes == nodes) && (other.edges == edges) && (other.clean_names == clean_names)
+  end
+end
+class TraceProcessor < ActiveMessaging::Processor
+  subscribes_to :trace
+  @@dot = Dot.new("Trace") {}
+  class << self
+  end
+  def dot
+    @@dot
+  end
+  def on_message(message)
+    xml = Mpath.parse(message)
+    if (xml.sent?) then
+      from = xml.sent.from.to_s
+      queue = xml.sent.queue.to_s
+      @@dot.node from
+      @@dot.node queue, "shape" => 'box'
+      @@dot.edge from, queue #hah - could do from => to
+    elsif (xml.received?) then
+      by = xml.received.by.to_s
+      queue = xml.received.queue.to_s
+      @@dot.node queue, "shape" => 'box'
+      @@dot.node by
+      @@dot.edge queue, by
+    elsif (xml.trace_control) then
+      command = xml.trace_control.to_s
+     begin
+        send command
+      rescue
+        puts "TraceProcessor: I don't understand the command #{command}"
+      end
+    end
+    create_image
+  end
+  def create_image
+    File.open(DOT_FILE, "w") {|f| f.puts @@dot.to_s }
+    output_file = APP_ROOT + "/public/trace.png"
+    `dot -Tpng -o #{output_file} #{DOT_FILE}`
+  end
+  def clear
+    @@dot = Dot.new("Trace") {}
+  end
+end

data/generators/tracer/tracer_generator.rb ADDED Viewed

@@ -0,0 +1,25 @@
+class TracerGenerator < RubiGen::Base
+  def manifest
+    record do |m|
+      path = 'app/controllers'
+      m.directory path
+      m.template 'controller.rb', File.join(path, "#{file_name}_controller.rb")
+      path = 'app/processors'
+      m.directory path
+      m.template 'trace_processor.rb', File.join(path, "#{file_name}_processor.rb")
+      path = 'app/helpers'
+      m.directory path
+      m.template 'helper.rb', File.join(path, "#{file_name}_helper.rb")
+      path = 'app/views/layouts'
+      m.directory path
+      m.file 'layout.rhtml', File.join(path, "#{file_name}.rhtml")
+      path = "app/views/#{file_name}"
+      m.directory path
+      m.file 'index.rhtml', File.join(path, "index.rhtml")
+    end
+  end
+end

data/lib/activemessaging.rb ADDED Viewed

@@ -0,0 +1,133 @@
+module ActiveMessaging
+  VERSION  = "0.5" #maybe this should be higher, but I'll let others judge :)
+  APP_ROOT = ENV['APP_ROOT'] || ENV['RAILS_ROOT'] || ((defined? RAILS_ROOT) && RAILS_ROOT) || File.dirname($0)
+  APP_ENV  = ENV['APP_ENV']  || ENV['RAILS_ENV']  || 'development'
+  # Used to indicate that the processing for a thread shoud complete
+  class StopProcessingException < Interrupt #:nodoc:
+  end
+  # Used to indicate that the processing on a message should cease,
+  # and the message should be returned back to the broker as best it can be
+  class AbortMessageException < Exception #:nodoc:
+  end
+  # Used to indicate that the processing on a message should cease,
+  # but no further action is required
+  class StopFilterException < Exception #:nodoc:
+  end
+  def ActiveMessaging.logger
+    @@logger = RAILS_DEFAULT_LOGGER if !defined?(@@logger) && (defined?(RAILS_DEFAULT_LOGGER) && !RAILS_DEFAULT_LOGGER.nil?)
+    @@logger = ActiveRecord::Base.logger unless defined?(@@logger)
+    @@logger = Logger.new(STDOUT) unless defined?(@@logger)
+    @@logger
+  end
+  # DEPRECATED, so I understand, but I'm using it nicely below.
+  def self.load_extensions
+    require 'logger'
+    require 'activemessaging/support'
+    require 'activemessaging/gateway'
+    require 'activemessaging/adapter'
+    require 'activemessaging/message_sender'
+    require 'activemessaging/processor'
+    require 'activemessaging/filter'
+    require 'activemessaging/trace_filter'
+    # load all under the adapters dir
+    Dir[APP_ROOT + '/vendor/plugins/activemessaging/lib/activemessaging/adapters/*.rb'].each{|a|
+      begin
+        adapter_name = File.basename(a, ".rb")
+        require 'activemessaging/adapters/' + adapter_name
+      rescue RuntimeError, LoadError => e
+        logger.debug "ActiveMessaging: adapter #{adapter_name} not loaded: #{ e.message }"
+      end
+    }
+  end
+  def self.load_config
+    path = File.expand_path("#{APP_ROOT}/config/messaging.rb")
+    begin
+      load path
+    rescue MissingSourceFile
+      logger.debug "ActiveMessaging: no '#{path}' file to load"
+    rescue
+      raise $!, " ActiveMessaging: problems trying to load '#{path}': \n\t#{$!.message}"
+    end
+  end
+  def self.load_processors(first=true)
+    #Load the parent processor.rb, then all child processor classes
+    load APP_ROOT + '/vendor/plugins/activemessaging/lib/activemessaging/message_sender.rb' unless defined?(ActiveMessaging::MessageSender)
+    load APP_ROOT + '/vendor/plugins/activemessaging/lib/activemessaging/processor.rb' unless defined?(ActiveMessaging::Processor)
+    load APP_ROOT + '/vendor/plugins/activemessaging/lib/activemessaging/filter.rb' unless defined?(ActiveMessaging::Filter)
+    logger.debug "ActiveMessaging: Loading #{APP_ROOT + '/app/processors/application.rb'}" if first
+    load APP_ROOT + '/app/processors/application.rb' if File.exist?("#{APP_ROOT}/app/processors/application.rb")
+    Dir[APP_ROOT + '/app/processors/*.rb'].each do |f|
+      unless f.match(/\/application.rb/)
+        logger.debug "ActiveMessaging: Loading #{f}" if first
+        load f
+      end
+    end
+  end
+  def self.reload_activemessaging
+    # this is resetting the messaging.rb
+    ActiveMessaging::Gateway.filters = []
+    ActiveMessaging::Gateway.named_destinations = {}
+    ActiveMessaging::Gateway.processor_groups = {}
+    # now load the config
+    load_config
+    load_processors(false)
+  end
+  def self.load_activemessaging
+    load_extensions
+    load_config
+    load_processors
+  end
+  def self.start
+    if ActiveMessaging::Gateway.subscriptions.empty?
+      err_msg = <<EOM
+ActiveMessaging Error: No subscriptions.
+If you have no processor classes in app/processors, add them using the command:
+  script/generate processor DoSomething"
+If you have processor classes, make sure they include in the class a call to 'subscribes_to':
+  class DoSomethingProcessor < ActiveMessaging::Processor
+    subscribes_to :do_something
+EOM
+      puts err_msg
+      logger.error err_msg
+      exit
+    end
+    Gateway.start
+  end
+end
+#load these once to start with
+ActiveMessaging.load_activemessaging
+# reload these on each request - leveraging Dispatcher semantics for consistency
+begin
+  require 'dispatcher' unless defined?(::Dispatcher)
+  # add processors and config to on_prepare if supported (rails 1.2+)
+  if ::Dispatcher.respond_to? :to_prepare
+    ::Dispatcher.to_prepare :activemessaging do
+      ActiveMessaging.reload_activemessaging
+    end
+  end
+rescue MissingSourceFile => e
+  logger.info e.message
+  logger.info "Rails not available."
+end

data/lib/activemessaging/adapter.rb ADDED Viewed

@@ -0,0 +1,21 @@
+module ActiveMessaging
+  # include this module to make a new adapter - will register the adapter w/gateway so an be used in connection config
+  module Adapter
+    def self.included(included_by)
+      class << included_by
+        def register adapter_name
+          Gateway.register_adapter adapter_name, self
+        end
+      end
+    end
+    def logger()
+      @@logger = ActiveMessaging.logger unless defined?(@@logger)
+      @@logger
+    end
+  end
+end

data/lib/activemessaging/adapters/asqs.rb ADDED Viewed

@@ -0,0 +1,412 @@
+require 'rubygems'
+require 'net/http'
+require 'openssl'
+require 'base64'
+require 'cgi'
+require 'time'
+require 'activemessaging/adapter'
+module ActiveMessaging
+  module Adapters
+    module AmazonSQS
+      class Connection
+        include ActiveMessaging::Adapter
+        register :asqs
+        QUEUE_NAME_LENGTH = 1..80
+        # MESSAGE_SIZE = 1..(256 * 1024)
+        MESSAGE_SIZE = 1..(8 * 1024)
+        VISIBILITY_TIMEOUT = 0..(24 * 60 * 60)
+        NUMBER_OF_MESSAGES = 1..255
+        GET_QUEUE_ATTRIBUTES = ['All', 'ApproximateNumberOfMessages', 'VisibilityTimeout']
+        SET_QUEUE_ATTRIBUTES = ['VisibilityTimeout']
+        #configurable params
+        attr_accessor :reliable, :reconnectDelay, :access_key_id, :secret_access_key, :aws_version, :content_type, :host, :port, :poll_interval, :cache_queue_list
+        #generic init method needed by a13g
+        def initialize cfg
+            raise "Must specify a access_key_id" if (cfg[:access_key_id].nil? || cfg[:access_key_id].empty?)
+            raise "Must specify a secret_access_key" if (cfg[:secret_access_key].nil? || cfg[:secret_access_key].empty?)
+            @access_key_id=cfg[:access_key_id]
+            @secret_access_key=cfg[:secret_access_key]
+            @request_expires = cfg[:requestExpires]         || 10
+            @request_retry_count = cfg[:requestRetryCount]  || 5
+            @aws_version = cfg[:aws_version]                || '2008-01-01'
+            @content_type = cfg[:content_type]              || 'text/plain'
+            @host = cfg[:host]                              || 'queue.amazonaws.com'
+            @port = cfg[:port]                              || 80
+            @protocol = cfg[:protocol]                      || 'http'
+            @poll_interval = cfg[:poll_interval]            || 1
+            @reconnect_delay = cfg[:reconnectDelay]         || 5
+            @aws_url="#{@protocol}://#{@host}"
+            @cache_queue_list = cfg[:cache_queue_list].nil? ? true : cfg[:cache_queue_list]
+            @reliable =         cfg[:reliable].nil?         ? true : cfg[:reliable]
+            #initialize the subscriptions and queues
+            @subscriptions = {}
+            @current_subscription = 0
+            queues
+        end
+        def disconnect
+          #it's an http request - there is no disconnect - ha!
+        end
+        # queue_name string, headers hash
+        # for sqs, make sure queue exists, if not create, then add to list of polled queues
+        def subscribe queue_name, message_headers={}
+          # look at the existing queues, create any that are missing
+          queue = get_or_create_queue queue_name
+          if @subscriptions.has_key? queue.name
+            @subscriptions[queue.name].add
+          else
+            @subscriptions[queue.name] = Subscription.new(queue.name, message_headers)
+          end
+        end
+        # queue_name string, headers hash
+        # for sqs, attempt delete the queues, won't work if not empty, that's ok
+        def unsubscribe queue_name, message_headers={}
+          if @subscriptions[queue_name]
+            @subscriptions[queue_name].remove
+            @subscriptions.delete(queue_name) if @subscriptions[queue_name].count <= 0
+          end
+        end
+        # queue_name string, body string, headers hash
+        # send a single message to a queue
+        def send queue_name, message_body, message_headers={}
+          queue = get_or_create_queue queue_name
+          send_messsage queue, message_body
+        end
+        # receive a single message from any of the subscribed queues
+        # check each queue once, then sleep for poll_interval
+        def receive
+          raise "No subscriptions to receive messages from." if (@subscriptions.nil? || @subscriptions.empty?)
+          start = @current_subscription
+          while true
+            # puts "calling receive..."
+            @current_subscription = ((@current_subscription < @subscriptions.length-1) ? @current_subscription + 1 : 0)
+            sleep poll_interval if (@current_subscription == start)
+            queue_name = @subscriptions.keys.sort[@current_subscription]
+            queue = queues[queue_name]
+            subscription = @subscriptions[queue_name]
+            unless queue.nil?
+              messages = retrieve_messsages queue, 1, subscription.headers[:visibility_timeout]
+              return messages[0] unless (messages.nil? or messages.empty? or messages[0].nil?)
+            end
+          end
+        end
+        def received message, headers={}
+          begin
+            delete_message message
+          rescue Object=>exception
+            logger.error "Exception in ActiveMessaging::Adapters::AmazonSQS::Connection.received() logged and ignored: "
+            logger.error exception
+          end
+        end
+        def unreceive message, headers={}
+          # do nothing; by not deleting the message will eventually become visible again
+          return true
+        end
+        protected
+        def create_queue(name)
+          validate_new_queue name
+      		response = make_request('CreateQueue', nil, {'QueueName'=>name})
+          add_queue response.get_text("//QueueUrl") unless response.nil?
+        end
+        def delete_queue queue
+          validate_queue queue
+          response = make_request('DeleteQueue', "#{queue.queue_url}")
+        end
+        def list_queues(queue_name_prefix=nil)
+          validate_queue_name queue_name_prefix unless queue_name_prefix.nil?
+          params = queue_name_prefix.nil? ? {} : {"QueueNamePrefix"=>queue_name_prefix}
+      		response = make_request('ListQueues', nil, params)
+          response.nil? ? [] : response.nodes("//QueueUrl").collect{ |n| add_queue(n.text) }
+        end
+        def get_queue_attributes(queue, attribute='All')
+          validate_get_queue_attribute(attribute)
+          params = {'AttributeName'=>attribute}
+          response = make_request('GetQueueAttributes', "#{queue.queue_url}")
+          attributes = {}
+          response.each_node('/GetQueueAttributesResponse/GetQueueAttributesResult/Attribute') { |n|
+            n = n.elements['Name'].text
+            v = n.elements['Value'].text
+            attributes[n] = v
+          }
+          if attribute != 'All'
+            attributes[attribute]
+          else
+            attributes
+          end
+        end
+        def set_queue_attribute(queue, attribute, value)
+          validate_set_queue_attribute(attribute)
+          params = {'Attribute.Name'=>attribute, 'Attribute.Value'=>value.to_s}
+          response = make_request('SetQueueAttributes', "#{queue.queue_url}", params)
+        end
+        def delete_queue queue
+          validate_queue queue
+          response = make_request('DeleteQueue', "#{queue.queue_url}")
+        end
+        # in progress
+        def send_messsage queue, message
+          validate_queue queue
+          validate_message message
+          response = make_request('SendMessage', queue.queue_url, {'MessageBody'=>message})
+          response.get_text("//MessageId") unless response.nil?
+        end
+        def retrieve_messsages queue, num_messages=1, timeout=nil
+          validate_queue queue
+          validate_number_of_messages num_messages
+          validate_timeout timeout if timeout
+          params = {'MaxNumberOfMessages'=>num_messages.to_s}
+          params['VisibilityTimeout'] = timeout.to_s if timeout
+          response = make_request('ReceiveMessage', "#{queue.queue_url}", params)
+          response.nodes("//Message").collect{ |n| Message.from_element n, response, queue } unless response.nil?
+        end
+        def delete_message message
+          response = make_request('DeleteMessage', "#{message.queue.queue_url}", {'ReceiptHandle'=>message.receipt_handle})
+        end
+      	def make_request(action, url=nil, params = {})
+          # puts "make_request a=#{action} u=#{url} p=#{params}"
+      	  url ||= @aws_url
+      		# Add Actions
+      		params['Action'] = action
+      		params['Version'] = @aws_version
+      		params['AWSAccessKeyId'] = @access_key_id
+      		params['Expires']= (Time.now + @request_expires).gmtime.iso8601
+      		params['SignatureVersion'] = '1'
+      		# Sign the string
+      		sorted_params = params.sort_by { |key,value| key.downcase }
+      		joined_params = sorted_params.collect { |key, value| key.to_s + value.to_s }
+      		string_to_sign = joined_params.to_s
+      		digest = OpenSSL::Digest::Digest.new('sha1')
+          hmac = OpenSSL::HMAC.digest(digest, @secret_access_key, string_to_sign)
+          params['Signature'] = Base64.encode64(hmac).chomp
+          # Construct request
+          query_params = params.collect { |key, value| key + "=" + CGI.escape(value.to_s) }.join("&")
+          # Put these together to get the request query string
+          request_url = "#{url}?#{query_params}"
+          # puts "request_url = #{request_url}"
+          request = Net::HTTP::Get.new(request_url)
+          retry_count = 0
+          while retry_count < @request_retry_count.to_i
+      		  retry_count = retry_count + 1
+            # puts "make_request try retry_count=#{retry_count}"
+            begin
+              response = SQSResponse.new(http_request(host,port,request))
+              check_errors(response)
+              return response
+            rescue Object=>ex
+              # puts "make_request caught #{ex}"
+              raise ex unless reliable
+        		  sleep(@reconnect_delay)
+            end
+          end
+        end
+        # I wrap this so I can move to a different client, or easily mock for testing
+        def http_request h, p, r
+          return Net::HTTP.start(h, p){ |http| http.request(r) }
+        end
+        def check_errors(response)
+          raise "http response was nil" if (response.nil?)
+          raise response.errors if (response && response.errors?)
+          response
+        end
+        private
+        # internal data structure methods
+        def add_queue(url)
+          q = Queue.from_url url
+          queues[q.name] = q if self.cache_queue_list
+          return q
+        end
+        def get_or_create_queue queue_name
+          qs = queues
+          qs.has_key?(queue_name) ? qs[queue_name] : create_queue(queue_name)
+        end
+        def queues
+          return @queues if (@queues && cache_queue_list)
+          @queues = {}
+          list_queues.each{|q| @queues[q.name]=q }
+          return @queues
+        end
+        # validation methods
+        def validate_queue_name qn
+          raise "Queue name, '#{qn}', must be between #{QUEUE_NAME_LENGTH.min} and #{QUEUE_NAME_LENGTH.max} characters." unless QUEUE_NAME_LENGTH.include?(qn.length)
+          raise "Queue name, '#{qn}', must be alphanumeric only." if (qn =~ /[^\w\-\_]/ )
+        end
+        def validate_new_queue qn
+          validate_queue_name qn
+          raise "Queue already exists: #{qn}" if queues.has_key? qn
+        end
+        def validate_queue q
+            raise "Never heard of queue, can't use it: #{q.name}" unless queues.has_key? q.name
+        end
+        def validate_message m
+          raise "Message cannot be nil." if m.nil?
+          raise "Message length, #{m.length}, must be between #{MESSAGE_SIZE.min} and #{MESSAGE_SIZE.max}." unless MESSAGE_SIZE.include?(m.length)
+        end
+        def validate_timeout to
+          raise "Timeout, #{to}, must be between #{VISIBILITY_TIMEOUT.min} and #{VISIBILITY_TIMEOUT.max}." unless VISIBILITY_TIMEOUT.include?(to)
+        end
+        def validate_get_queue_attribute qa
+          raise "Queue Attribute name, #{qa}, not in list of valid attributes to get: #{GET_QUEUE_ATTRIBUTES.to_sentence}." unless GET_QUEUE_ATTRIBUTES.include?(qa)
+        end
+        def validate_set_queue_attribute qa
+          raise "Queue Attribute name, #{qa}, not in list of valid attributes to set: #{SET_QUEUE_ATTRIBUTES.to_sentence}." unless SET_QUEUE_ATTRIBUTES.include?(qa)
+        end
+        def validate_number_of_messages nom
+          raise "Number of messages, #{nom}, must be between #{NUMBER_OF_MESSAGES.min} and #{NUMBER_OF_MESSAGES.max}." unless NUMBER_OF_MESSAGES.include?(nom)
+        end
+      end
+      class SQSResponse
+        attr_accessor :headers, :doc, :http_response
+        def initialize response
+          # puts "response.body = #{response.body}"
+          @http_response = response
+          @headers = response.to_hash()
+          @doc = REXML::Document.new(response.body)
+        end
+        def message_type
+          return doc ? doc.root.name : ''
+        end
+        def errors?
+          (not http_response.kind_of?(Net::HTTPSuccess)) or (message_type == "ErrorResponse")
+        end
+        def errors
+          return "HTTP Error: #{http_response.code} : #{http_response.message}" unless http_response.kind_of?(Net::HTTPSuccess)
+          msg = nil
+          each_node('//Error') { |n|
+            msg ||= ""
+            c = n.elements['Code'].text
+            m = n.elements['Message'].text
+            msg << ", " if msg != ""
+            msg << "#{c} : #{m}"
+          }
+          return msg
+        end
+        def get_text(xpath,default='')
+          e = REXML::XPath.first( doc, xpath)
+          e.nil? ? default : e.text
+        end
+        def each_node(xp)
+          REXML::XPath.each(doc.root, xp) {|n| yield n}
+        end
+        def nodes(xp)
+          doc.elements.to_a(xp)
+        end
+      end
+      class Subscription
+        attr_accessor :name, :headers, :count
+        def initialize(destination, headers={}, count=1)
+          @destination, @headers, @count = destination, headers, count
+        end
+        def add
+          @count += 1
+        end
+        def remove
+          @count -= 1
+        end
+      end
+      class Queue
+        attr_accessor :name, :pathinfo, :domain, :visibility_timeout
+        def self.from_url url
+          return Queue.new($2,$1) if (url =~ /^http:\/\/(.+)\/([-a-zA-Z0-9_]+)$/)
+          raise "Bad Queue URL: #{url}"
+        end
+        def queue_url
+          "#{pathinfo}/#{name}"
+        end
+        def initialize name, domain, vt=nil
+          @name, @pathinfo, @domain, @visibility_timeout = name, pathinfo, domain, vt
+        end
+        def to_s
+          "<AmazonSQS::Queue name='#{name}' url='#{queue_url}' domain='#{domain}'>"
+        end
+      end
+      # based on stomp message, has pointer to the SQSResponseObject
+      class Message
+        attr_accessor :headers, :id, :body, :command, :response, :queue, :md5_of_body, :receipt_handle
+        def self.from_element e, response, queue
+          Message.new(response.headers, e.elements['MessageId'].text, e.elements['Body'].text, e.elements['MD5OfBody'].text, e.elements['ReceiptHandle'].text, response, queue)
+        end
+        def initialize headers, id, body, md5_of_body, receipt_handle, response, queue, command='MESSAGE'
+          @headers, @id, @body, @md5_of_body, @receipt_handle, @response, @queue, @command =  headers, id, body, md5_of_body, receipt_handle, response, queue, command
+          headers['destination'] = queue.name
+        end
+        def to_s
+          "<AmazonSQS::Message id='#{id}' body='#{body}' headers='#{headers.inspect}' command='#{command}' response='#{response}'>"
+        end
+      end
+    end
+  end
+end