aliyun-mqs 0.0.3 → 0.1.1

data/lib/aliyun/mqs/message.rb

@@ -0,0 +1,56 @@
+module Aliyun::Mqs
+  class Message
+
+    attr_reader :queue, :id, :body_md5, :body, :receipt_handle, :enqueue_at, :first_enqueue_at, :next_visible_at, :dequeue_count, :priority
+
+    def initialize queue, content
+      h = Hash.xml_object(content, "Message")
+      @queue = queue
+      @id = h["MessageId"]
+      @body_md5 = h["MessageBodyMD5"]
+      @body = h["MessageBody"]
+      @enqueue_at = Time.at(h["EnqueueTime"].to_i/1000.0)
+      @first_enqueue_at = Time.at(h["FirstDequeueTime"].to_i/1000.0)
+      @next_visible_at = Time.at(h["NextVisibleTime"].to_i/1000.0) if h["NextVisibleTime"]
+      @dequeue_count = h["DequeueCount"].to_i
+      @priority = h["Priority"].to_i
+      @receipt_handle = h["ReceiptHandle"]
+    end
+
+    def delete
+      check_receipt_handle
+      Aliyun::Mqs::Request.delete(queue.messages_path, params:{:ReceiptHandle => receipt_handle})
+    end
+
+    def change_visibility seconds
+      check_receipt_handle
+      Aliyun::Mqs::Request.put(queue.messages_path, params:{:ReceiptHandle => receipt_handle, :VisibilityTimeout=>seconds})
+    end
+
+    def to_s
+      s = {
+        "队列"=> queue.name, 
+        "ID"=>id, 
+        "MD5"=>body_md5, 
+        "Receipt handle"=>receipt_handle, 
+        "Enqueue at"=>enqueue_at,
+        "First enqueue at"=>first_enqueue_at,
+        "Next visible at"=>next_visible_at,
+        "Dequeue count" => dequeue_count,
+        "Priority"=>priority
+      }.collect{|k,v| "#{k}: #{v}"}
+
+      sep = "============================================="
+      s.unshift sep
+      s << sep
+      s << body
+      s.join("\n")
+    end
+
+    private 
+    def check_receipt_handle
+      raise "No receipt handle for this operation" unless receipt_handle
+    end
+
+  end
+end

data/lib/aliyun/mqs/queue.rb

@@ -1,77 +1,67 @@
-require 'active_support/core_ext/hash'
-require 'builder'
-require 'aliyun/mqs/http'
+module Aliyun::Mqs
+  class Queue
+    attr_reader :name
 
-module Aliyun
-  module Mqs
+    delegate :to_s, to: :name
 
-    class Queue
-      include Mqs::Http
-
-      def initialize(name, access_owner_id: nil)
-        @access_key_id     = Mqs.configuration.access_key_id
-        @access_key_secret = Mqs.configuration.access_key_secret
-        @access_region     = Mqs.configuration.access_region
-        @access_owner_id   = access_owner_id || Mqs.configuration.access_owner_id
-        @access_queue = name
-        @access_host  = "#{@access_owner_id}.mqs-#{@access_region}.aliyuncs.com"
-        throw '参数不能为nil' if instance_variables.any? {|x| x == nil}
+    class << self
+      def [] name
+        Queue.new(name)
       end
 
-
-      def destroy
-        verb = 'DELETE'
-        request_resource = "/#{@access_queue}"
-        request_uri = "http://#{@access_host}#{request_resource}"
-        send_request(verb, request_uri)
+      def queues opts={}
+        mqs_options = {query: "x-mqs-prefix", offset: "x-mqs-marker", size: "x-mqs-ret-number"}
+        mqs_headers = opts.slice(*mqs_options.keys).reduce({}){|mqs_headers, item| k, v = *item; mqs_headers.merge!(mqs_options[k]=>v)}
+        response = Request.get("/", mqs_headers: mqs_headers)
+        Hash.xml_array(response, "Queues", "Queue").collect{|item| Queue.new(URI(item["QueueURL"]).path.sub!(/^\//, ""))}
       end
+    end
 
-      def send(message_body, delay_seconds: 0, priority: 8)
-        verb = 'POST'
-        content_body = to_xml(message_body, delay_seconds, priority)
-        request_resource = "/#{@access_queue}/messages"
-        request_uri = "http://#{@access_host}#{request_resource}"
-        send_request(verb, request_uri, content_body)
-      end
+    def initialize name
+      @name = name
+    end
 
-      def receive(waitseconds: nil, peekonly: false)
-        verb = 'GET'
-        query_params = {}
-        query_params[:waitseconds] = waitseconds if waitseconds
-        query_params[:peekonly] = true if peekonly # Aliyun doesn't accept uncessary query params
-        request_resource =  "/#{@access_queue}/messages" + (query_params.length > 0 ? '?' + query_params.to_param : '')
-        request_uri      = "http://#{@access_host}#{request_resource}"
-        send_request(verb, request_uri)
+    def create opts={}
+      response = Request.put(queue_path) do |request|
+        msg_options = {
+          :VisibilityTimeout => 30,
+          :DelaySeconds => 0,
+          :MaximumMessageSize => 65536,
+          :MessageRetentionPeriod => 345600,
+          :PollingWaitSeconds => 0}.merge(opts)
+        request.content :Queue, msg_options
       end
+    end
 
-      def delete message
-        verb = 'DELETE'
-        if String === message
-          receipt_handle = message
-        elsif Response === message
-          receipt_handle = message.receipt_handle
-        end
-        request_resource = "/#{@access_queue}/messages?" + {ReceiptHandle: receipt_handle}.to_param
-        request_uri = "http://#{@access_host}#{request_resource}"
-        send_request(verb, request_uri)
-      end
+    def delete
+      Request.delete(queue_path)
+    end
 
-      def peek(waitseconcds: nil)
-        receive(waitseconds: waitseconcds, peekonly: true)
+    def send_message message, opts={}
+      Request.post(messages_path) do |request|
+        msg_options = {:DelaySeconds => 0, :Priority => 10}.merge(opts)
+        request.content :Message, msg_options.merge(:MessageBody => message.to_s)
       end
+    end
 
-      private
+    def receive_message wait_seconds: nil
+      request_opts = {}
+      request_opts.merge!(params:{waitseconds: wait_seconds}) if wait_seconds
+      result = Request.get(messages_path, request_opts)
+      Message.new(self, result)
+    end
 
-      def to_xml(message_body, delay_seconds, priority)
-        xml = Builder::XmlMarkup.new( :indent => 2 )
-        xml.instruct! :xml, :encoding => 'UTF-8'
-        xml.Message(:xmlns => 'http://mqs.aliyuncs.com/doc/v1/') do |m|
-          m.MessageBody message_body
-          m.DelaySeconds delay_seconds
-          m.Priority priority
-        end
-      end
+    def peek_message
+      result = Request.get(messages_path, params: {peekonly: true})
+      Message.new(self, result)
+    end
+
+    def queue_path
+      "/#{name}"
+    end
 
+    def messages_path
+      "/#{name}/messages"
     end
 
   end

data/lib/aliyun/mqs/request.rb

@@ -0,0 +1,88 @@
+require 'base64'
+module Aliyun::Mqs
+
+  class RequestException < Exception
+    attr_reader :content
+    delegate :[], to: :content
+
+    def initialize ex
+      @content = Hash.xml_object(ex.to_s, "Error")
+    rescue
+      @content = {"Message" => ex.message}
+    end
+  end
+
+  class Request
+    attr_reader :uri, :method, :date, :body, :content_md5, :content_type, :content_length, :mqs_headers
+    delegate :access_id, :key, :owner_id, :region, to: :configuration
+
+    class << self
+      [:get, :delete, :put, :post].each do |m|
+        define_method m do |*args, &block|
+          options = {method: m, path: args[0], mqs_headers: {}, params: {}}
+          options.merge!(args[1]) if args[1].is_a?(Hash)
+
+          request = Aliyun::Mqs::Request.new(options)
+          block.call(request) if block
+          request.execute
+        end
+      end
+    end
+
+    def initialize method: "get", path: "/", mqs_headers: {}, params: {}
+      conf = {
+        host: "#{owner_id}.mqs-#{region}.aliyuncs.com",
+        path: path
+      }
+      conf.merge!(query: params.to_query) unless params.empty?
+      @uri = URI::HTTP.build(conf)
+      @method = method
+      @mqs_headers = mqs_headers.merge("x-mqs-version" => "2014-07-08")
+    end
+
+    def content type, values={}
+      ns = "http://mqs.aliyuncs.com/doc/v1/"
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.send(type.to_sym, xmlns: ns) do |b|
+          values.each{|k,v| b.send k.to_sym, v}
+        end
+      end
+      @body = builder.to_xml
+      @content_md5 = Base64::encode64(Digest::MD5.hexdigest(body)).chop
+      @content_length = body.size
+      @content_type = "text/xml;charset=utf-8"
+    end
+
+    def execute
+      date = DateTime.now.httpdate
+      headers =  {
+        "Authorization" => authorization(date),
+        "Content-Length" => content_length || 0,
+        "Content-Type" => content_type,
+        "Content-MD5" => content_md5,
+        "Date" => date,
+        "Host" => uri.host
+      }.merge(mqs_headers).reject{|k,v| v.nil?}
+      begin
+        RestClient.send *[method, uri.to_s, body, headers].compact
+      rescue RestClient::Exception => ex
+        raise RequestException.new(ex)
+      end
+    end
+
+    private
+    def configuration
+      Aliyun::Mqs.configuration
+    end
+
+    def authorization date
+      canonical_resource = [uri.path, uri.query].compact.join("?")
+      canonical_mq_headers = mqs_headers.sort.collect{|k,v| "#{k.downcase}:#{v}"}.join("\n")
+      method = self.method.to_s.upcase
+      signature = [method, content_md5 || "" , content_type || "" , date, canonical_mq_headers, canonical_resource].join("\n")
+      sha1 = Digest::HMAC.digest(signature, key, Digest::SHA1)
+      "MQS #{access_id}:#{Base64.encode64(sha1).chop}"
+    end
+
+  end
+end

data/lib/aliyun/mqs/version.rb

@@ -1,5 +1,5 @@
 module Aliyun
   module Mqs
-    VERSION = "0.0.3"
+    VERSION = "0.1.1"
   end
 end

data/spec/lib/aliyun/mqs/message_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Aliyun::Mqs::Queue do
+
+  let(:xml_message){
+    Aliyun::Mqs::Message.new(Aliyun::Mqs::Queue["aQueue"], <<-XML)
+      <?xml version="1.0" encoding="UTF-8" ?> 
+      <Message xmlns="http://mqs.aliyuncs.com/doc/v1/">
+        <MessageId>5fea7756-0ea4-451a-a703-a558b933e274</MessageId> 
+        <ReceiptHandle>MbZj6wDWli+QEauMZc8ZRv37sIW2iJKq3M9Mx/KSbkJ0</ReceiptHandle>
+        <MessageBodyMD5>fafb00f5732ab283681e124bf8747ed1</MessageBodyMD5> 
+        <MessageBody>This is a test message</MessageBody>
+        <EnqueueTime>1250700979248000</EnqueueTime> 
+        <NextVisibleTime>1250700799348000</NextVisibleTime>
+        <FirstDequeueTime>1250700779318000</FirstDequeueTime > 
+        <DequeueCount>1</DequeueCount >
+        <Priority>8</Priority>
+      </Message>
+    XML
+  }
+
+  let(:peek_xml_message){
+    Aliyun::Mqs::Message.new(Aliyun::Mqs::Queue["aQueue"], <<-XML)
+      <?xml version="1.0" encoding="UTF-8" ?>
+      <Message xmlns="http://mqs.aliyuncs.com/doc/v1/">
+        <MessageId>5fea7756-0ea4-451a-a703-a558b933e274</MessageId>
+        <MessageBodyMD5>fafb00f5732ab283681e124bf8747ed1</MessageBodyMD5>
+        <MessageBody>This is a test message</MessageBody>
+        <EnqueueTime>1250700979248000</EnqueueTime>
+        <FirstDequeueTime>1250700979348000</FirstDequeueTime>
+        <DequeueCount>5</DequeueCount>
+        <Priority>8</Priority>
+      </Message>
+    XML
+  }
+
+  describe "#delete" do
+    specify "will delete the message from queue" do
+      expect(Aliyun::Mqs::Request).to receive(:delete).with("/aQueue/messages", params:{:ReceiptHandle=>"MbZj6wDWli+QEauMZc8ZRv37sIW2iJKq3M9Mx/KSbkJ0"})
+      xml_message.delete
+    end
+
+    specify "won't delete message without receipt_handle" do
+      expect{peek_xml_message.delete}.to raise_exception
+    end
+  end
+
+  describe "#change_visibility" do
+    specify "will change message's visibility timeout" do
+      expect(Aliyun::Mqs::Request).to receive(:put).with("/aQueue/messages", params:{
+        :ReceiptHandle=>"MbZj6wDWli+QEauMZc8ZRv37sIW2iJKq3M9Mx/KSbkJ0",
+        :VisibilityTimeout => 10
+      })
+
+      xml_message.change_visibility 10
+    end
+
+    specify "won't change message's visibility timeout given message has no receipt_handle" do
+      expect{peek_xml_message.change_visibility 10}.to raise_exception
+    end
+  end
+
+end

data/spec/lib/aliyun/mqs/queue_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Aliyun::Mqs::Queue do
+  
+  specify ".[] will create new queue instance" do
+    queue = Aliyun::Mqs::Queue["aQueue"]
+    expect(queue).not_to be_nil
+    expect(queue.name).to eq("aQueue")
+  end
+
+  describe ".queues" do
+    let(:xml_response){
+       <<-XML
+        <?xml version="1.0"?>
+        <Queues xmlns="http://mqs.aliyuncs.com/doc/v1">
+          <Queue>
+            <QueueURL>http://xxxxx.mqs-cn-hangzhou.aliyuncs.com/test</QueueURL>
+          </Queue>
+        </Queues>
+      XML
+    }
+
+    specify "find all queues" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/", mqs_headers:{}).and_return xml_response
+      queues = Aliyun::Mqs::Queue.queues
+      expect(queues.size).to eq(1)
+      expect(queues[0].name).to eq("test")
+    end
+
+    specify "query queues" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/", mqs_headers:{"x-mqs-prefix"=>"query"}).and_return xml_response
+      queues = Aliyun::Mqs::Queue.queues(query: "query")
+    end
+
+    specify "find number of queues" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/", mqs_headers:{"x-mqs-ret-number"=>5}).and_return xml_response
+      queues = Aliyun::Mqs::Queue.queues(size: 5)
+    end
+
+    specify "find of queues start at given position" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/", mqs_headers:{"x-mqs-marker"=>2}).and_return xml_response
+      queues = Aliyun::Mqs::Queue.queues(offset: 2)
+    end
+  end
+
+
+  describe "#create" do
+    specify "will create a new queue with default options" do
+      expect(RestClient).to receive(:put) do |*args|
+        path, body, headers = *args
+        expect(path).to eq("http://owner-id.mqs-region.aliyuncs.com/aQueue")
+        xml = Hash.from_xml(body)
+        expect(xml["Queue"]["VisibilityTimeout"]).to eq("30")
+        expect(xml["Queue"]["DelaySeconds"]).to eq("0")
+        expect(xml["Queue"]["MaximumMessageSize"]).to eq("65536")
+        expect(xml["Queue"]["MessageRetentionPeriod"]).to eq("345600")
+        expect(xml["Queue"]["PollingWaitSeconds"]).to eq("0")
+        expect(headers).not_to be_nil
+      end
+      Aliyun::Mqs::Queue["aQueue"].create
+    end
+
+    specify "will create a new queue with customized options" do
+      expect(RestClient).to receive(:put) do |*args|
+        path, body, headers = *args
+        expect(Hash.from_xml(body)["Queue"]["PollingWaitSeconds"]).to eq("30")
+      end
+      Aliyun::Mqs::Queue["aQueue"].create(:PollingWaitSeconds => 30)
+    end
+  end
+
+  describe "#delete" do
+    specify "will delete existing queue" do
+      expect(Aliyun::Mqs::Request).to receive(:delete).with("/aQueue")
+      Aliyun::Mqs::Queue["aQueue"].delete
+    end
+  end
+
+  describe "#send_message" do
+    specify "will send a message to a queue with default options" do
+      expect(RestClient).to receive(:post) do |*args|
+        path, body, headers = *args
+        expect(path).to eq("http://owner-id.mqs-region.aliyuncs.com/aQueue/messages")
+        xml = Hash.from_xml(body)
+        expect(xml["Message"]["MessageBody"]).to eq("text message")
+        expect(xml["Message"]["DelaySeconds"]).to eq("0")
+        expect(xml["Message"]["Priority"]).to eq("10")
+        expect(headers).not_to be_nil
+      end
+
+      Aliyun::Mqs::Queue["aQueue"].send_message "text message"
+    end
+
+
+    specify "will send a message to a queue with customized options" do
+      expect(RestClient).to receive(:post) do |*args|
+        path, body, headers = *args
+        expect(Hash.from_xml(body)["Message"]["Priority"]).to eq("1")
+      end
+
+      Aliyun::Mqs::Queue["aQueue"].send_message "text message", :Priority=>1
+    end
+  end
+  
+
+  describe "#receive_message" do
+    let(:xml_response){
+      <<-XML
+      <?xml version="1.0" encoding="UTF-8" ?> 
+      <Message xmlns="http://mqs.aliyuncs.com/doc/v1/">
+        <MessageId>5fea7756-0ea4-451a-a703-a558b933e274</MessageId> 
+        <ReceiptHandle>MbZj6wDWli+QEauMZc8ZRv37sIW2iJKq3M9Mx/KSbkJ0</ReceiptHandle>
+        <MessageBodyMD5>fafb00f5732ab283681e124bf8747ed1</MessageBodyMD5> 
+        <MessageBody>This is a test message</MessageBody>
+        <EnqueueTime>1250700979248000</EnqueueTime> 
+        <NextVisibleTime>1250700799348000</NextVisibleTime>
+        <FirstDequeueTime>1250700779318000</FirstDequeueTime > 
+        <DequeueCount>1</DequeueCount >
+        <Priority>8</Priority>
+      </Message>
+      XML
+    }
+
+    specify "will receive message from a queue" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/aQueue/messages",{}).and_return xml_response
+
+      message = Aliyun::Mqs::Queue["aQueue"].receive_message
+      expect(message).not_to be_nil
+      expect(message.id).to eq("5fea7756-0ea4-451a-a703-a558b933e274")
+      expect(message.body).to eq("This is a test message")
+      expect(message.body_md5).to eq("fafb00f5732ab283681e124bf8747ed1")
+      expect(message.receipt_handle).to eq("MbZj6wDWli+QEauMZc8ZRv37sIW2iJKq3M9Mx/KSbkJ0")
+      expect(message.enqueue_at).to eq(Time.at(1250700979248000/1000.0))
+      expect(message.first_enqueue_at).to eq(Time.at(1250700779318000/1000.0))
+      expect(message.next_visible_at).to eq(Time.at(1250700799348000/1000.0))
+      expect(message.dequeue_count).to eq(1)
+      expect(message.priority).to eq(8)
+    end
+
+    specify "will receive message from a queue with poll wait" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/aQueue/messages",params:{waitseconds: 60}).and_return xml_response
+      message = Aliyun::Mqs::Queue["aQueue"].receive_message wait_seconds: 60
+    end
+  end
+
+  describe "#peek" do
+    let(:xml_response){
+      <<-XML
+      <?xml version="1.0" encoding="UTF-8" ?>
+      <Message xmlns="http://mqs.aliyuncs.com/doc/v1/">
+        <MessageId>5fea7756-0ea4-451a-a703-a558b933e274</MessageId>
+        <MessageBodyMD5>fafb00f5732ab283681e124bf8747ed1</MessageBodyMD5>
+        <MessageBody>This is a test message</MessageBody>
+        <EnqueueTime>1250700979248000</EnqueueTime>
+        <FirstDequeueTime>1250700979348000</FirstDequeueTime>
+        <DequeueCount>5</DequeueCount>
+        <Priority>8</Priority>
+      </Message>
+      XML
+    }
+
+    specify "will peek message of a queue" do
+      expect(Aliyun::Mqs::Request).to receive(:get).with("/aQueue/messages",params:{peekonly: true}).and_return xml_response
+      message = Aliyun::Mqs::Queue["aQueue"].peek_message
+
+      expect(message).not_to be_nil
+      expect(message.id).to eq("5fea7756-0ea4-451a-a703-a558b933e274")
+      expect(message.body).to eq("This is a test message")
+      expect(message.body_md5).to eq("fafb00f5732ab283681e124bf8747ed1")
+      expect(message.receipt_handle).to be_nil
+      expect(message.enqueue_at).to eq(Time.at(1250700979248000/1000.0))
+      expect(message.first_enqueue_at).to eq(Time.at(1250700979348000/1000.0))
+      expect(message.next_visible_at).to be_nil
+      expect(message.dequeue_count).to eq(5)
+      expect(message.priority).to eq(8)
+    end
+  end
+
+end