simple_qs 0.1.1 → 0.1.2

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 0.1.2
+
+Features:
+	- Add exists? class method to SimpleQS::Queue
+	- Add delete class method to SimpleQS::Queue
+
+Bugfixes:
+	- Fix gemspec, gem now works as it should :)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Marjan Krekoten'
+
+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 PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL 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/README.md

@@ -0,0 +1,250 @@
+# English #
+
+## Installation ##
+
+		[sudo] gem install simple_qs
+
+## Usage ##
+
+		require 'simple_qs'
+		SimpleQS.account_id = 'your-account-id'
+		SimpleQS.access_key_id = 'YOUR_ACCESS_KEY'
+		SimpleQS.secret_access_key = 'YOUR_SECRET_ACCESS_KEY'
+
+### Region ###
+
+You can select region for queue:
+
+		# :default		=> 'queue.amazonaws.com'
+		# :us_west_1	=> 'us-west-1.queue.amazonaws.com'
+		# :eu_west_1	=> 'eu-west-1.queue.amazonaws.com'
+		SimpleQS.host # => 'queue.amazonaws.com'
+		
+		SimpleQS.host = :eu_west_1
+		SimpleQS.host # => 'eu-west-1.queue.amazonaws.com'
+
+### Queues ###
+
+Create a queue:
+
+		queue = SimpleQS::Queue.create('queue_name')
+
+Or:
+
+		SimpleQS::Queue.create('queue_name') do |queue|
+			# ...
+		end
+
+Create a queue with specific default visibility timeout for received messages:
+
+		SimpleQS::Queue.create('queue_name', 60) # Visibility timeout set to 60 secinds instead of default 30
+
+List all account's queues:
+
+		SimpleQS::Queue.list # returns list of SimpleQS::Queue objects
+
+List all account's queues starting with 'test':
+
+		SimpleQS::Queue.list('test')
+
+Change default visibility timeout for queue:
+
+		SimpleQS::Queue.new('queue_name').set_visibility_timeout(120)
+
+Set queue attributes:
+
+		SimpleQS::Queue.new('queue_name').set_attributes({:VisibilityTimeout => 120, :Policy => "policy JSON here"})
+
+Get queue attributes:
+
+		SimpleQS::Queue.new('queue_name').get_attributes(:All)
+
+Add permissions:
+
+		SimpleQS::Queue.new('queue_name').add_permissions('testPerms', [
+			{:account_id => '098166147350', :action => 'SendMessage'},
+			{:account_id => '098166147350', :action => 'ReceiveMessage'}
+		])
+
+Remove permissions:
+
+		SimpleQS::Queue.new('queue_name').remove_permissions('testPerms')
+
+Delete queue:
+
+		SimpleQS::Queue.new('queue_name').delete
+
+### Messages ###
+
+Send message:
+
+		queue = SimpleQS::Queue.new('queue_name')
+		queue.send_message('message 1')
+		queue.send_message('message 2')
+
+Or:
+
+		SimpleQS::Message.send(queue, 'message 1')
+		SimpleQS::Message.send(queue, 'message 2')
+
+Receive message(s):
+
+		queue.receive_messages # always returns array of messages
+		queue.receive_messages(:All, 10, 70) # receive maximum 10 messages with all attributes (:All)
+											 # and set for them visibility timeout to 70 seconds
+
+Or:
+
+		SimpleQS::Message.receive(queue)
+		SimpleQS::Message.receive(queue, :All, 10, 70)
+
+Resend received message:
+
+		messages = queue.receive_messages
+		messages.first.resend
+
+Change visibility timeout for this message:
+
+		messages.first.change_visibility(120) # Change to 120 seconds
+
+Delete received message:
+
+		messages.first.delete
+
+## TODO ##
+
+See [TODO](http://github.com/krekoten/SimpleQS/blob/master/TODO.md) file
+
+## Issues ##
+
+[ISSUES](http://github.com/krekoten/SimpleQS/issues)
+
+## Authors ##
+
+Marjan Krekoten' (krekoten@gmail.com)
+
+# Українською #
+
+## Встановлення ##
+
+		[sudo] gem install simple_qs
+
+## Користування ##
+
+		require 'simple_qs'
+		SimpleQS.account_id = 'your-account-id'
+		SimpleQS.access_key_id = 'YOUR_ACCESS_KEY'
+
+		SimpleQS.secret_access_key = 'YOUR_SECRET_ACCESS_KEY'
+
+### Регіон ###
+
+Можна обрати регіон, в якому буде створена черга:
+
+		# :default		=> 'queue.amazonaws.com'
+		# :us_west_1	=> 'us-west-1.queue.amazonaws.com'
+		# :eu_west_1	=> 'eu-west-1.queue.amazonaws.com'
+		SimpleQS.host # => 'queue.amazonaws.com'
+
+		SimpleQS.host = :eu_west_1
+		SimpleQS.host # => 'eu-west-1.queue.amazonaws.com'
+
+### Черги ###
+
+Створити чергу:
+
+		queue = SimpleQS::Queue.create('queue_name')
+
+Або:
+
+		SimpleQS::Queue.create('queue_name') do |queue|
+			# ...
+		end
+
+Створити чергу із специфічним обмеженням часу невидимості для отриманих повідомлень:
+
+		SimpleQS::Queue.create('queue_name', 60) # Час невидимості встановленно на 60 секунд, натомість типових 30-ти
+
+Перелічити всі черги даного рахунку:
+
+		SimpleQS::Queue.list # returns list of SimpleQS::Queue objects
+
+Перелічити всі черги даного рахунку, що починаються на 'test':
+
+		SimpleQS::Queue.list('test')
+
+Змінити типовий час невидимості для даної черги:
+
+		SimpleQS::Queue.new('queue_name').set_visibility_timeout(120)
+
+Встановити атрибути черги:
+
+		SimpleQS::Queue.new('queue_name').set_attributes({:VisibilityTimeout => 120, :Policy => "policy JSON here"})
+
+Отримати поточні атрибути черги:
+
+		SimpleQS::Queue.new('queue_name').get_attributes(:All)
+
+Надати дозволи:
+
+		SimpleQS::Queue.new('queue_name').add_permissions('testPerms', [
+			{:account_id => '098166147350', :action => 'SendMessage'},
+			{:account_id => '098166147350', :action => 'ReceiveMessage'}
+		])
+
+Скасувати дозволи:
+
+		SimpleQS::Queue.new('queue_name').remove_permissions('testPerms')
+
+Видалити чергу:
+
+		SimpleQS::Queue.new('queue_name').delete
+
+### Повідомлення ###
+
+Відправити повідомлення:
+
+		queue = SimpleQS::Queue.new('queue_name')
+		queue.send_message('message 1')
+		queue.send_message('message 2')
+
+Або:
+
+		SimpleQS::Message.send(queue, 'message 1')
+		SimpleQS::Message.send(queue, 'message 2')
+
+Отримати повідомлення:
+
+		queue.receive_messages # завжди повертає масив
+		queue.receive_messages(:All, 10, 70) # отримати максимум 10 повідомлень зі всіма атрибутами (:All)
+											 # та встановленим часом невидимості у 70 секунд
+
+Або:
+
+		SimpleQS::Message.receive(queue)
+		SimpleQS::Message.receive(queue, :All, 10, 70)
+
+Надіслати отримані повідомлення ще раз:
+
+		messages = queue.receive_messages
+		messages.first.resend
+
+Змінити час невидимості для даного повідомлення:
+
+		messages.first.change_visibility(120) # Встановити у 120 секунд
+
+Видалити отримане повідомлення з черги:
+
+		messages.first.delete
+
+## Що потрібно зробити ##
+
+Дивіться [TODO](http://github.com/krekoten/SimpleQS/blob/master/TODO.md)
+
+## Помилки, побажання і т.і. ##
+
+[ISSUES](http://github.com/krekoten/SimpleQS/issues)
+
+## Автори ##
+
+Мар'ян Крекотень (krekoten@gmail.com)

data/TODO.md

@@ -0,0 +1,3 @@
+ * Add interface for policy
+ * RDoc
+ * Handle big messages ( > 8 Kb) via S3 (send special message marker with bucket and object name where real message stored)

data/lib/simple_qs.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+
+$: << File.join(File.dirname(__FILE__))
+
+module SimpleQS
+  
+  API_VERSION = '2009-02-01'
+  
+  SQS_HOSTS = {
+    :default    => 'queue.amazonaws.com',
+    :us_west_1  => 'us-west-1.queue.amazonaws.com',
+    :eu_west_1  => 'eu-west-1.queue.amazonaws.com'
+  }
+
+  autoload :Message,    'simple_qs/message'
+  autoload :Queue,      'simple_qs/queue'
+  autoload :Request,    'simple_qs/request'
+  autoload :Responce,   'simple_qs/responce'
+  
+  class << self
+    attr_accessor :access_key_id, :secret_access_key
+    
+    def account_id=(value)
+      @account_id = value.gsub(/[^0-9]/, '')
+    end
+    attr_reader :account_id
+    
+    def host=(value)
+      raise ArgumentError, 'Expected value to be one of: :default, :us_west_1, :eu_west_1' unless SQS_HOSTS.key?(value)
+      @host = value
+    end
+    
+    def host
+      @host ||= :default
+      SQS_HOSTS[@host]
+    end
+  end
+end
+
+require 'version'

data/lib/simple_qs/message.rb

@@ -0,0 +1,135 @@
+module SimpleQS
+  class Message
+
+    class DoubleSendError    < StandardError; end
+    class NotReceivedError  < StandardError; end
+
+    attr_accessor :queue
+    attr_reader :message_id, :receipt_handle, :body, :md5_of_body
+    attr_reader :sender_id, :sent_timestamp, :approximate_receive_count, :approximate_first_receive_timestamp
+
+    def initialize(queue, params = nil)
+      @queue = queue
+
+      @body = params if params.class == String
+      _from_responce(params) if params.class == SimpleQS::Responce
+      _from_hash(params) if params.class == Hash
+    end
+
+    def send
+      raise DoubleSendError, "Cann't send already sent message. Use resend() method." if message_id
+      raise DoubleSendError, "Cann't send received message. Use resend() method." if receipt_handle
+
+      params = {
+        'Action'      => 'SendMessage',
+        'MessageBody'  => body
+      }
+      request = queue.build_request(:post, params)
+      responce = request.perform
+      raise responce.to_error unless responce.successful?
+      _from_responce(responce)
+
+      self
+    end
+
+    def resend
+      dup.send
+    end
+
+    def delete
+      raise NotReceivedError, "Cann't delete message that was not received" unless receipt_handle
+      params = {
+        'Action'        => 'DeleteMessage',
+        'ReceiptHandle'  => receipt_handle
+      }
+      request = queue.build_request(:get, params)
+      responce = request.perform
+      raise responce.to_error unless responce.successful?
+    end
+    alias_method :destroy, :delete
+
+    def change_visibility(visibility_timeout)
+      SimpleQS::Queue.check_visibility_timeout(visibility_timeout)
+      raise NotReceivedError, "Cann't change visibility timeout for message that was not received" unless receipt_handle
+
+      params = {
+        'Action'            => 'ChangeMessageVisibility',
+        'ReceiptHandle'      => receipt_handle,
+        'VisibilityTimeout'  => visibility_timeout
+      }
+
+      request = queue.build_request(:get, params)
+      responce = request.perform
+      
+      raise responce.to_error unless responce.successful?
+    end
+
+    def dup
+      self.class.new(queue, body)
+    end
+
+    def ==(other)
+      message_id == other.message_id && receipt_handle == other.receipt_handle
+    end
+
+    class << self
+      def send(queue, message_body)
+        new(queue, message_body).send
+      end
+
+      def receive(queue, attributes = nil, max_number_of_messages = nil, visibility_timeout = nil)
+
+        SimpleQS::Queue.check_visibility_timeout(visibility_timeout) if visibility_timeout
+        if max_number_of_messages && !(1..10).include?(max_number_of_messages)
+          raise ArgumentError, "Maximum number of messages should be in 1..10 range"
+        end
+
+        params = {
+          'Action'    => 'ReceiveMessage'
+        }
+
+        if attributes
+          attributes = [attributes] unless attributes.class == Array
+          attributes.uniq!
+          unless (attributes - [:All, :SenderId, :SentTimestamp, :ApproximateReceiveCount, :ApproximateFirstReceiveTimestamp]).empty?
+            raise ArgumentError,\
+              "Allowed attributes: :All, :SenderId, :SentTimestamp, :ApproximateReceiveCount, :ApproximateFirstReceiveTimestamp"
+          end
+          attributes.each_index do |i|
+            params["AttributeName.#{i + 1}"] = attributes[i]
+          end
+        end
+        params['MaxNumberOfMessages'] = max_number_of_messages if max_number_of_messages
+        params['VisibilityTimeout'] = visibility_timeout if visibility_timeout
+
+        request = queue.build_request(:get, params)
+        responce = request.perform
+        if responce.respond_to?(:message)
+          messages = (responce.message.class == Array ? responce.message : [responce.message])
+          messages.map {|message| new(queue, message)}
+        else
+          []
+        end
+      end
+    end
+
+    protected
+
+    def _from_responce(responce)
+      @message_id   = responce.message_id
+      @md5_of_body  = responce.md5_of_message_body
+    end
+
+    def _from_hash(message)
+      attributes = message.delete('Attribute')
+      attributes.each do |attr|
+        message[attr['Name']] = attr['Value']
+      end if attributes
+      message.each do |key, value|
+        key = key.gsub(/([A-Z]+)/, '_\1').downcase.gsub(/^_/, '')
+        instance_variable_set("@#{key}".to_sym, value) if respond_to?(key.to_sym)
+      end
+    end
+
+  end
+end

data/lib/simple_qs/queue.rb

@@ -0,0 +1,273 @@
+module SimpleQS
+  class Queue
+    
+    class MaxVisibilityError < StandardError; end
+
+    MAX_VISIBILITY_TIMEOUT = 43200
+
+    attr_accessor :queue_url
+
+    # Initializes new SimpleQS::Queue object
+    # Parameters:
+    #    queue_url_or_name - String, either queue url or queue name
+    def initialize(queue_url_or_name)
+      begin
+        self.class.check_queue_name(queue_url_or_name)
+        @name = queue_url_or_name
+        @queue_url = "http://#{SimpleQS.host}/#{SimpleQS.account_id}/#{@name}"
+      rescue ArgumentError
+        @queue_url = queue_url_or_name
+      end
+    end
+
+    # Get queue name
+    # Returns:
+    #    String - queue name
+    def name
+      @name ||= @queue_url.split(/\//).last
+    end
+
+    # Is this queue deleted?
+    #  Returns:
+    #    Bool - true if queue is deleted
+    def deleted
+      @deleted ||= false
+    end
+    alias_method :deleted?, :deleted
+
+
+    # Deletes this queue
+    # Returns:
+    #    Bool - true, if successful
+    # Raises:
+    #    SimpleQS::Responce::Error
+    def delete
+      params = {
+        'Action'    => 'DeleteQueue'
+      }
+
+      request = build_request(:get, params)
+      responce = request.perform
+      
+      raise responce.to_error unless responce.successful?
+
+      @deleted = true
+    end
+    alias_method :destroy, :delete
+
+    def send_message(body)
+      SimpleQS::Message.send(self, body)
+    end
+
+    def receive_messages(attributes = nil, max_number_of_messages = nil, visibility_timeout = nil)
+      SimpleQS::Message.receive(self, attributes, max_number_of_messages, visibility_timeout)
+    end
+
+    def get_attributes(attribute_or_array = nil)
+      params = {
+        'Action'    => 'GetQueueAttributes'
+      }
+
+      if attribute_or_array
+        attribute_or_array = [attribute_or_array] unless attribute_or_array.class == Array
+        attribute_or_array.uniq!
+        unless (attribute_or_array - [:All, :ApproximateNumberOfMessages, :ApproximateNumberOfMessagesNotVisible,
+              :VisibilityTimeout, :CreatedTimestamp, :LastModifiedTimestamp, :Policy]).empty?
+          raise ArgumentError,\
+            "Allowed attributes: :All, :ApproximateNumberOfMessages, :ApproximateNumberOfMessagesNotVisible, " <<
+              ":VisibilityTimeout, :CreatedTimestamp, :LastModifiedTimestamp, :Policy"
+        end
+        attribute_or_array.each_index do |i|
+          params["AttributeName.#{i + 1}"] = attribute_or_array[i]
+        end
+      end
+
+      request = build_request(:get, params)
+      responce = request.perform
+      raise responce.to_error unless responce.successful?
+
+      if responce.respond_to?(:attribute)
+        responce.attribute.inject({}) do |result, key_value|
+          result[key_value['Name']] = key_value['Value']
+          result
+        end
+      else
+        {}
+      end
+    end
+
+    def set_visibility_timeout(visibility_timeout)
+      set_attributes({:VisibilityTimeout => visibility_timeout})
+    end
+    
+    def set_policy(policy)
+      set_attributes({:Policy => policy})
+    end
+
+    def set_attributes(attributes)
+      raise ArgumentError, "Allowed attributes: :VisibilityTimeout, :Policy" unless (attributes.keys - [:VisibilityTimeout, :Policy]).empty?
+      self.class.check_visibility_timeout(attributes[:VisibilityTimeout]) if attributes[:VisibilityTimeout]
+
+      params = {
+        'Action'      => 'SetQueueAttributes'
+      }
+
+      i = 1
+      attributes.each do |key, value|
+        params["Attribute.#{i}.Name"] = key.to_s
+        params["Attribute.#{i}.Value"] = value
+        i += 1
+      end
+
+      request = build_request(:get, params)
+      responce = request.perform
+
+      raise responce.to_error unless responce.successful?
+    end
+
+    # label - String, identifier for permissions
+    # permissions - Array of Hashes, [{:account_id => '125074342641', :action => 'SendMessage'}, ...]
+    def add_permissions(label, permissions)
+      self.class.check_queue_name(label)
+
+      params = {
+        'Action'  => 'AddPermission',
+        'Label'    => label
+      }
+
+      i = 1
+      permissions.each do |permission_hash|
+        raise ArgumentError, "invalid action: #{permission_hash[:action]}"\
+          unless ['*', 'SendMessage', 'ReceiveMessage', 'DeleteMessage',
+                  'ChangeMessageVisibility', 'GetQueueAttributes'].include?(permission_hash[:action])
+
+        params["AWSAccountId.#{i}"] = permission_hash[:account_id]
+        params["ActionName.#{i}"]    = permission_hash[:action]
+        i += 1
+      end
+
+      request = build_request(:post, params)
+      responce = request.perform
+
+      raise responce.to_error unless responce.successful?
+    end
+
+    def remove_permissions(label)
+      params = {
+        'Action'  => 'RemovePermission',
+        'Label'    => label
+      }
+
+      request = build_request(:get, params)
+      responce = request.perform
+
+      raise responce.to_error unless responce.successful?
+    end
+
+    def build_request(method, params)
+      request = SimpleQS::Request.build(method, params)
+      request.query_string = [SimpleQS.account_id, name]
+      request
+    end
+    
+    class << self
+      # Create new queue
+      # Parameters:
+      #    name - String, name of queue. Should be not longer than 80 chars and contain only a-zA-Z0-9\-\_
+      #    default_visibility_timeout - Fixnum, visibility timeout [Optional]. In range 0 to MAX_VISIBILITY_TIMEOUT.
+      #                                 If nil, then default is used (30 seconds).
+      #    &block - if given, then newly created queue object passed to it
+      #  Returns:
+      #    SimpleQS::Queue
+      #  Raises:
+      #    ArgumentError
+      #    SimpleQS::Queue::MaxVisibilityError
+      #    SimpleQS::Responce::Error
+      def create(name, default_visibility_timeout = nil, &block)
+        
+        check_queue_name(name)
+        check_visibility_timeout(default_visibility_timeout)
+        
+        params = {
+          'Action'    => 'CreateQueue',
+          'QueueName' => name
+        }
+        params['DefaultVisibilityTimeout'] = default_visibility_timeout if default_visibility_timeout
+        
+        request = SimpleQS::Request.build(:get, params)
+        responce = request.perform
+        if responce.successful?
+          queue = new(responce.queue_url)
+          yield queue if block_given?
+          queue
+        else
+          raise responce.to_error
+        end
+      end
+
+      # List queues
+      # Parameters:
+      #    pattern - String, first letterns of queues names [Optional].
+      # Returns:
+      #    Array - array of SimpleQS::Queue or empty if nothing found
+      #  Rises:
+      #    ArgumentError
+      #    SimpleQS::Responce::Error
+      def list(pattern = nil)
+        params = {
+          'Action'    => 'ListQueues'
+        }
+
+        check_queue_name(pattern) if pattern
+        params['QueueNamePrefix'] = pattern if pattern
+
+        request = SimpleQS::Request.build(:get, params)
+        responce = request.perform
+        raise responce.to_error unless responce.successful?
+
+        begin
+          queues = responce.queue_url.class == Array ? responce.queue_url : [responce.queue_url]
+          queues.map {|queue_url| new(queue_url)}
+        rescue NoMethodError
+          []
+        end
+      end
+      
+      def exists?(queue_name)
+        list(queue_name).any? {|queue| queue.name == queue_name}
+      end
+      
+      def delete(queue_name)
+        new(queue_name).delete
+      end
+      alias_method :destroy, :delete
+      
+      # Performs checks on queue name. Raises ArgumentError with message in case of
+      # constraint violation
+      def check_queue_name(name)
+        raise ArgumentError, "expected to be String, but got #{name.class.to_s}" unless name.class == String
+        raise(
+          ArgumentError,
+          "should be maximum 80 characters long"
+        ) if name.length > 80
+        raise(
+          ArgumentError,
+          "should contain only alphanumeric characters, hyphens (-), and underscores (_)"
+        ) if name =~ /[^a-zA-Z0-9\_\-]/
+      end
+      
+      # Performs checks on visibility timeout. Raises ArgumentError or SimpleQS::Queue::MaxVisibilityError
+      # with message in case of constraint violation
+      def check_visibility_timeout(default_visibility_timeout)
+        raise(
+          ArgumentError,
+          "expected visibility timeout to respon to to_i, but #{default_visibility_timeout.class.to_s} doesn't"
+        ) if default_visibility_timeout && default_visibility_timeout.class != Fixnum
+        raise(
+          MaxVisibilityError,
+          "expected visibility timeout to be in 0...#{MAX_VISIBILITY_TIMEOUT} range, got #{default_visibility_timeout}"
+        ) if default_visibility_timeout && !(0...MAX_VISIBILITY_TIMEOUT).include?(default_visibility_timeout)
+      end
+    end
+  end
+end

data/lib/simple_qs/request.rb

@@ -0,0 +1,24 @@
+module SimpleQS
+  module Request
+    autoload :Base,     'simple_qs/request/base'
+    autoload :Get,      'simple_qs/request/get'
+    autoload :Post,     'simple_qs/request/post'
+    
+    class UnknownHttpMethod < StandardError; end
+    
+    HTTP_METHODS = {
+      :get    => :Get,
+      :post   => :Post
+    }
+    
+    class << self
+      def build(request, params = {})
+        if SimpleQS::Request::HTTP_METHODS.keys.include?(request)
+          SimpleQS::Request.const_get(HTTP_METHODS[request]).new(params)
+        else
+          raise SimpleQS::Request::UnknownHttpMethod, "Method #{request} is unknown or unsupported"
+        end
+      end
+    end
+  end
+end

data/lib/simple_qs/request/base.rb

@@ -0,0 +1,105 @@
+require 'uri'
+require 'net/http'
+require 'base64'
+require 'hmac-sha1'
+
+module SimpleQS
+  module Request
+    class Base
+      
+      RESERVED_CHARACTERS = /[^a-zA-Z0-9\-\.\_\~]/
+      SIGNATURE_VERSION   = 2
+      SIGNATURE_METHOD    = 'HmacSHA1'
+      
+      def initialize(params = {})
+        self.query_params = params
+      end
+      
+      def ==(other)
+        self.class.http_method == other.class.http_method\
+          && query_params == other.query_params\
+          && query_string == other.query_string
+      end
+
+      def timestamp
+        @timestamp ||= _timestamp
+      end
+      
+      def timestamp=(time)
+        raise ArgumentError, "expected Time object, bug got #{time.class.to_s} instead." unless time.kind_of?(Time)
+        @timestamp = time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+
+      def query_params
+        @query_params ||= {}
+        @query_params = {
+          'SignatureVersion'    => SIGNATURE_VERSION,
+          'SignatureMethod'     => SIGNATURE_METHOD,
+          'Version'             => SimpleQS::API_VERSION,
+          'Timestamp'           => timestamp,
+          'AWSAccessKeyId'      => SimpleQS.access_key_id
+        }.merge(@query_params)
+        @query_params.delete('Timestamp') if @query_params['Expires']
+        
+        @query_params
+      end
+      attr_writer :query_params
+      
+      def update_query_params(params)
+        @query_params = query_params.merge params
+      end
+
+      def query_string
+        @query_string ||= "/"
+      end
+      
+      def query_string=(value)
+        value = value.join('/') if value.kind_of?(Array)
+        @query_string = (value =~ /^\// ? value : "/#{value}")
+      end
+
+      # Canonicalizes query string
+      def canonical_query_string
+        params_to_query(query_params.sort)
+      end
+
+      def signature_base_string
+        [
+          self.class.http_method.to_s.upcase,
+          SimpleQS.host.downcase,
+          query_string,
+          canonical_query_string
+        ].join("\n")
+      end
+
+      def uri(with_query_params = false)
+        "http://#{SimpleQS.host}#{query_string}" << (with_query_params ? "?#{params_to_query(query_params)}" : '')
+      end
+      
+      def sign!
+        update_query_params({
+          'Signature'   => Base64.encode64(HMAC::SHA1.digest(SimpleQS.secret_access_key, signature_base_string)).chomp
+        })
+        self
+      end
+
+      def params_to_query(params)
+        params.map {|pair| pair.map {|value| URI.escape(value.to_s, RESERVED_CHARACTERS)}.join('=')}.join('&')
+      end
+      
+      class << self
+        def http_method(value = nil)
+          @http_method = value if value
+          @http_method
+        end
+      end
+      
+      protected
+
+      # Generates UTC timestamp in dateTime object format
+      def _timestamp
+        Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+      end
+    end
+  end
+end

data/lib/simple_qs/request/get.rb

@@ -0,0 +1,12 @@
+module SimpleQS
+  module Request
+    class Get < Base
+      http_method :get
+      
+      def perform
+        sign!
+        SimpleQS::Responce.new Net::HTTP.get(URI.parse(uri(true)))
+      end
+    end
+  end
+end

data/lib/simple_qs/request/post.rb

@@ -0,0 +1,12 @@
+module SimpleQS
+  module Request
+    class Post < Base
+      http_method :post
+
+      def perform
+        sign!
+        SimpleQS::Responce.new Net::HTTP.post_form(URI.parse(uri), query_params).body
+      end
+    end
+  end
+end

data/lib/simple_qs/responce.rb

@@ -0,0 +1,30 @@
+require 'xmlsimple'
+
+require 'simple_qs/responce/exceptions'
+
+module SimpleQS
+  class Responce
+    
+    autoload :SuccessfulBuilder,    'simple_qs/responce/successful_builder'
+    autoload :FailureBuilder,       'simple_qs/responce/failure_builder'
+    
+    def initialize(xml)
+      _parse xml
+    end
+    
+    def successful?
+      !@xml_data.key?('ErrorResponse')
+    end
+
+    def root_element
+      @xml_data.keys[0]
+    end
+    
+    private
+    
+    def _parse(xml)
+      @xml_data = XmlSimple.xml_in(xml, {'ForceArray' => false, 'KeepRoot' => true})
+      (successful? ? SuccessfulBuilder : FailureBuilder).build(self)
+    end
+  end
+end

data/lib/simple_qs/responce/exceptions.rb

@@ -0,0 +1,38 @@
+module SimpleQS
+  class Responce
+
+    class Error < StandardError; end
+
+    class AccessDeniedError                            < Error; end
+    class AuthFailureError                            < Error; end
+    class AWSSimpleQueueServiceInternalError          < Error; end
+    class AWSSimpleQueueServiceNonExistentQueueError  < Error; end
+    class AWSSimpleQueueServiceQueueDeletedRecently    < Error; end
+    class AWSSimpleQueueServiceQueueNameExists        < Error; end
+    class ConflictingQueryParameterError              < Error; end
+    class InvalidParameterValueError                  < Error; end
+    class InternalError                                < Error; end
+    class InvalidAccessKeyIdError                      < Error; end
+    class InvalidActionError                          < Error; end
+    class InvalidAddressError                          < Error; end
+    class InvalidHttpRequestError                      < Error; end
+    class InvalidParameterCombinationError            < Error; end
+    class InvalidParameterValueError                  < Error; end
+    class InvalidQueryParameterError                  < Error; end
+    class InvalidRequestError                          < Error; end
+    class InvalidSecurityError                        < Error; end
+    class InvalidSecurityTokenError                    < Error; end
+    class MalformedVersionError                        < Error; end
+    class MissingClientTokenIdError                    < Error; end
+    class MissingCredentialsError                      < Error; end
+    class MissingParameterError                        < Error; end
+    class NoSuchVersionError                          < Error; end
+    class NotAuthorizedToUseVersionError              < Error; end
+    class OptInRequiredError                          < Error; end
+    class RequestExpiredError                          < Error; end
+    class RequestThrottledError                        < Error; end
+    class ServiceUnavailableError                      < Error; end
+    class SignatureDoesNotMatchError                  < Error; end
+    class X509ParseError                              < Error; end
+  end
+end

data/lib/simple_qs/responce/failure_builder.rb

@@ -0,0 +1,33 @@
+module SimpleQS
+  class Responce
+    class FailureBuilder
+      def self.build responce
+        responce.instance_eval do
+          def sender_error?
+            @xml_data[root_element]['Error']['Type'] == 'Sender'
+          end
+
+          def receiver_error?
+            @xml_data[root_element]['Error']['Type'] == 'Receiver'
+          end
+
+          def request_id
+            @xml_data[root_element]['RequestId']
+          end
+
+          def error_code
+            @xml_data[root_element]['Error']['Code'].gsub(/\./, '')
+          end
+          
+          def error_message
+            @xml_data[root_element]['Error']['Message']
+          end
+
+          def to_error
+            self.class.const_get(error_code =~ /Error$/ ? error_code : "#{error_code}Error").new error_message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_qs/responce/successful_builder.rb

@@ -0,0 +1,26 @@
+module SimpleQS
+  class Responce
+    class SuccessfulBuilder
+      def self.build responce
+        responce.instance_eval do
+
+          def action_name
+            @action_name ||= root_element.gsub(/Response/, '')
+          end
+
+          def request_id
+            @xml_data[root_element]['ResponseMetadata']['RequestId']
+          end
+
+          @xml_data[root_element]["#{action_name}Result"].each do |key, value|
+            self.instance_eval %{
+              def #{key.gsub(/([A-Z]+)/, '_\1').downcase.gsub(/^_/, '')}
+                #{value.inspect}
+              end
+            }
+          end if @xml_data[root_element]["#{action_name}Result"]
+        end
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module SimpleQS
+  VERSION = '0.1.2'
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - !binary |
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-16 00:00:00 +03:00
+date: 2010-08-17 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,6 +48,18 @@ dependencies:
         version: 0.3.2
   type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: SimpleQS library fully wraps Amazon SQS REST API. It allows you perform all kind of calls on queues and messages.
 email: krekoten@gmail.com
 executables: []
@@ -56,8 +68,23 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- lib/simple_qs/message.rb
+- lib/simple_qs/queue.rb
+- lib/simple_qs/request/base.rb
+- lib/simple_qs/request/get.rb
+- lib/simple_qs/request/post.rb
+- lib/simple_qs/request.rb
+- lib/simple_qs/responce/exceptions.rb
+- lib/simple_qs/responce/failure_builder.rb
+- lib/simple_qs/responce/successful_builder.rb
+- lib/simple_qs/responce.rb
+- lib/simple_qs.rb
+- lib/version.rb
+- LICENSE
+- README.md
+- CHANGELOG.md
+- TODO.md
 has_rdoc: true
 homepage: http://github.com/krekoten/SimpleQS
 licenses: []