em-amazon-sqs 0.1.0

data/example/server.rb

@@ -0,0 +1,27 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+require 'rubygems'
+require 'lib/simple_qs'
+
+unless ENV['AWS_ACCESS_KEY_ID'] && ENV['AWS_SECRET_ACCESS_KEY'] && ENV['AWS_ACCOUNT_ID']
+  abort "Please set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_ACCOUNT_ID environment variables"
+end
+
+SimpleQS.access_key_id      = ENV['AWS_ACCESS_KEY_ID']
+SimpleQS.secret_access_key  = ENV['AWS_SECRET_ACCESS_KEY']
+SimpleQS.account_id         = ENV['AWS_ACCOUNT_ID']
+
+@queue = SimpleQS::Queue.create('testMessageBus')
+
+while true do
+  messages = @queue.receive_messages
+  unless messages.empty?
+    message = messages.first
+    message.delete
+    if message.body == 'quit'
+      puts "Quitting..."
+      break
+    else
+      puts "[MESSAGE]: #{message.body}"
+    end
+  end
+end

data/lib/simple_qs.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+
+$: << File.join(File.dirname(__FILE__))
+
+module SimpleQS
+  
+  API_VERSION = '2009-02-01'
+  
+  SQS_HOSTS = {
+    :us_east_1      => 'sqs.us-east-1.amazonaws.com',
+    :us_west_1      => 'sqs.us-west-1.amazonaws.com',
+    :eu_west_1      => 'sqs.eu-west-1.amazonaws.com',
+    :ap_southeast_1 => 'sqs.ap-southeast-1.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: :us_east_1, :us_west_1, :eu_west_1, :ap_southeast_1' unless SQS_HOSTS.key?(value)
+      @host = value
+    end
+    
+    def host
+      @host ||= :us_east_1
+      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,298 @@
+module SimpleQS
+  class Queue
+    
+    class MaxVisibilityError < StandardError; end
+    class MaxMessageSizeError < StandardError; end
+    class MessageRetentionPeriodError < 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_maximum_message_size(message_size)
+      set_attributes({:MaximumMessageSize => message_size})
+    end
+    
+    def set_message_retention_period(period)
+      set_attributes({:MessageRetentionPeriod => period})
+    end
+
+    ALLOWED_ATTRIBUTES = [
+      :VisibilityTimeout,
+      :Policy,
+      :MaximumMessageSize,
+      :MessageRetentionPeriod
+    ]
+
+    def set_attributes(attributes)
+      unless (attributes.keys - ALLOWED_ATTRIBUTES).empty?
+        raise ArgumentError, "Allowed attributes: #{ALLOWED_ATTRIBUTES.map {|attr| ":" << attr.to_s}.join(", ")}"
+      end
+      self.class.check_visibility_timeout(attributes[:VisibilityTimeout]) if attributes[:VisibilityTimeout]
+      if attributes[:MaximumMessageSize] && !(1024..65536).include?(attributes[:MaximumMessageSize])
+        raise MaxMessageSizeError, 'MaximumMessageSize should be between 1024 and 65536'
+      end
+      if attributes[:MessageRetentionPeriod] && !(3600..1209600).include?(attributes[:MessageRetentionPeriod])
+        raise MessageRetentionPeriodError, 'MessageRetentionPeriod should be between 3600 and 1209600'
+      end
+
+      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