RubyGems - activemessaging - Versions diffs - 0.6.0 - Mend

activemessaging 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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