waz-queues 0.1.0

data/lib/waz-queues.rb

@@ -0,0 +1,19 @@
+require 'time'
+require 'cgi'
+require 'base64'
+require 'rexml/document'
+require 'rexml/xpath'
+
+require 'restclient'
+require 'hmac-sha2'
+
+$:.unshift(File.dirname(__FILE__))
+require 'waz/storage/core_service'
+require 'waz/queues/base'
+require 'waz/queues/exceptions'
+require 'waz/queues/message'
+require 'waz/queues/queue'
+require 'waz/queues/service'
+require 'waz/queues/version'
+
+

data/lib/waz/queues/base.rb

@@ -0,0 +1,22 @@
+module WAZ
+  module Queues
+    class Base
+      class << self
+        def establish_connection!(options = {})
+          raise InvalidOption.new(:account_name) unless options.keys.include? :account_name
+          raise InvalidOption.new(:access_key) unless options.keys.include? :access_key
+          options[:use_ssl] = false unless options.keys.include? :use_ssl
+          @connection = options
+        end
+        
+        def default_connection
+          return @connection
+        end
+        
+        def connected?
+          return !@connection.nil?
+        end
+      end
+    end
+  end
+end

data/lib/waz/queues/exceptions.rb

@@ -0,0 +1,30 @@
+module WAZ
+  module Queues
+    class WAZStorageException < StandardError
+    end
+    
+    class InvalidOption < WAZStorageException
+      def initialize(missing_option)
+        super("You did not provide one of the required parameters. Please provide the #{missing_option}.")
+      end
+    end
+    
+    class QueueAlreadyExists < WAZStorageException
+      def initialize(name)
+        super("The queue #{name} already exists on your account.")
+      end
+    end
+    
+    class OptionOutOfRange < WAZStorageException
+      def initialize(args = {})
+        super("The #{args[:name]} parameter is out of range allowed values go from #{args[:min]} to  #{args[:max]}.")
+      end
+    end
+    
+    class InvalidOperation < WAZStorageException
+      def initialize()
+        super("A peeked message cannot be delete, you need to lock it first (pop_receipt required).")
+      end
+    end
+  end
+end

data/lib/waz/queues/message.rb

@@ -0,0 +1,31 @@
+module WAZ
+  module Queues
+    class Message
+      attr_accessor :message_id, :message_text, :pop_receipt, :expiration_time, :insertion_time, :time_next_visible
+      def initialize(params = {})
+        self.message_id = params[:message_id]
+        self.message_text = params[:message_text]
+        self.pop_receipt = params[:pop_receipt] 
+        self.expiration_time = params[:expiration_time]
+        self.insertion_time = params[:insertion_time]
+        self.time_next_visible = params[:time_next_visible]
+        @queue_name = params[:queue_name]
+      end
+      
+      def queue_name
+        return @queue_name
+      end
+      
+      def destroy!
+        raise WAZ::Queues::InvalidOperation if pop_receipt.nil?
+        service_instance.delete_message(queue_name, message_id, pop_receipt)
+      end
+            
+      private
+        def service_instance
+          options = Base.default_connection
+          @service_instance ||= Service.new(options[:account_name], options[:access_key])
+        end
+    end
+  end
+end

data/lib/waz/queues/queue.rb

@@ -0,0 +1,96 @@
+module WAZ
+  module Queues
+    class Queue
+      class << self
+        def list
+          service_instance.list_queues.map do |queue|
+            WAZ::Queues::Queue.new(queue)
+          end
+        end
+        
+        def create(queue_name, metadata = {})
+          service_instance.create_queue(queue_name, metadata)
+          WAZ::Queues::Queue.new({:name => queue_name, :url => service_instance.generate_request_uri(nil, queue_name)})
+        end
+        
+        def find(queue_name)
+          begin 
+            service_instance.get_queue_metadata(queue_name)
+            WAZ::Queues::Queue.new({:name => queue_name, :url => service_instance.generate_request_uri(nil, queue_name)})
+          rescue RestClient::ResourceNotFound
+            return nil
+          end
+        end
+        
+        private
+          def service_instance
+            options = Base.default_connection
+            @service_instance ||= Service.new(options[:account_name], options[:access_key])
+          end
+      end
+      
+      attr_accessor :name, :url
+
+      def initialize(options = {})
+        raise WAZ::Queues::InvalidOption, :name unless options.keys.include?(:name)
+        raise WAZ::Queues::InvalidOption, :url unless options.keys.include?(:url)
+        self.name = options[:name]
+        self.url = options[:url]
+      end
+      
+      def destroy!
+        service_instance.delete_queue(self.name)
+      end
+      
+      def metadata
+        service_instance.get_queue_metadata(self.name)
+      end
+      
+      # when overwrite passed different than true it overrides 
+      # the metadata for the queue 
+      def put_properties!(new_metadata = {}, overwrite = false)
+        new_metadata.merge!(metadata.reject { |k, v| !k.to_s.start_with? "x_ms_meta"} ) unless overwrite
+        service_instance.set_queue_metadata(new_metadata)
+      end
+      
+      def enqueue!(message, ttl = 604800)
+        service_instance.enqueue(self.name, message, ttl)
+      end
+      
+      def size
+        metadata[:x_ms_approximate_messages_count].to_i
+      end
+      
+      def lock(num_of_messages = 1, visibility_timeout = nil)
+        options = {}
+        options[:num_of_messages] = num_of_messages
+        options[:visiblity_timeout] = visibility_timeout unless visibility_timeout.nil?
+        messages = service_instance.get_messages(self.name, options).map do |raw_message|
+                    WAZ::Queues::Message.new(raw_message.merge(:queue_name => self.name))
+                  end
+        return messages.first() if num_of_messages == 1
+        return messages
+      end
+      
+      def peek(num_of_messages = 1)
+        options = {}
+        options[:num_of_messages] = num_of_messages
+        messages = service_instance.peek(self.name, options).map do |raw_message|
+                    WAZ::Queues::Message.new(raw_message.merge(:queue_name => self.name))
+                  end
+        return messages.first() if num_of_messages == 1
+        return messages
+      end
+      
+      def clear
+        service_instance.clear_queue(self.name)
+      end
+      
+      private
+        def service_instance
+          options = Base.default_connection
+          @service_instance ||= Service.new(options[:account_name], options[:access_key])
+        end
+    end
+  end
+end

data/lib/waz/queues/service.rb

@@ -0,0 +1,95 @@
+module WAZ
+  module Queues
+    class Service
+      include WAZ::Storage::SharedKeyCoreService
+          
+      def list_queues(options ={})
+        url = generate_request_uri("list", nil)
+        request = generate_request("GET", url)
+        doc = REXML::Document.new(request.execute())
+        queues = []
+         REXML::XPath.each(doc, '//Queue/') do |item|
+            queues << { :name => REXML::XPath.first(item, "QueueName").text,
+                        :url => REXML::XPath.first(item, "Url").text }
+          end
+        return queues
+      end
+      
+      def create_queue(queue_name, metadata = {})
+        begin
+          url = generate_request_uri(nil, queue_name)
+          request = generate_request("PUT", url, metadata)
+          request.execute()
+        rescue RestClient::RequestFailed
+          raise WAZ::Queues::QueueAlreadyExists, queue_name if $!.http_code == 409
+        end
+      end
+      
+      def delete_queue(queue_name)
+        url = generate_request_uri(nil, queue_name)
+        request = generate_request("DELETE", url)
+        request.execute()
+      end
+      
+      def get_queue_metadata(queue_name)
+        url = generate_request_uri("metadata", queue_name)
+        request = generate_request("HEAD", url)
+        request.execute().headers
+      end
+      
+      def set_queue_metadata(queue_name, metadata = {})
+        url = generate_request_uri("metadata", queue_name)
+        request = generate_request("PUT", url, metadata)
+        request.execute()
+      end
+      
+      # ttl Specifies the time-to-live interval for the message, in seconds. 
+      # The maximum time-to-live allowed is 7 days. If this parameter is omitted, the default time-to-live is 7 days.
+      def enqueue(queue_name, message_payload, ttl = 604800)
+        url = generate_request_uri(nil, "#{queue_name}/messages", "messagettl" => ttl)
+        payload = "<?xml version=\"1.0\" encoding=\"utf-8\"?><QueueMessage><MessageText>#{message_payload}</MessageText></QueueMessage>"
+        request = generate_request("POST", url, { "Content-Type" => "application/xml" }, payload)
+        request.execute()
+      end
+      
+      # :num_of_messages option specifies the max number of messages to get (maximum 32)
+      # :visibility_timeout option specifies the timeout of the message locking in seconds (max two hours)
+      def get_messages(queue_name, options = {})
+        raise WAZ::Queues::OptionOutOfRange, {:name => :num_of_messages, :min => 1, :max => 32} if (options.keys.include?(:num_of_messages) && (options[:num_of_messages].to_i < 1 || options[:num_of_messages].to_i > 32))
+        raise WAZ::Queues::OptionOutOfRange, {:name => :visibility_timeout, :min => 1, :max => 7200} if (options.keys.include?(:visibility_timeout) && (options[:visibility_timeout].to_i < 1 || options[:visibility_timeout].to_i > 7200))
+        url = generate_request_uri(nil, "#{queue_name}/messages", options)
+        request = generate_request("GET", url)
+        doc = REXML::Document.new(request.execute())
+        messages = []
+        REXML::XPath.each(doc, '//QueueMessage/') do |item|
+          message = { :message_id => REXML::XPath.first(item, "MessageId").text,
+                      :message_text => REXML::XPath.first(item, "MessageText").text,
+                      :expiration_time => Time.httpdate(REXML::XPath.first(item, "ExpirationTime").text),
+                      :insertion_time => Time.httpdate(REXML::XPath.first(item, "InsertionTime").text) }
+
+          # This are only valid when peek-locking messages
+          message[:pop_receipt] = REXML::XPath.first(item, "PopReceipt").text unless REXML::XPath.first(item, "PopReceipt").nil?
+          message[:time_next_visible] = Time.httpdate(REXML::XPath.first(item, "TimeNextVisible").text) unless REXML::XPath.first(item, "TimeNextVisible").nil?
+          messages << message
+        end
+        return messages
+      end
+      
+      def peek(queue_name, options = {})
+        return get_messages(queue_name, {:peek_only => true}.merge(options))
+      end
+      
+      def delete_message(queue_name, message_id, pop_receipt)
+        url = generate_request_uri(nil, "#{queue_name}/messages/#{message_id}", :pop_receipt => pop_receipt)
+        request = generate_request("DELETE", url)
+        request.execute()
+      end
+      
+      def clear_queue(queue_name)
+        url = generate_request_uri(nil, "#{queue_name}/messages")
+        request = generate_request("DELETE", url)
+        request.execute()
+      end
+    end
+  end
+end

data/lib/waz/queues/version.rb

@@ -0,0 +1,11 @@
+module WAZ
+  module Queues
+    module VERSION #:nodoc:
+      MAJOR    = '0'
+      MINOR    = '1'
+      TINY     = '0' 
+    end
+    
+    Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].compact * '.'
+  end
+end

data/lib/waz/storage/core_service.rb

@@ -0,0 +1,56 @@
+module WAZ
+  module Storage
+    module SharedKeyCoreService
+      attr_accessor :account_name, :account_key, :use_ssl, :base_url
+      
+      def initialize(account_name, account_key, use_ssl = false, base_url = "queue.core.windows.net" )
+        self.account_name = account_name
+        self.account_key = account_key 
+        self.use_ssl = use_ssl
+        self.base_url = base_url
+      end
+      
+      def generate_request(verb, url, headers = {}, payload = nil)
+        http_headers = {}
+        headers.each{ |k, v| http_headers[k.to_s.gsub(/_/, '-')] = v} unless headers.nil?
+        request = RestClient::Request.new(:method => verb.downcase.to_sym, :url => url, :headers => http_headers, :payload => payload)
+        request.headers["x-ms-Date"] = Time.new.httpdate
+        request.headers["Content-Length"] = (request.payload or "").length
+        request.headers["Authorization"] = "SharedKey #{account_name}:#{generate_signature(request)}"
+        return request
+      end
+            
+      def generate_request_uri(operation = nil, path = nil, options = {})
+        protocol = use_ssl ? "https" : "http"
+        query_params = options.keys.sort{ |a, b| a.to_s <=> b.to_s}.map{ |k| "#{k.to_s.gsub(/_/, '')}=#{options[k]}"}.join("&") unless options.empty?
+        uri = "#{protocol}://#{account_name}.#{base_url}#{(path or "").start_with?("/") ? "" : "/"}#{(path or "")}#{operation ? "?comp=" + operation : ""}"
+        uri << "#{operation ? "&" : "?"}#{query_params}" if query_params
+        return uri
+      end
+      
+      def canonicalize_headers(headers)
+        cannonicalized_headers = headers.keys.select {|h| h.to_s.start_with? 'x-ms'}.map{ |h| "#{h.downcase.strip}:#{headers[h].strip}" }.sort{ |a, b| a <=> b }.join("\x0A")
+        return cannonicalized_headers
+      end
+      
+      def canonicalize_message(url)
+        uri_component = url.gsub(/https?:\/\/[^\/]+\//i, '').gsub(/\?.*/i, '')
+        comp_component = url.scan(/(comp=[^&]+)/i).first()
+        uri_component << "?#{comp_component}" if comp_component
+        canonicalized_message = "/#{self.account_name}/#{uri_component}"
+        return canonicalized_message
+      end
+      
+      def generate_signature(request)
+         signature = request.method.to_s.upcase + "\x0A" +
+                     (request.headers["Content-MD5"] or "") + "\x0A" +
+                     (request.headers["Content-Type"] or "") + "\x0A" +
+                     (request.headers["Date"] or "")+ "\x0A" +
+                     canonicalize_headers(request.headers) + "\x0A" +
+                     canonicalize_message(request.url)
+                     
+         return Base64.encode64(HMAC::SHA256.new(Base64.decode64(self.account_key)).update(signature.toutf8).digest)
+       end
+    end
+  end
+end

data/rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+require 'lib/waz-queues'
+
+
+namespace :test do
+  Spec::Rake::SpecTask.new('run_with_rcov') do |t|
+    puts "running tests and code coverage"    
+    t.spec_files = FileList['tests/waz/queues/*.rb']
+    t.rcov = true
+    t.rcov_opts = ['--text-report', '--exclude', "exclude.*/.gem,test,Library,#{ENV['GEM_HOME']}", '--sort', 'coverage' ]
+    t.spec_opts = ['-cfn']
+  end
+end
+
+namespace :dist do  
+  spec = Gem::Specification.new do |s|
+    s.name              = 'waz-queues'
+    s.version           = Gem::Version.new(WAZ::Queues::Version)
+    s.summary           = "Client library for Windows Azure's Queue Storage Service's REST API"
+    s.description       = s.summary
+    s.email             = 'johnny.halife@me.com'
+    s.author            = 'Johnny G. Halife'
+    s.homepage          = 'http://github.com/johnnyhalife/waz-queues'
+    s.require_paths     = ["lib"]
+    s.files             = FileList['rakefile', 'lib/**/*.rb']
+    s.test_files        = Dir['test/**/*']
+    s.has_rdoc          = false
+    
+    # Dependencies
+    s.add_runtime_dependency 'rest-client', '>= 1.0.3'
+    s.add_dependency 'ruby-hmac'
+  end
+  
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: waz-queues
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Johnny G. Halife
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-hmac
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Client library for Windows Azure's Queue Storage Service's REST API
+email: johnny.halife@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rakefile
+- lib/waz/queues/base.rb
+- lib/waz/queues/exceptions.rb
+- lib/waz/queues/message.rb
+- lib/waz/queues/queue.rb
+- lib/waz/queues/service.rb
+- lib/waz/queues/version.rb
+- lib/waz/storage/core_service.rb
+- lib/waz-queues.rb
+has_rdoc: true
+homepage: http://github.com/johnnyhalife/waz-queues
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: Client library for Windows Azure's Queue Storage Service's REST API
+test_files: []
+