sqs 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Kuźma
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sqs"
+    gem.summary = %Q{Simple Queue Service accessing library}
+    gem.email = "qoobaa@gmail.com"
+    gem.homepage = "http://github.com/qoobaa/sqs"
+    gem.authors = ["Jakub Kuźma"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sqs #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/sqs/connection.rb

@@ -0,0 +1,114 @@
+module Sqs
+
+  # Class responsible for handling connections to amazon hosts
+  class Connection
+    include Parser
+
+    attr_accessor :access_key_id, :secret_access_key, :use_ssl, :timeout, :debug
+    alias :use_ssl? :use_ssl
+
+    # ==== Parameters:
+    # +options+:: Hash of options
+    #
+    # ==== Options:
+    # +access_key_id+:: access key id
+    # +secret_access_key+:: secret access key
+    # +use_ssl+:: optional, defaults to false
+    # +debug+:: optional, defaults to false
+    # +timeout+:: optional, for Net::HTTP
+    def initialize(options = {})
+      @access_key_id = options[:access_key_id]
+      @secret_access_key = options[:secret_access_key]
+      @use_ssl = options[:use_ssl] || false
+      @debug = options[:debug]
+      @timeout = options[:timeout]
+    end
+
+    # Makes request with given HTTP method, sets missing parameters,
+    # adds signature to request header and returns response object
+    # (Net::HTTPResponse)
+    #
+    # ==== Parameters:
+    # +options+:: hash of options
+    #
+    # ==== Options:
+    # +host+:: hostname to connect to, optional, defaults to queue.amazonaws.com
+    # +path+:: path to send request to, required, throws ArgumentError if not given
+    #
+    # ==== Returns:
+    # Net::HTTPResponse object -- response from remote server
+    def request(options)
+      host = options.delete(:host) || HOST
+      path = options.delete(:path) or raise ArgumentError, "No path given"
+
+      request = Net::HTTP::Post.new(path)
+
+      response = http(host).start do |http|
+        add_common_options!(options)
+        add_timestamp!(options)
+        add_signature!(host, path, options)
+        set_form_data!(request, options)
+        http.request(request)
+      end
+
+      handle_response(response)
+    end
+
+    private
+
+    def set_form_data!(request, options)
+      request.set_form_data(options)
+      request.content_type = "application/x-www-form-urlencoded; charset=utf-8"
+    end
+
+    def add_common_options!(options)
+      options.merge!("AWSAccessKeyId"   => access_key_id,
+                     "SignatureMethod"  => "HmacSHA256",
+                     "SignatureVersion" => "2",
+                     "Version"          => "2009-02-01")
+    end
+
+    def add_timestamp!(options)
+      options["Timestamp"] = Time.now.utc.iso8601 if options["Timestamp"].nil? and options["Expires"].nil?
+    end
+
+    def add_signature!(host, path, options)
+      options["Signature"] = Signature.generate(:method => :post,
+                                                :host => host,
+                                                :path => path,
+                                                :access_key_id => access_key_id,
+                                                :secret_access_key => secret_access_key,
+                                                :params => options)
+    end
+
+    def port
+      use_ssl ? 443 : 80
+    end
+
+    def http(host)
+      http = Net::HTTP.new(host, port)
+      http.set_debug_output(STDOUT) if @debug
+      http.use_ssl = @use_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @use_ssl
+      http.read_timeout = @timeout if @timeout
+      http
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200...300
+        response
+      when 300...600
+        if response.body.nil? || response.body.empty?
+          raise Error::ResponseError.new(nil, response)
+        else
+          code, message = parse_error(response.body)
+          raise Error::ResponseError.exception(code).new(message, response)
+        end
+      else
+        raise ConnectionError.new(response, "Unknown response code: #{response.code}")
+      end
+      response
+    end
+  end
+end

data/lib/sqs/exceptions.rb

@@ -0,0 +1,97 @@
+module Sqs
+  module Error
+
+    # All responses with a code between 300 and 599 that contain an
+    # <Error></Error> body are wrapped in an ErrorResponse which
+    # contains an Error object. This Error class generates a custom
+    # exception with the name of the xml Error and its message. All
+    # such runtime generated exception classes descend from
+    # ResponseError and contain the ErrorResponse object so that all
+    # code that makes a request can rescue ResponseError and get
+    # access to the ErrorResponse.
+    class ResponseError < StandardError
+      attr_reader :response
+
+      # ==== Parameters:
+      # +message+:: what went wrong
+      # +response+:: Net::HTTPResponse object or nil
+      def initialize(message, response)
+        @response = response
+        super(message)
+      end
+
+      # Factory for all other Exception classes in module, each for every
+      # error response available from AmazonAWS
+      #
+      # ==== Parameters:
+      # +code+:: code name of exception
+      #
+      # ==== Returns:
+      # Descendant of ResponseError suitable for that exception code or ResponseError class
+      # if no class found
+      def self.exception(code)
+        Sqs::Error.const_get(code)
+      rescue NameError
+        ResponseError
+      end
+    end
+
+    #:stopdoc:
+
+    class AccessDenied < ResponseError; end
+    class AuthFailure < ResponseError; end
+    class ConflictingQueryParameter < ResponseError; end
+    class ElementNotSigned < ResponseError; end
+    class InternalError < ResponseError; end
+    class InvalidAccessKeyId < ResponseError; end
+    class InvalidAction < ResponseError; end
+    class InvalidAddress < ResponseError; end
+    class InvalidAttributeName < ResponseError; end
+    class InvalidHttpRequest < ResponseError; end
+    class InvalidMessageContents < ResponseError; end
+    class InvalidParameterCombination < ResponseError; end
+    class InvalidParameterValue < ResponseError; end
+    class InvalidQueryParameter < ResponseError; end
+    class InvalidRequest < ResponseError; end
+    class InvalidSecurity < ResponseError; end
+    class InvalidSecurityToken < ResponseError; end
+    class MalformedSOAPSignature < ResponseError; end
+    class MalformedVersion < ResponseError; end
+    class MessageTooLong < ResponseError; end
+    class MissingClientTokenId < ResponseError; end
+    class MissingCredentials < ResponseError; end
+    class MissingParameter < ResponseError; end
+    class NoSuchVersion < ResponseError; end
+    class NonExistentQueue < ResponseError; end
+    class NotAuthorizedToUseVersion < ResponseError; end
+    class QueueDeletedRecently < ResponseError; end
+    class QueueNameExists < ResponseError; end
+    class ReadCountOutOfRange < ResponseError; end
+    class RequestExpired < ResponseError; end
+    class RequestThrottled < ResponseError; end
+    class SOAP11IncorrectDateFormat < ResponseError; end
+    class SOAP11MissingAction < ResponseError; end
+    class ServiceUnavailable < ResponseError; end
+    class SignatureDoesNotMatch < ResponseError; end
+    class SoapBodyMissing < ResponseError; end
+    class SoapEnvelopeMissing < ResponseError; end
+    class SoapEnvelopeParseError < ResponseError; end
+    class UnknownEnvelopeNamespace < ResponseError; end
+    class WSSecurityCorruptSignedInfo < ResponseError; end
+    class WSSecurityCreatedDateIncorrectFormat < ResponseError; end
+    class WSSecurityEncodingTypeError < ResponseError; end
+    class WSSecurityExpiresDateIncorrectFormat < ResponseError; end
+    class WSSecurityIncorrectValuetype < ResponseError; end
+    class WSSecurityMissingValuetype < ResponseError; end
+    class WSSecurityMultipleCredentialError < ResponseError; end
+    class WSSecurityMultipleX509Error < ResponseError; end
+    class WSSecuritySignatureError < ResponseError; end
+    class WSSecuritySignatureMissing < ResponseError; end
+    class WSSecuritySignedInfoMissing < ResponseError; end
+    class WSSecurityTimestampExpired < ResponseError; end
+    class WSSecurityTimestampExpiresMissing < ResponseError; end
+    class WSSecurityTimestampMissing < ResponseError; end
+    class WSSecurityX509CertCredentialError < ResponseError; end
+    class X509ParseError < ResponseError; end
+  end
+end

data/lib/sqs/message.rb

@@ -0,0 +1,36 @@
+module Sqs
+  class Message
+    extend Forwardable
+
+    def_instance_delegators :queue, :name, :queue_request
+    attr_reader :queue, :id, :body, :body_md5, :receipt_handle
+    private_class_method :new
+
+    def ==(other)
+      self.id == other.id and self.queue == other.queue
+    end
+
+    def destroy
+      delete_message
+      true
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:#{name}/#{id}>"
+    end
+
+    private
+
+    def initialize(queue, options)
+      @queue = queue
+      @id = options[:id]
+      @body = options[:body]
+      @body_md5 = options[:body_md5]
+      @receipt_handle = options[:receipt_handle]
+    end
+
+    def delete_message
+      queue_request("Action" => "DeleteMessage", "ReceiptHandle" => receipt_handle)
+    end
+  end
+end

data/lib/sqs/parser.rb

@@ -0,0 +1,48 @@
+module Sqs
+  module Parser
+    include REXML
+
+    def rexml_document(xml)
+      xml.force_encoding(Encoding::UTF_8) if xml.respond_to? :force_encoding
+      Document.new(xml)
+    end
+
+    def parse_list_queues_result(xml)
+      urls = []
+      rexml_document(xml).elements.each("ListQueuesResponse/ListQueuesResult/QueueUrl") { |e| urls << e.text }
+      urls
+    end
+
+    def parse_create_queue_result(xml)
+      rexml_document(xml).elements["CreateQueueResponse/CreateQueueResult/QueueUrl"].text
+    end
+
+    def parse_get_queue_attributes_result(xml)
+      attributes = {}
+      rexml_document(xml).elements.each("GetQueueAttributesResponse/GetQueueAttributesResult/Attribute") do |e|
+        name = e.elements["Name"].text
+        value = e.elements["Value"].text
+        attributes[name] = value
+      end
+      attributes
+    end
+
+    def parse_receive_message_result(xml)
+      messages = []
+      rexml_document(xml).elements.each("ReceiveMessageResponse/ReceiveMessageResult/Message") do |e|
+        messages << {
+          :id => e.elements["MessageId"].text,
+          :receipt_handle => e.elements["ReceiptHandle"].text,
+          :body_md5 => e.elements["MD5OfBody"].text,
+          :body => e.elements["Body"].text
+        }
+      end
+      messages
+    end
+
+    def parse_error(xml)
+      document = rexml_document(xml)
+      [document.elements["ErrorResponse/Error/Code"].text.split(".").last, document.elements["ErrorResponse/Error/Message"].text]
+    end
+  end
+end

data/lib/sqs/queue.rb

@@ -0,0 +1,95 @@
+module Sqs
+  class Queue
+    extend Forwardable
+    include Parser
+
+    attr_reader :path, :name, :service
+    def_instance_delegators :service, :service_request
+    private_class_method :new
+
+    def ==(other)
+      self.name == other.name and self.service == other.service
+    end
+
+    def destroy
+      delete_queue
+      true
+    end
+
+    def attributes
+      get_queue_attributes
+    end
+
+    def update_attributes(attributes)
+      set_queue_attributes(attributes)
+      true
+    end
+
+    def create_message(body)
+      send_message("MessageBody" => body)
+      true
+    end
+
+    def message(visibility_timeout = nil)
+      options = {}
+      options["VisibilityTimeout"] = visibility_timeout.to_s if visibility_timeout
+      receive_message(options).first
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:#{name}>"
+    end
+
+    private
+
+    def initialize(service, url) #:nodoc:
+      self.service = service
+      self.url = url
+    end
+
+    attr_writer :service, :path
+
+    def url=(url)
+      parsed_url = URI.parse(url)
+      self.path = parsed_url.path[1..-1]
+      self.name = parsed_url.path.split("/").last
+    end
+
+    def name=(name)
+      @name = name
+    end
+
+    def queue_request(options = {})
+      service_request(options.merge(:path => path))
+    end
+
+    def delete_queue
+      queue_request("Action" => "DeleteQueue")
+    end
+
+    def get_queue_attributes
+      response = queue_request("Action" => "GetQueueAttributes", "AttributeName" => "All")
+      parse_get_queue_attributes_result(response.body)
+    end
+
+    def set_queue_attributes(options)
+      attributes = {}
+      options.each_with_index do |attribute, i|
+        attributes["Attribute.#{i + 1}.Name"] = attribute.first.to_s
+        attributes["Attribute.#{i + 1}.Value"] = attribute.last.to_s
+      end
+      queue_request(attributes.merge("Action" => "SetQueueAttributes"))
+    end
+
+    def send_message(options)
+      queue_request(options.merge("Action" => "SendMessage"))
+    end
+
+    def receive_message(options)
+      response = queue_request(options.merge("Action" => "ReceiveMessage"))
+      parse_receive_message_result(response.body).map do |message_attributes|
+        Message.send(:new, self, message_attributes)
+      end
+    end
+  end
+end

data/lib/sqs/roxy/moxie.rb

@@ -0,0 +1,58 @@
+# Copyright (c) 2008 Ryan Daigle
+
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module Sqs
+  module Roxy # :nodoc:all
+    module Moxie
+      # Set up this class to proxy on the given name
+      def proxy(name, options = {}, &block)
+
+        # Make sure args are OK
+        original_method = method_defined?(name) ? instance_method(name) : nil
+        raise "Cannot proxy an existing method, \"#{name}\", and also have a :to option.  Please use one or the other." if
+          original_method and options[:to]
+
+        # If we're proxying an existing method, we need to store
+        # the original method and move it out of the way so
+        # we can take over
+        if original_method
+          new_method = "proxied_#{name}"
+          alias_method new_method, "#{name}"
+          options[:to] = original_method
+        end
+
+        # Thanks to Jerry for this simplification of my original class_eval approach
+        # http://ryandaigle.com/articles/2008/11/10/implement-ruby-proxy-objects-with-roxy/comments/8059#comment-8059
+        if !original_method or original_method.arity == 0
+          define_method name do
+            @proxy_for ||= {}
+            @proxy_for[name] ||= Proxy.new(self, options, nil, &block)
+          end
+        else
+          define_method name do |*args|
+            Proxy.new(self, options, args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sqs/roxy/proxy.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2008 Ryan Daigle
+
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module Sqs
+  module Roxy # :nodoc:all
+    # The very simple proxy class that provides a basic pass-through
+    # mechanism between the proxy owner and the proxy target.
+    class Proxy
+
+      alias :proxy_instance_eval :instance_eval
+      alias :proxy_extend :extend
+
+      # Make sure the proxy is as dumb as it can be.
+      # Blatanly taken from Jim Wierich's BlankSlate post:
+      # http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^proxy_|^object_id)/ }
+
+      def initialize(owner, options, args, &block)
+        @owner = owner
+        @target = options[:to]
+        @args = args
+
+        # Adorn with user-provided proxy methods
+        [options[:extend]].flatten.each { |ext| proxy_extend(ext) } if options[:extend]
+        proxy_instance_eval &block if block_given?
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def proxy_target
+        if @target.is_a?(Proc)
+          @target.call(@owner)
+        elsif @target.is_a?(UnboundMethod)
+          bound_method = @target.bind(proxy_owner)
+          bound_method.arity == 0 ? bound_method.call : bound_method.call(*@args)
+        else
+          @target
+        end
+      end
+
+      # def inspect
+      #   "#<S3::Roxy::Proxy:0x#{object_id.to_s(16)}>"
+      # end
+
+      # Delegate all method calls we don't know about to target object
+      def method_missing(sym, *args, &block)
+        proxy_target.__send__(sym, *args, &block)
+      end
+    end
+  end
+end

data/lib/sqs/service.rb

@@ -0,0 +1,118 @@
+module Sqs
+  class Service
+    extend Roxy::Moxie
+    include Parser
+
+    attr_reader :access_key_id, :secret_access_key, :use_ssl
+
+    # Compares service to other, by access_key_id and secret_access_key
+    def ==(other)
+      self.access_key_id == other.access_key_id and self.secret_access_key == other.secret_access_key
+    end
+
+    # ==== Parameters:
+    # +options+:: a hash of options described below
+    #
+    # ==== Options:
+    # +access_key_id+:: Amazon access key id, required
+    # +secret_access_key+:: Amazon secret access key, required
+    # +use_ssl+:: true if use ssl in connection, otherwise false
+    # +timeout+:: parameter for Net::HTTP module
+    # +debug+:: prints the raw requests to STDOUT
+    def initialize(options)
+      @access_key_id = options[:access_key_id] or raise ArgumentError, "No access key id given"
+      @secret_access_key = options[:secret_access_key] or raise ArgumentError, "No secret access key given"
+      @use_ssl = options[:use_ssl]
+      @timeout = options[:timeout]
+      @debug = options[:debug]
+    end
+
+    # Returns all queues in the service and caches the result (see reload)
+    def queues(reload = false)
+      if reload or @queues.nil?
+        @queues = list_queues
+      else
+        @queues
+      end
+    end
+
+    proxy :queues do
+      # Builds new queue with given name
+      def create(name, default_visibility_timeout = nil)
+        options = { "QueueName" => name }
+        options["DefaultVisibilityTimeout"] = default_visibility_timeout.to_s if default_visibility_timeout
+        proxy_owner.send(:create_queue, options)
+      end
+
+      # Finds the queue with given name
+      def find_first(name)
+        find_all(name).first
+      end
+      alias :find :find_first
+
+      # Find all queues in the service
+      def find_all(name)
+        if name and not name.empty?
+          proxy_owner.send(:list_queues, "QueueNamePrefix" => name)
+        else
+          proxy_target
+        end
+      end
+
+      # Reloads the queue list (clears the cache)
+      def reload
+        proxy_owner.queues(true)
+      end
+
+      # Destroy all queues in the service (USE WITH CARE!).
+      def destroy_all
+        proxy_target.each { |queue| queue.destroy }
+        true
+      end
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:#@access_key_id>"
+    end
+
+    private
+
+    def list_queues(options = {})
+      response = service_request(options.merge("Action" => "ListQueues"))
+
+      parse_list_queues_result(response.body).map do |url|
+        Queue.send(:new, self, url)
+      end
+    end
+
+    def create_queue(options)
+      name = options["QueueName"]
+      raise ArgumentError, "Invalid queue name: #{name}" unless queue_name_valid?(name)
+
+      response = service_request(options.merge("Action" => "CreateQueue"))
+
+      url = parse_create_queue_result(response.body)
+      Queue.send(:new, self, url)
+    end
+
+    def queue_name_valid?(name)
+      name =~ /\A[a-zA-Z0-9_-]{1,80}\Z/
+    end
+
+    def service_request(options = {})
+      connection.request(options.merge(:path => "/#{options[:path]}"))
+    end
+
+    def connection
+      if @connection.nil?
+        @connection = Connection.new
+        @connection.access_key_id = @access_key_id
+        @connection.secret_access_key = @secret_access_key
+        @connection.use_ssl = @use_ssl
+        @connection.timeout = @timeout
+        @connection.debug = @debug
+      end
+      @connection
+    end
+  end
+end

data/lib/sqs/signature.rb

@@ -0,0 +1,60 @@
+module Sqs
+
+  # Class responsible for generating signatures to requests.
+  #
+  # Implements algorithm defined by Amazon Web Services to sign
+  # request with secret private credentials
+
+  class Signature
+    UNSAFE_REGEXP = /[^a-zA-Z0-9_.-]/
+
+    # Generates signature for given parameters
+    #
+    # ==== Parameters:
+    # +options+: a hash that contains options listed below
+    #
+    # ==== Options:
+    # +host+: hostname
+    # +access_key_id+: access key id
+    # +secret_access_key+: secret access key
+    # +method+: method of the request ("GET" or "POST")
+    # +params+: request parameters hash
+    # +path+: request path
+    #
+    # ==== Returns:
+    # Generated signature for given hostname and request
+    def self.generate(options)
+      host = options[:host]
+      access_key_id = options[:access_key_id]
+      secret_access_key = options[:secret_access_key]
+      method = options[:method]
+      params = options[:params]
+      path = options[:path]
+
+      string_to_sign = ""
+      string_to_sign << method.to_s.upcase
+      string_to_sign << "\n"
+      string_to_sign << host.to_s.downcase
+      string_to_sign << "\n"
+      string_to_sign << path
+      string_to_sign << "\n"
+      string_to_sign << canonicalized_query_string(params)
+
+      digest = OpenSSL::Digest::Digest.new("sha256")
+      hmac = OpenSSL::HMAC.digest(digest, secret_access_key, string_to_sign)
+      base64 = Base64.encode64(hmac)
+      base64.chomp
+    end
+
+    private
+
+    def self.canonicalized_query_string(params)
+      results = params.sort.map do |param|
+        urlencoded_key = URI.encode(param.first, UNSAFE_REGEXP)
+        urlencoded_value = URI.encode(param.last, UNSAFE_REGEXP)
+        "#{urlencoded_key}=#{urlencoded_value}"
+      end
+      results.join("&")
+    end
+  end
+end

data/lib/sqs.rb

@@ -0,0 +1,26 @@
+# stdlibs
+require "base64"
+require "forwardable"
+require "net/http"
+require "net/https"
+require "openssl"
+require "rexml/document"
+require "time"
+
+# proxy stuff
+require "sqs/roxy/moxie"
+require "sqs/roxy/proxy"
+
+# sqs stuff
+require "sqs/parser"
+require "sqs/connection"
+require "sqs/exceptions"
+require "sqs/message"
+require "sqs/queue"
+require "sqs/service"
+require "sqs/signature"
+
+module Sqs
+  # Default (and only) host serving SQS stuff
+  HOST = "queue.amazonaws.com"
+end

data/sqs.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sqs}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jakub Kuźma"]
+  s.date = %q{2009-08-17}
+  s.email = %q{qoobaa@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "Rakefile",
+     "VERSION",
+     "lib/sqs.rb",
+     "lib/sqs/connection.rb",
+     "lib/sqs/exceptions.rb",
+     "lib/sqs/message.rb",
+     "lib/sqs/parser.rb",
+     "lib/sqs/queue.rb",
+     "lib/sqs/roxy/moxie.rb",
+     "lib/sqs/roxy/proxy.rb",
+     "lib/sqs/service.rb",
+     "lib/sqs/signature.rb",
+     "sqs.gemspec",
+     "test/signature_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/qoobaa/sqs}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Simple Queue Service accessing library}
+  s.test_files = [
+    "test/signature_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/signature_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class SignatureTest < Test::Unit::TestCase
+  def setup
+    @options = {}
+    @params = {}
+    @options[:host] = "queue.amazonaws.com"
+    @options[:path] = "/"
+    @options[:method] = :get
+    @options[:access_key_id] = "0PN5J17HBGZHT7JJ3X82"
+    @options[:secret_access_key] = "uV3F3YluFJax1cknvbcGwgjvx4QpvB+leU8dUj2o"
+    @params["SignatureMethod"] = "HmacSHA256"
+    @params["SignatureVersion"] = "2"
+    @params["Version"] = "2009-02-01"
+    @params["Timestamp"] = "2009-08-17T08:56:12Z"
+    @params["AWSAccessKeyId"] = @options[:access_key_id]
+    @options[:params] = @params
+  end
+
+  def test_signature_for_get
+    @options[:method] = :get
+    expected = "lQcH/YUdHHpo4hshdHZrGbX9CLvksKmD9atmrCroyAo="
+    actual = Sqs::Signature.generate(@options)
+    assert_equal expected, actual
+  end
+
+  def test_signagure_for_post
+    @options[:method] = :post
+    expected = "st9O4GTVytI+5BjbjfRSPRB8xKOxel52F7Sle706BcA="
+    actual = Sqs::Signature.generate(@options)
+    assert_equal expected, actual
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+require 'rr'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sqs'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: sqs
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- "Jakub Ku\xC5\xBAma"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-17 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: qoobaa@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- .document
+- .gitignore
+- LICENSE
+- Rakefile
+- VERSION
+- lib/sqs.rb
+- lib/sqs/connection.rb
+- lib/sqs/exceptions.rb
+- lib/sqs/message.rb
+- lib/sqs/parser.rb
+- lib/sqs/queue.rb
+- lib/sqs/roxy/moxie.rb
+- lib/sqs/roxy/proxy.rb
+- lib/sqs/service.rb
+- lib/sqs/signature.rb
+- sqs.gemspec
+- test/signature_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/qoobaa/sqs
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple Queue Service accessing library
+test_files: 
+- test/signature_test.rb
+- test/test_helper.rb