jungle 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+= 0.1.0
+
+* initial release

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/jungle.rb
+lib/jungle/client.rb
+lib/jungle/support.rb
+lib/jungle/version.rb
+test/example.rb
+test/jungle_test.rb
+test/test.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,63 @@
+Jungle
+	http://jungle.rubyforge.org/
+	by Tom Preston-Werner
+
+== DESCRIPTION:
+
+Jungle is a client library for the Amazon SQS (Simple Queue Service). It provides an intuitive, well documented API and a fully tested codebase.
+
+== INSTALLATION:
+
+Jungle can be installed via RubyGems:
+
+  $ sudo gem install jungle
+
+== USAGE:
+
+In order to use Jungle to interface with Amazon web services, you must first sign up for a web services account at http://amazonaws.com. Once you have an account, you'll need to locate your access key (20 bytes long) and secret access key (40 bytes long). It is important to keep your secret access key secure (take necessary precautions when deploying code that contains your AWS credentials). With your credentials handy, you can create a Jungle client.
+
+  require 'rubygems'
+  require 'jungle'
+
+  client = Jungle::Client.new('1234567890ABCDEFGHIJ', '1234567890abcdefghijklmnopqrstuvwxyz1234')
+
+From the client, you can get access to an SQS client, on which you can execute SQS commands.
+
+The first thing you'll need to do is create a queue:
+
+  client.sqs.create_queue('foo')
+
+Once you've created the queue, you can send messages to it:
+
+  client.sqs.send_message('foo', "Help, I'm trapped in a REPL!")
+
+Messages are always placed on the back of the queue. To retrieve a message from the front of the queue:
+
+  message = client.sqs.receive_message('foo')
+
+The call to Jungle::SQSClient#receive_message will return a single Jungle::SQSMessage by default. From this you can get the message's id and body.
+
+  message.id #=> "1AM3Q5BE7ZZRNQD8MEY6|3H4AA8J7EJKM0DQZR7E1|9CBMKVD6TTQX44QJ1S30"
+  message.body #=> "Help, I'm trapped in a REPL!"
+
+When you make a call to Jungle::SQSClient#receive_message, the message(s) that are returned will be invisible to other receive_message calls for 30 seconds. This prevents two clients from receiving the same message, but still allows the message to be handled after the timeout. You can specify a different visibility timeout when you create the queue:
+
+  client.sqs.create_queue('bar', { :visibility_timeout => '60' })
+
+Alternatively, you can specify a visibility timeout for a specific message when you place it on the queue.
+
+  client.sqs.send_message('foo', { :visibility_timeout => '15' })
+
+If you have the id of a message handy and you'd like to get that message without locking it, you can peek at it:
+
+  unlocked_message = client.sqs.peek_message('foo', message.id)
+
+  unlocked_message.id #=> "1AM3Q5BE7ZZRNQD8MEY6|3H4AA8J7EJKM0DQZR7E1|9CBMKVD6TTQX44QJ1S30"
+  unlocked_message.body #=> "Help, I'm trapped in a REPL!"
+
+Once you've handled the message, you'll want to remove it permanently from the queue:
+
+  client.sqs.delete_message('foo', message.id)
+
+You need to specify both the queue and the message id in order to delete the message.
+

data/Rakefile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/jungle.rb'
+
+Hoe.new('jungle', Jungle::VERSION) do |p|
+  p.rubyforge_name = 'jungle'
+  p.summary = 'A pure Ruby client library for Amazon\'s SQS business web services.'
+  p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.need_tar = false
+  p.extra_deps = []
+end

data/lib/jungle.rb

@@ -0,0 +1,9 @@
+require 'base64'
+require 'openssl'
+require 'digest/sha1'
+require 'net/https'
+require 'delegate'
+require 'rexml/document'
+require 'yaml'
+
+Dir[File.join(File.dirname(__FILE__), 'jungle/**/*.rb')].sort.each { |lib| require lib }

data/lib/jungle/client.rb

@@ -0,0 +1,591 @@
+module Jungle
+  class Client
+    # Return a new Jungle client on which you get SQS or S3 clients and make requests to Amazon AWS
+    #   +access_key_id+ is an AWS access key (20 bytes long)
+    #   +secret_access_key+ is an AWS secret access key used to compute HMAC:SHA1 (40 bytes)
+    def initialize(access_key_id = nil, secret_access_key = nil)
+      @auth = Auth.new(access_key_id, secret_access_key)
+    end
+    
+    # Return an SQSClient with the credentials of this Client. The returned object is
+    # a singleton, and as such the same instance will be returned for all calls to this
+    # method on this client
+    def sqs
+      @sqs ||= SQSClient.new(@auth)
+    end
+  end
+  
+  class AWSClient
+    protected
+    
+    # Return a connection from the connection pool (or block until one is available)
+    # This method must be overridden by AWSClient subclasses
+    def get_connection_from_pool
+      raise(Exception, "AWS#get_connection_from_pool must be overridden in subclasses")
+    end
+    
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+    
+    # Construct a url from the given path and query parameters
+    def construct_url(path, query_params = {})
+      query_part = query_params.keys.map { |key| "#{camelize(key)}=#{query_params[key]}" }.join('&')
+      
+      base = query_part.size != 0 ? (path == '' ? '/?' : '?') : ''
+            
+      path << base << query_part
+    end
+    
+    # Make a REST call
+    def rest_call(host, path, query, security_params, data = '', headers = {})
+      connection = get_connection_from_pool()
+            
+      connection.set_debug_output($stdout) if debug()
+      
+      connection.start do
+        request = method_to_request_class(security_params['method']).new(construct_url(path, query))
+        
+        security_headers = {'Authorization' => security_params['auth_string'],
+                            'Date' => security_params['date'],
+                            'AWS-Version' => '2006-04-01',
+                            'Content-Type' => 'text/plain'}
+
+        set_headers(request, headers)        
+        set_headers(request, security_headers)
+        
+        if request.request_body_permitted?
+          return connection.request(request, data)
+        else
+          return connection.request(request)
+        end
+      end
+    end
+    
+    # Return the corresponding Net:HTTP class for the given method
+    #   +method+ is one of "get", "post", put", or "delete"
+    def method_to_request_class(method)
+      method =~ /(get|post|put|delete)/i || raise(InvalidArgument, "method must be a valid HTTP method")
+      Net::HTTP.const_get(method.capitalize.intern)
+    end
+    
+    # Add the given headers to the request
+    #   +request+ is the request
+    #   +headers+ is a hash containing key, value pairs
+    #   +prefix+ is a string that will be appended to each key
+    def set_headers(request, headers, prefix='')
+      headers.each do |key, value|
+        request[prefix + key] = value
+      end
+    end
+  end
+  
+  class SQSClient < AWSClient
+    attr_accessor :service_url
+    attr_accessor :debug
+    attr_reader :mode
+    
+    # Return a new SQSClient
+    #   +auth+ is a Jungle::Auth object with knowledge of authentication credentials
+    def initialize(auth)
+      @auth = auth
+      @debug = false
+      
+      @mode = :lazy
+      @queue_lookup = {}
+      
+      self.service_url = "queue.amazonaws.com"
+    end
+    
+    # An SQSClient may be in one of two modes: lazy or strict. In strict mode,
+    # calls to send_message and receive_message must specify the full queue path
+    # (e.g. A8SVKWT62YDQI/foo). Lazy mode allows you to specify just the queue
+    # name (e.g. foo) and will make a call to create_queue to look up the queue
+    # path for a given queue name. As queue paths are cached by the client, this
+    # process only happens once.
+    #   +mode+ is a symbol representing the mode to be set, either :lazy or :strict
+    #          (default :lazy)
+    def mode=(mode)
+      [:lazy, :strict].include?(mode) || raise(InvalidArgument, "Mode must be either :lazy or :strict")
+      @mode = mode
+    end
+    
+    # Create a new queue with the given name. If the queue already exists, the
+    # operation returns the same response as if it had just been created.
+    #   +name+ is the name of the queue you wish to create, e.g. Foo
+    #   +options+ is a hash that may specify the following options:
+    #     +visibility_timeout+ is the visibility timeout to set as the default for
+    #                          new messages on this queue
+    #
+    # The response has the following readers:
+    #   #operation - :create_queue
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    #   #queue_url - the queue path that was created
+    def create_queue(name, options = {})
+      validate_queue_name(name)
+      
+      # construct request url string
+      path = ''
+      query = {'QueueName' => name}
+      query.merge! options
+      
+      # get security params as a hash
+      security_params = @auth.security_params('POST', path)
+      
+      # make the call
+      http_response = rest_call(self.service_url, path, query, security_params)
+      
+      # create the sqs response
+      sqs_response = SQSResponseFactory.manufacture(:create_queue, http_response)
+      
+      # add to queue lookup if response was success and mode is lazy
+      if @mode == :lazy && sqs_response.code == 200
+        @queue_lookup[name] ||= sqs_response.queue_url
+      end
+      
+      sqs_response
+    end
+    
+    # List the available queues on this account (up to 10,000).
+    #   +options+ is a hash that may specify the following options:
+    #     +queue_name_prefix+ is a string that, if specified, will cause
+    #                         only queues that start with the given string
+    #                         to be returned.
+    #
+    # The response has the following readers:
+    #   #operation - :list_queues
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    #   #queue_urls - an array of queue urls
+    def list_queues(options = {})
+      # construct request url string
+      path = ''
+      query = options
+      
+      # get security params as a hash
+      security_params = @auth.security_params('GET', path)
+      
+      # make the call
+      http_response = rest_call(self.service_url, path, query, security_params)
+      
+      # create the sqs response
+      SQSResponseFactory.manufacture(:list_queues, http_response)
+    end
+    
+    # Put the specified message on the given queue
+    #   +queue+ is the name of the queue on which to add the message
+    #   +message+ is the data that this message should contain. Must be between 1 and 256k bytes
+    #
+    # The response has the following readers:
+    #   #operation - :send_message
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    #   #message_id - the id of the just created message
+    def send_message(queue, message)
+      validate_queue_name(queue)
+      validate_message(message)
+      
+      # if in lazy mode, find queue path
+      queue_path = resolve_queue_path(queue)
+      
+      # construct request url string
+      path = '/' << queue_path << '/back'
+      query = {}
+      
+      # get security params as a hash
+      security_params = @auth.security_params('PUT', path)
+      
+      # prepare the message
+      payload = message
+      
+      # make the call
+      response = rest_call(self.service_url, path, query, security_params, payload)
+      
+      # return the response
+      SQSResponseFactory.manufacture(:send_message, response)
+    end
+    
+    # Receive a message from the given queue
+    #   +queue+ is the name (lazy mode) or path (strict mode) of the queue
+    #   +options+ is a hash that may specify the following options:
+    #     +number_of_messages+ is the maximum number of messages to return. If the number
+    #                          of messages in the queue is less than the value specified
+    #                          then all of the remaining messages will be received (default 1)
+    #     +visibility_timeout+ is the duration, in seconds, that the received message or messages
+    #                          will not be visible to other receive_message calls.
+    #
+    # The response has the following readers:
+    #   #operation - :receive_message
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    #   #messages - an array of SQSMessage objects
+    #
+    # An SQSMessage has the following readers:
+    #   #id - the id of the message
+    #   #body - the body of the message
+    def receive_messages(queue, options = {})
+      validate_queue_name(queue)
+      
+      queue_path = resolve_queue_path(queue)
+      
+      # construct request url string
+      path = '/' << queue_path << '/front'
+      query = options
+      
+      # get security params as a hash
+      security_params = @auth.security_params('GET', path)
+      
+      # make the call
+      response = rest_call(self.service_url, path, query, security_params)
+      
+      # return the response
+      SQSResponseFactory.manufacture(:receive_message, response, {:queue_path => queue_path})
+    end
+    
+    # Receive a single message from the given queue
+    #   +queue+ is the name (lazy mode) or path (strict mode) of the queue
+    #   +options+ is a hash that may specify the following options:
+    #     +visibility_timeout+ is the duration, in seconds, that the received message
+    #                          will not be visible to other receive_message or
+    #                          receive messages calls.
+    #
+    # The response has the following readers:
+    #   #operation - :receive_message
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    #   #message - the SQSMessage object or nil if none were returned
+    #
+    # An SQSMessage has the following readers:
+    #   #id - the id of the message
+    #   #body - the body of the message
+    def receive_message(queue, options = {})
+      local_options = { :number_of_messages => 1 }
+      receive_messages(queue, options.merge(local_options))
+    end
+    
+    # Delete a message
+    #   +queue+ is the name (lazy mode) or path (strict mode) of the queue
+    #   +message_id+ is the message id of the message
+    #
+    # The response has the following readers:
+    #   #operation - :delete_message
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    def delete_message(message_or_queue, message_id = nil)
+      message_values = {}
+      
+      if message_or_queue.instance_of? SQSMessage
+        message = message_or_queue
+        message_values[:queue_path] = message.queue_path
+        message_values[:id] = message.id
+      else
+        queue = message_or_queue
+        validate_queue_name(queue)
+        message_values[:queue_path] = resolve_queue_path(queue)
+        message_values[:id] = message_id
+      end
+      
+      # construct request url string
+      path = '/' << message_values[:queue_path] << '/' << message_values[:id]
+      query = {}
+      
+      # get security params as a hash
+      security_params = @auth.security_params('DELETE', path)
+      
+      # make the call
+      response = rest_call(self.service_url, path, query, security_params)
+      
+      # return the response
+      SQSResponseFactory.manufacture(:delete_message, response)
+    end
+    
+    # Look at a message without deleting it from the queue or changing its
+    # visibility.
+    #   +queue+ is the name (lazy mode) or path (strict mode) of the queue (see mode=)
+    #   +message_id+ is the message id of the message
+    #
+    # The response has the following readers:
+    #   #operation - :peek_message
+    #   #code - the http response code (200 on success)
+    #   #xml - the full xml body that was returned with the request
+    #   #message - the SQSMessage
+    #
+    # An SQSMessage has the following readers:
+    #   #id - the id of the message
+    #   #body - the body of the message
+    def peek_message(queue, message_id)
+      validate_queue_name(queue)
+      
+      queue_path = resolve_queue_path(queue)
+      
+      # construct request url string
+      path = '/' << queue_path << '/' << message_id
+      query = {}
+      
+      # get security params as a hash
+      security_params = @auth.security_params('GET', path)
+      
+      # make the call
+      response = rest_call(self.service_url, path, query, security_params)
+      
+      # return the response
+      SQSResponseFactory.manufacture(:peek_message, response)
+    end
+    
+    protected
+    
+    # Return a pooled http connection for this service. If none are available,
+    # block until one becomes available, then return it
+    def get_connection_from_pool
+      http = Net::HTTP.new(self.service_url, 443)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http
+    end
+    
+    private
+    
+    # Validate the queue. The queue should not begin with a protocol specifier or a slash.
+    #   +queue+ is the queue string
+    def validate_queue_name(queue)
+      queue !~ /(http|https|ftp|ssh):\/\// || raise(InvalidArgument, "name should be JUST queue name, not a full URL")
+      queue !~ /^\// || raise(InvalidArgument, "name must not start with a slash")
+    end
+    
+    # Validate the given message. The message must be between 1 and 256k bytes
+    #   +message+ is the message string
+    def validate_message(message)
+      message.size < (256 * 1024) || raise(InvalidArgument, "message must be less than 256Kb")
+    end
+    
+    def resolve_queue_path(queue)
+      # if in lazy mode, find real queue name
+      if @mode == :lazy
+        if queue_path = @queue_lookup[queue]
+          # queue name is in lookup
+          return queue_path
+        else
+          # queue name not in lookup, make a service request to get it
+          res = create_queue(queue)
+          res.code == 200 || raise(InternalError, "Request to CreateQueue failed (looking up queue name)")
+          return res.queue_url
+        end
+      else
+        return queue
+      end
+    end
+  end
+  
+  class Auth
+    
+    def self.config_file=(file)
+      @config_file = file
+    end
+    
+    def self.config_file
+      @config_file
+    end
+    
+    # Return a new Auth
+    #   +access_key_id+ is an AWS access key (20 bytes long)
+    #   +secret_access_key+ is an AWS secret access key used to compute HMAC:SHA1 (40 bytes)
+    def initialize(access_key_id = nil, secret_access_key = nil)
+      if access_key_id.nil? && secret_access_key.nil?
+        # get credentials from config file
+        config_file = Auth.config_file || "jungle.yml"
+        config_file_contents = File.open(config_file).read
+        config = YAML::load(config_file_contents)
+        
+        access_key_id = config['jungle']['access_key_id']
+        secret_access_key = config['jungle']['secret_access_key']
+      else
+        raise(InvalidArgument, 'access_key_id must be 20 bytes') unless access_key_id.size == 20
+        raise(InvalidArgument, 'secret_access_key must be 40 bytes') unless secret_access_key.size == 40
+      end
+      
+      @access_key_id = access_key_id
+      @secret_access_key = secret_access_key
+    end
+    
+    # Return the security params for the given request
+    #   +method+ is the HTTP method. One of GET, POST, PUT, DELETE
+    #   +path+ is the full REST url, e.g. http://example.com/foo?bar=baz
+    def security_params(method, path)
+      params = base_params(method, path)
+            
+      signed_canonical_string = hmac_signature(canonical_string(params), @secret_access_key)
+
+      params.merge({'signed_canonical_string' => signed_canonical_string,
+                    'auth_string' => "AWS #{@access_key_id}:#{signed_canonical_string}"})
+    end
+    
+    private
+    
+    # Compute an HMAC:SHA1 signature of the given string with the given key by
+    # taking the hmac-sha1 sum, and then base64 encoding it.Optionally, it
+    # will also url encode the result of that to protect the string if it's
+    # going to be used as a query string parameter.
+    def hmac_signature(string, key, urlencode = false)
+      digest = OpenSSL::Digest::Digest.new('sha1')
+      b64_hmac = Base64.encode64(OpenSSL::HMAC.digest(digest, key, string)).strip
+
+      if urlencode
+        return CGI::escape(b64_hmac)
+      else
+        return b64_hmac
+      end
+    end
+    
+    # Construct the base params for use in a request
+    #   +method+ is the HTTP method. One of GET, POST, PUT, DELETE
+    #   +path+ is the full REST url, e.g. http://example.com/foo?bar=baz
+    def base_params(method, path)
+      # ensure path is acceptable
+      path !~ /http:\/\// || raise(InvalidArgument, "path must not include protocol or domain")
+      
+      # create the resource path
+      path.chomp!
+      resource = path
+      resource << '/' if resource == ''
+      
+      security_params = {'method' => method,
+                         'resource' => resource,
+                         'md5_signature' => '',
+                         'date' => Time.now.httpdate,
+                         'content_type' => 'text/plain',
+                         'access_key_id' => @access_key_id,
+                         'secret_access_key_id' => @secret_access_key
+                         }
+    end
+    
+    # Construct the canonical string used in the HMAC:SHA1 to authorize AWS requests
+    #   +params+ is the result of a call to #base_params
+    def canonical_string(params)
+      buf = []
+      buf << params['method']
+      buf << params['md5_signature']
+      buf << params['content_type']
+      buf << params['date']
+      buf << params['resource']
+      buf.join("\n")
+    end
+  end
+  
+  # Contains a message that has been received from a queue.
+  class SQSMessage
+    attr_accessor :id, :body, :queue_path
+    
+    def initialize(queue_path, xml)
+      @queue_path = queue_path
+      m, @id, @body = *xml.match(/<MessageId>(.*?)<\/MessageId><MessageBody>(.*?)<\/MessageBody>/m)
+    end
+    
+    def inspect
+      puts "#<Message id:#{@id} body:#{@body}>"
+    end
+  end
+  
+  class SQSResponseFactory
+    Struct.new("SQSErrorResponse", :operation, :code, :xml)
+    
+    Struct.new("SQSCreateQueueResponse", :operation, :code, :xml, :queue_url)
+    Struct.new("SQSListQueuesResponse", :operation, :code, :xml, :queue_urls)
+    Struct.new("SQSSendMessageResponse", :operation, :code, :xml, :message_id)
+    Struct.new("SQSReceiveMessageResponse", :operation, :code, :xml, :messages)
+    Struct.new("SQSDeleteMessageResponse", :operation, :code, :xml)
+    Struct.new("SQSPeekMessageResponse", :operation, :code, :xml, :message)
+    
+    class Struct::SQSReceiveMessageResponse
+      def message
+        messages.first
+      end
+    end
+    
+    def self.manufacture(operation, response, options = nil)
+      begin
+        if options
+          self.send(operation.to_s + "_response", operation, response, options)
+        else
+          self.send(operation.to_s + "_response", operation, response)
+        end
+      rescue
+        raise
+        raise(InternalError, "operation #{operation} not implemented")
+      end
+      
+      # case operation
+      # when :create_queue: self.create_queue_response(operation, response)
+      # when :list_queues: self.list_queues_response(operation, response)
+      # when :send_message: self.send_message_response(operation, response)
+      # when :receive_message: self.receive_message_response(operation, response)
+      # else raise(InternalError, "operation #{operation} not implemented")
+      # end
+    end
+    
+    def self.create_queue_response(operation, response)
+      if response.is_a? Net::HTTPSuccess
+        xml = response.read_body
+        m, queue_url = *xml.match(/<QueueUrl>http:\/\/.*?\/(.*?)<\/QueueUrl>/)
+        Struct::SQSCreateQueueResponse.new(operation, response.code.to_i, xml, queue_url)
+      else
+        Struct::SQSErrorResponse.new(operation, response.code.to_i, response.read_body)
+      end
+    end
+    
+    def self.list_queues_response(operation, response)
+      if response.is_a? Net::HTTPSuccess
+        xml = response.read_body
+        queue_urls = xml.scan(/<QueueUrl>(.+?)<\/QueueUrl>/m).flatten
+        Struct::SQSListQueuesResponse.new(operation, response.code.to_i, xml, queue_urls)
+      else
+        Struct::SQSErrorResponse.new(operation, response.code.to_i, response.read_body)
+      end
+    end
+    
+    def self.send_message_response(operation, response)
+      if response.is_a? Net::HTTPSuccess
+        xml = response.read_body
+        m, message_id = *xml.match(/<MessageId>(.*?)<\/MessageId>/)
+        Struct::SQSCreateQueueResponse.new(operation, response.code.to_i, xml, message_id)
+      else
+        Struct::SQSErrorResponse.new(operation, response.code.to_i, response.read_body)
+      end
+    end
+    
+    def self.receive_message_response(operation, response, options)
+      if response.is_a? Net::HTTPSuccess
+        xml = response.read_body
+        messages = xml.scan(/<Message>.*?<\/Message>/m).map { |message_xml| SQSMessage.new(options[:queue_path], message_xml) }
+        Struct::SQSReceiveMessageResponse.new(operation, response.code.to_i, xml, messages)
+      else
+        Struct::SQSErrorResponse.new(operation, response.code.to_i, response.read_body)
+      end
+    end
+    
+    def self.delete_message_response(operation, response)
+      if response.is_a? Net::HTTPSuccess
+        xml = response.read_body
+        Struct::SQSDeleteMessageResponse.new(operation, response.code.to_i, xml)
+      else
+        Struct::SQSErrorResponse.new(operation, response.code.to_i, response.read_body)
+      end
+    end
+    
+    def self.peek_message_response(operation, response)
+      if response.is_a? Net::HTTPSuccess
+        xml = response.read_body
+        m, message_xml = *xml.match(/<Message>.*?<\/Message>/)
+        message = SQSMessage.new(message_xml)
+        Struct::SQSPeekMessageResponse.new(operation, response.code.to_i, xml, message)
+      else
+        Struct::SQSErrorResponse.new(operation, response.code.to_i, response.read_body)
+      end
+    end
+    
+  end
+end

data/lib/jungle/support.rb

@@ -0,0 +1,9 @@
+module Jungle
+  class InvalidArgument < Exception
+    
+  end
+  
+  class InternalError < Exception
+    
+  end
+end

data/lib/jungle/version.rb

@@ -0,0 +1,3 @@
+module Jungle #:nodoc:
+  VERSION = "0.1.0"
+end

data/test/example.rb

@@ -0,0 +1,25 @@
+require 'jungle'
+
+jungle_client = Jungle::Client.new.sqs
+
+1.upto(4) do |i|
+  puts 'put message'
+  jungle_client.send_message('numbers', "#{i} bottles of beer on the wall")
+end
+
+threads = []
+
+2.times do
+  threads << Thread.new(jungle_client) do |client|
+    while true
+      res = client.receive_message('numbers')
+      break unless res.code == 200 && res && res.message
+      puts res.message.body
+      client.delete_message(res.message)
+    end
+  end
+end
+
+threads.each do |thread|
+  thread.join
+end

data/test/jungle_test.rb

@@ -0,0 +1,370 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The void" do
+  specify "should allow the creation of a Jungle::Client" do
+    lambda { Jungle::Client.new }.should_not_raise
+  end
+end
+
+
+context "A Jungle::Client" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should have an sqs method" do
+    @client.should_not_be nil
+    lambda { @client.sqs }.should_not_raise
+    @client.sqs.should.be.instance_of? Jungle::SQSClient
+  end
+  
+  specify "should return the same SQSClient for each call to #sqs" do
+    sqs1 = @client.sqs
+    sqs2 = @client.sqs
+    sqs1.object_id.should.be.equal sqs2.object_id
+  end
+end
+
+
+context "A Jungle::AWSClient construct_url call" do
+  setup do
+    @client = Jungle::AWSClient.new
+  end
+  
+  specify "should generate the proper url" do
+    @client.bypass.construct_url("").should == ""
+    @client.bypass.construct_url("", {'FooBar' => 'baz'}).should == "/?FooBar=baz"
+    
+    @client.bypass.construct_url("/foo").should == "/foo"
+    @client.bypass.construct_url("/foo", {'FooBar' => 'baz'}).should == "/foo?FooBar=baz"
+  end
+  
+  specify "should throw an exception on bad input data" do
+    
+  end
+end
+
+
+# context "A Jungle::AWSClient make_request call" do
+#   setup do
+#     @client = Jungle::AWSClient.new
+#   end
+#   
+#   specify "should " do
+#     @client.bypass.make_request('POST', 'foo')
+#   end
+# end
+
+
+context "A Jungle::AWSClient get_connection_from_pool call" do
+  setup do
+    @client = Jungle::AWSClient.new
+  end
+  
+  specify "should raise an exception" do
+    lambda { @client.get_connection_from_pool }.should_raise
+  end
+end
+
+
+context "A Jungle::AWSClient method_to_request_class call" do
+  setup do
+    @client = Jungle::AWSClient.new
+  end
+  
+  specify "should return a request class for valid HTTP methods" do
+    @client.bypass.method_to_request_class('GET').should == Net::HTTP::Get
+    @client.bypass.method_to_request_class('Post').should == Net::HTTP::Post
+    @client.bypass.method_to_request_class('put').should == Net::HTTP::Put
+    @client.bypass.method_to_request_class('DeLeTe').should == Net::HTTP::Delete
+  end
+  
+  specify "should raise an exception on invalid method" do
+    lambda { @client.bypass.method_to_request_class('Foo') }.should_raise
+  end
+end
+
+
+context "A Jungle::Client::SQSClient" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should respond to create_queue" do
+    lambda { @client.sqs.create_queue('foo') }.should_not_raise
+  end
+end
+
+
+context "A Jungle::Client::SQSClient get_connection_from_pool call" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should return a Net::HTTP object" do
+    @client.sqs.bypass.get_connection_from_pool.should_be_an_instance_of Net::HTTP
+  end
+end
+
+
+context "A Jungle::Client::SQSClient validate_message call" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should not raise on messages less than 256Kb in length" do
+    lambda { @client.sqs.bypass.validate_message('foo') }.should_not_raise
+  end
+  
+  specify "should raise on messages more than 256Kb in length" do
+    big_message = ''
+    (257 * 1024).times { big_message << 'a' }
+    big_message.size.should == 257 * 1024
+    lambda { @client.sqs.bypass.validate_message(big_message) }.should_raise
+  end
+end
+
+
+context "A Jungle::Client::SQSClient create_queue call" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should not accept full URL queue names" do
+    lambda { @client.sqs.create_queue('http://example.com/foo') }.should_raise
+  end
+  
+  specify "should not accept queue names that start with a slash" do
+    lambda { @client.sqs.create_queue('/foo') }.should_raise
+  end
+  
+  specify "should accept simple string names" do
+    lambda { @client.sqs.create_queue('foo') }.should_not_raise
+  end
+  
+  specify "should return success" do
+    #@client.sqs.debug = true
+    res = @client.sqs.create_queue('foo')
+    res.code.should == 200
+  end
+  
+  specify "should return the queue name part of the new queue" do
+    res = @client.sqs.create_queue('foo')
+    res.queue_url.should.match(/.*?\/foo/)
+  end
+end
+
+
+context "A Jungle::Client::SQSClient send_message call" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should accept a message on an existing queue in strict mode" do
+    #@client.sqs.debug = true
+    @client.sqs.mode = :strict
+    
+    res = @client.sqs.create_queue('foo')
+    qurl = res.queue_url
+    
+    lambda { @client.sqs.send_message(qurl, 'ping') }.should_not_raise
+  end
+  
+  specify "should return error on non existing queue in strict mode" do
+    #@client.sqs.debug = true
+    @client.sqs.mode = :strict
+    
+    res = @client.sqs.send_message('foo', 'ping')
+    res.code.should_not == 200
+  end
+  
+  specify "should accept a message on an existing queue in lazy mode" do
+    #@client.sqs.debug = true
+    
+    @client.sqs.create_queue('foo')
+    
+    lambda { @client.sqs.send_message('foo', 'ping') }.should_not_raise
+  end
+  
+  specify "should accept a message on a non existing queue in lazy mode" do
+    #@client.sqs.debug = true
+        
+    lambda { @client.sqs.send_message('foo', 'ping') }.should_not_raise
+  end
+  
+  specify "should return success" do
+    #@client.sqs.debug = true
+    @client.sqs.mode = :strict
+    
+    res = @client.sqs.create_queue('foo')
+    qurl = res.queue_url
+    
+    res = @client.sqs.send_message(qurl, 'ping')
+    res.code.should == 200
+  end
+end
+
+
+context "A Jungle::Client::SQSClient receive_message call" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should return success" do
+    #@client.sqs.debug = true
+        
+    res = @client.sqs.receive_message('foo')
+    res.code.should == 200
+  end
+  
+  specify "should return a response containing one SQSMessage" do
+    #@client.sqs.debug = true
+    
+    @client.sqs.send_message('foo', 'ping')
+        
+    res = @client.sqs.receive_message('foo')
+    res.messages.size.should == 1
+  end
+  
+  specify "should return return n response containing one SQSMessage with the message" do
+    #@client.sqs.debug = true
+    
+    @client.sqs.send_message('foo', 'ping')
+        
+    res = @client.sqs.receive_message('foo')
+    
+    p res.messages.first
+    
+    #res.messages.first.body.should == 'ping'
+  end
+end
+
+
+context "A Jungle::Client::SQSClient receive_messages call" do
+  setup do
+    @client = Jungle::Client.new
+  end
+  
+  specify "should return success" do
+    #@client.sqs.debug = true
+        
+    res = @client.sqs.receive_messages('foo')
+    res.code.should == 200
+  end
+  
+  specify "should return a response containing several SQSMessages" do
+    #@client.sqs.debug = true
+    
+    @client.sqs.send_message('foo', 'ping')
+    @client.sqs.send_message('foo', 'ping')
+        
+    res = @client.sqs.receive_messages('foo', :number_of_messages => 2)
+        
+    res.messages.size.should == 2
+  end
+end
+
+
+context "The response from Jungle::Client.SQSClient list_queues" do
+  setup do
+    @client = Jungle::Client.new
+  end
+
+  specify "should return success" do
+    res = @client.sqs.list_queues
+    res.code.should == 200
+  end
+  
+  specify "should return an array of strings" do
+    res = @client.sqs.list_queues
+    res.queue_urls.size.should_be > 1
+    res.queue_urls.each do |name|
+      name.should_be_an_instance_of String
+    end
+  end
+end
+
+
+context "The response from Jungle::Auth base_params" do
+  setup do
+    @auth = Jungle::Auth.new
+  end
+
+  specify "should contain 'method' matching method" do
+    @auth.bypass.base_params("GET", '/foo')['method'].should == 'GET'
+  end
+  
+  specify "should contain 'resource' matching resource substring of path" do
+    @auth.bypass.base_params("GET", '/foo')['resource'].should == '/foo'
+  end
+end
+
+
+context "The response from Jungle::Auth canonical_string" do
+  setup do
+    @auth = Jungle::Auth.new
+  end
+  
+  specify "should be a non-empty string" do
+    canonical = @auth.bypass.canonical_string(@auth.bypass.base_params('GET', '/foo'))
+    canonical.should_not_be nil
+    canonical.should_be_instance_of String
+    canonical.should_not == ""
+  end
+  
+  specify "should always contain the method as the first line" do
+    %w{GET POST PUT DELETE}.each do |method|
+      canonical = @auth.bypass.canonical_string(@auth.bypass.base_params(method, '/foo'))
+      canonical.split("\n")[0].should == method
+    end
+  end
+  
+  specify "should always have an empty second line" do
+    canonical = @auth.bypass.canonical_string(@auth.bypass.base_params('GET', '/foo'))
+    canonical.split("\n")[1].should == ''
+  end
+  
+  specify "should always have text/plain as the third line" do
+    canonical = @auth.bypass.canonical_string(@auth.bypass.base_params('GET', '/foo'))
+    canonical.split("\n")[2].should == 'text/plain'
+  end
+  
+  specify "should always have the current date as the fourth line" do
+    canonical = @auth.bypass.canonical_string(@auth.bypass.base_params('GET', '/foo'))
+    # Time.stubs(:httpdate).returns('Thu, 17 Nov 2005 18:49:58 GMT')
+    # canonical.split("\n")[3].should == 'Thu, 17 Nov 2005 18:49:58 GMT'
+  end
+  
+  specify "should always have the resource address as the fifth line" do
+    canonical = @auth.bypass.canonical_string(@auth.bypass.base_params('GET', ''))
+    canonical.split("\n")[4].should == '/'
+    
+    canonical = @auth.bypass.canonical_string(@auth.bypass.base_params('GET', '/'))
+    canonical.split("\n")[4].should == '/'
+  end
+end
+
+context "The response from Jungle::Auth hmac_signature" do
+  setup do
+    @auth = Jungle::Auth.new
+  end
+  
+  specify "should not be blank" do
+    @auth.bypass.hmac_signature("foo", "bar").should_not == ''
+  end
+  
+  specify "should return an sha1" do
+    hmac = @auth.bypass.hmac_signature("foo", "bar")
+    hmac.size.should == 28
+  end
+end
+
+context "The response from Jungle::Auth security_params" do
+  setup do
+    @auth = Jungle::Auth.new
+  end
+  
+  specify "should have plausible auth_string" do
+    @auth.bypass.security_params('GET', '')['auth_string'].should =~ /^AWS .{20}:.{28}$/
+  end
+end

data/test/test.rb

@@ -0,0 +1,17 @@
+require 'benchmark'
+require 'rexml/document'
+require 'xmlsimple'
+require 'xml/libxml'
+include Benchmark
+    
+xml = "<?xml version=\"1.0\"?>\n<CreateQueueResponse xmlns=\"http://queue.amazonaws.com/doc/2006-04-01/\"><QueueUrl>http://queue.amazonaws.com/A8SVKWT62YDQI/foo</QueueUrl><ResponseStatus><StatusCode>Success</StatusCode><RequestId>cba8efdf-f348-4335-8277-f756af3789eb</RequestId></ResponseStatus></CreateQueueResponse>"
+
+n = 50000
+
+Benchmark.bm(7) do |x|
+  x.report("regex:") { n.times { xml =~ /<QueueUrl>(.*?)<\/QueueUrl>/; val = $1 } }
+  
+  #x.report("rexml:") { n.times { doc = REXML::Document.new(xml); val = doc.elements['CreateQueueResponse'].elements['QueueUrl'].text } }
+  
+  x.report("xmlsimple:") { n.times { doc = XmlSimple.xml_in(xml, 'ForceArray' => false); val = doc['QueueUrl'] } }
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/jungle'
+
+# This allows you to be a good OOP citizen and honor encapsulation, but
+# still make calls to private methods (for testing) by doing
+#
+#   obj.bypass.private_thingie(arg1, arg2)
+#
+# Which is easier on the eye than
+#
+#   obj.send(:private_thingie, arg1, arg2)
+#
+class Object
+  class Bypass
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+    
+    def initialize(ref)
+      @ref = ref
+    end
+  
+    def method_missing(sym, *args)
+      @ref.__send__(sym, *args)
+    end
+  end
+
+  def bypass
+    Bypass.new(self)
+  end
+end
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: jungle
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-01-06 00:00:00 -08:00
+summary: A pure Ruby client library for Amazon's SQS business web services.
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: "\thttp://jungle.rubyforge.org/"
+rubyforge_project: jungle
+description: Jungle is a client library for the Amazon SQS (Simple Queue Service). It provides an intuitive, well documented API and a fully tested codebase.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/jungle.rb
+- lib/jungle/client.rb
+- lib/jungle/support.rb
+- lib/jungle/version.rb
+- test/example.rb
+- test/jungle_test.rb
+- test/test.rb
+- test/test_helper.rb
+test_files: 
+- test/test_helper.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+