sparqcode-waz-storage 1.1.1

data/lib/waz/queues/exceptions.rb

@@ -0,0 +1,29 @@
+module WAZ
+  module Queues    
+    # This exception is raised while trying when calling WAZ::Queues::Queue.create('queue_name') and
+    # the metadata existing on the Queues Storage subsytem on the cloud contains different metadata from 
+    # the given one.
+    class QueueAlreadyExists < WAZ::Storage::StorageException
+      def initialize(name)
+        super("The queue #{name} already exists on your account.")
+      end
+    end
+    
+    # This exception is raised when an initialization parameter of any of the WAZ::Queues classes falls of 
+    # the specified values.
+    class OptionOutOfRange < WAZ::Storage::StorageException
+      def initialize(args = {})
+        super("The #{args[:name]} parameter is out of range allowed values go from #{args[:min]} to  #{args[:max]}.")
+      end
+    end
+    
+    # This exception is raised when the user tries to perform a delete operation over a peeked message. Since
+    # peeked messages cannot by deleted given the fact that there's no pop_receipt associated with it 
+    # this exception will be raised.
+    class InvalidOperation < WAZ::Storage::StorageException
+      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,65 @@
+module WAZ
+  module Queues
+    # This class is used to model a Message inside Windows Azure Queues the usage
+    # it's pretty simple, here you can see a couple of samples. Messages consist on an UTF-8 string up-to 8KB and some metadata
+    # regarding its status and visibility. Here are all the things that you can do with a message:
+    #
+    #  message.message_id #=> returns message id
+    #
+  	#  # this is the most important method regarding messages
+  	#  message.message_text #=> returns message contents
+    #  
+  	#  message.pop_receipt #=> used for correlating your dequeue request + a delete operation
+    #  
+  	#  message.expiration_time #=> returns when the message will be removed from the queue
+    #
+  	#  message.time_next_visible #=> when the message will be visible to other users
+    #
+  	#  message.insertion_time #=> when the message will be visible to other users
+    #
+  	#  message.queue_name #=> returns the queue name where the message belongs
+    #
+  	#  # remove the message from the queue
+  	#  message.destroy! 
+  	#
+    class Message      
+      class << self
+        # This method is internally used by this class. It's the way we keep a single instance of the 
+        # service that wraps the calls the Windows Azure Queues API. It's initialized with the values
+        # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
+        def service_instance
+          options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "queue")
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
+        end
+      end
+      
+      attr_accessor :message_id, :message_text, :pop_receipt, :expiration_time, :insertion_time, :time_next_visible, :dequeue_count
+       
+      # Creates an instance of Message class, this method is intended to be used internally from the 
+      # Queue.
+      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]
+        self.dequeue_count = params[:dequeue_count]
+        @queue_name = params[:queue_name]
+      end
+      
+      # Returns the Queue name where the Message belongs to
+      def queue_name
+        return @queue_name
+      end
+      
+      # Marks the message for deletion (to later be removed from the queue by the garbage collector). If the message
+      # where the message is being actually called was peeked from the queue instead of locked it will raise the 
+      # WAZ::Queues:InvalidOperation exception since it's not a permited operation.
+      def destroy!
+        raise WAZ::Queues::InvalidOperation if pop_receipt.nil?
+        self.class.service_instance.delete_message(queue_name, message_id, pop_receipt)
+      end            
+    end
+  end
+end

data/lib/waz/queues/queue.rb

@@ -0,0 +1,165 @@
+module WAZ
+  module Queues
+    # This class represents a Queue on Windows Azure Queues API. These are the methods implemented from Microsoft's API description 
+    # available on MSDN at http://msdn.microsoft.com/en-us/library/dd179363.aspx
+    #
+    #	# list available queues
+    #	WAZ::Queues::Queue.list
+    #
+    #	# create a queue (here you can also send hashed metadata)
+    #	WAZ::Queues::Queue.create('test-queue')
+    #
+    #	# get a specific queue
+    #	queue = WAZ::Queues::Queue.find('test-queue')
+    #
+    #	# get queue properties (including default headers)
+    #	queue.metadata #=> hash containing beautified metadata (:x_ms_meta_name)
+    #
+    #	# set queue properties (should follow x-ms-meta to be persisted)
+    #	# if you specify the optional parameter overwrite, existing metadata 
+    #	# will be deleted else merged with new one.
+    #	queue.put_properties!(:x_ms_meta_MyProperty => "my value")
+    #
+    #	# delete queue
+    #	queue.destroy!
+    #
+    #	# clear queue contents
+    #	queue.clear
+    #
+    #	# enqueue a message 
+    #	queue.enqueue!("payload of the message")
+    #
+    #	# peek a message/s (do not alter visibility, it can't be deleted neither)
+    #	# num_of_messages (1 to 32) to be peeked (default 1)
+    #	message = queue.peek
+    #
+    #	# lock a message/s.
+    #	# num_of_messages (1 to 32) to be peeked (default 1)
+    #	# visiblity_timeout (default 60 sec. max 7200 [2hrs])
+    #	message = queue.lock
+    #
+    class Queue
+      class << self
+        # Returns an array of the queues (WAZ::Queues::Queue) existing on the current 
+        # Windows Azure Storage account.
+        # 
+        # include_metadata defines if the metadata is retrieved along with queue data.
+        def list(include_metadata = false)
+          options = include_metadata ? { :include => 'metadata' } : {}
+          service_instance.list_queues(options).map do |queue|
+            WAZ::Queues::Queue.new(queue)
+          end
+        end
+        
+        # Creates a queue on the current account. If provided the metadata hash will specify additional 
+        # metadata to be stored on the queue. (Remember that metadata on the storage account must start with 
+        # :x_ms_metadata_{yourCustomPropertyName}, if not it will not be persisted).
+        def create(queue_name, metadata = {})
+          raise WAZ::Storage::InvalidParameterValue, {:name => "name", :values => ["lower letters, numbers or - (hypen), and must not start or end with - (hyphen)"]} unless WAZ::Storage::ValidationRules.valid_name?(queue_name)
+          service_instance.create_queue(queue_name, metadata)
+          WAZ::Queues::Queue.new(:name => queue_name, :url => service_instance.generate_request_uri(queue_name))
+        end
+        
+        # Finds a queue by it's name, in case that it isn't found on the current storage account it will 
+        # return nil shilding the user from a ResourceNotFound exception.
+        def find(queue_name)
+          begin 
+            metadata = service_instance.get_queue_metadata(queue_name)
+            WAZ::Queues::Queue.new(:name => queue_name, :url => service_instance.generate_request_uri(queue_name), :metadata => metadata)
+          rescue RestClient::ResourceNotFound
+            return nil
+          end
+        end
+        
+        # Syntax's sugar for find(:queue_name) or create(:queue_name)
+        def ensure(queue_name)
+          return (self.find(queue_name) or self.create(queue_name))
+        end
+        
+        # This method is internally used by this class. It's the way we keep a single instance of the 
+        # service that wraps the calls the Windows Azure Queues API. It's initialized with the values
+        # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
+        def service_instance
+          options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "queue")
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
+        end
+      end
+      
+      attr_accessor :name, :url, :metadata
+
+      def initialize(options = {})
+        raise WAZ::Storage::InvalidOption, :name unless options.keys.include?(:name)
+        raise WAZ::Storage::InvalidOption, :url unless options.keys.include?(:url)
+        self.name = options[:name]
+        self.url = options[:url]
+        self.metadata = options[:metadata]
+      end
+      
+      # Deletes the queue from the current storage account.
+      def destroy!
+        self.class.service_instance.delete_queue(self.name)
+      end
+      
+      # Retrieves the metadata headers associated with the quere.
+      def metadata
+        metadata ||= self.class.service_instance.get_queue_metadata(self.name)
+      end
+      
+      # Sets the metadata given on the new_metadata, when overwrite passed different 
+      # than true it overrides the metadata for the queue  (removing all existing metadata)
+      def put_properties!(new_metadata = {}, overwrite = false)
+        new_metadata.merge!(metadata.reject { |k, v| !k.to_s.start_with? "x_ms_meta"} ) unless overwrite
+        self.class.service_instance.set_queue_metadata(new_metadata)
+      end
+      
+      # Enqueues a message on current queue. message is just a string that should be 
+      # UTF-8 serializable and ttl specifies the time-to-live of the message in the queue 
+      # (in seconds).
+      def enqueue!(message, ttl = 604800)
+        self.class.service_instance.enqueue(self.name, message, ttl)
+      end
+      
+      # Returns the approximated queue size.
+      def size
+        metadata[:x_ms_approximate_messages_count].to_i
+      end
+      
+      # Since Windows Azure Queues implement a Peek-Lock pattern 
+      # the method lock will lock a message preventing other users from 
+      # picking/locking the current message from the queue. 
+      #
+      # The API supports multiple message processing by specifiying num_of_messages (up to 32)
+      # 
+      # The visibility_timeout parameter (optional) specifies for how long the message will be 
+      # hidden from other users.
+      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 = self.class.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
+      
+      # Returns top N (default 1, up to 32) message from the queue without performing 
+      # any modification on the message. Since the message it's retrieved read-only
+      # users cannot delete the peeked message.
+      def peek(num_of_messages = 1)
+        options = {}
+        options[:num_of_messages] = num_of_messages
+        messages = self.class.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
+      
+      # Marks every message on the queue for deletion (to be later garbage collected).
+      def clear
+        self.class.service_instance.clear_queue(self.name)
+      end
+    end
+  end
+end

data/lib/waz/queues/service.rb

@@ -0,0 +1,106 @@
+module WAZ
+  module Queues
+    # This is internally used by the waz-queues part of the gem and it exposes the Windows Azure Queue API REST methods 
+    # implementation. You can use this class to perform an specific operation that aren't provided by the current API.
+    class Service
+      include WAZ::Storage::SharedKeyCoreService
+      
+      # Lists the queues on the given storage account.
+      #
+      # When the options :include => 'metadata' is passed it returns
+      # the corresponding metadata for each queue on the listing.
+      def list_queues(options ={})
+        content = execute(:get, nil, { :comp => 'list' }.merge!(options), { :x_ms_version => "2009-09-19" })
+        doc = REXML::Document.new(content)
+        queues = []
+        
+        REXML::XPath.each(doc, '//Queue/') do |item|
+          metadata = {}
+          
+          item.elements['Metadata'].elements.each do |element|
+            metadata.merge!(element.name.gsub(/-/, '_').downcase.to_sym => element.text)
+          end unless item.elements['Metadata'].nil?
+          
+          queues << { :name => REXML::XPath.first(item, "Name").text,
+                      :url => REXML::XPath.first(item, "Url").text,
+                      :metadata => metadata}
+        end
+        return queues
+      end
+      
+      # Creates a queue on the current storage account. Throws WAZ::Queues::QueueAlreadyExists when 
+      # existing metadata and given metadata differ.
+      def create_queue(queue_name, metadata = {})
+        execute(:put, queue_name, nil, metadata.merge!(:x_ms_version => '2009-09-19'))
+      end
+      
+      # Deletes the given queue from the current storage account.
+      def delete_queue(queue_name)
+        execute(:delete, queue_name, {}, {:x_ms_version => '2009-09-19'})
+      end
+      
+      # Gets the given queue metadata.
+      def get_queue_metadata(queue_name)
+        execute(:head, queue_name, { :comp => 'metadata'}, :x_ms_version => '2009-09-19').headers
+      end
+      
+      # Sets the given queue metadata.
+      def set_queue_metadata(queue_name, metadata = {})
+        execute(:put, queue_name, { :comp => 'metadata' }, metadata.merge!(:x_ms_version => '2009-09-19'))
+      end
+      
+      # Enqueues a message on the current queue.
+      #
+      # 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)
+        payload = "<?xml version=\"1.0\" encoding=\"utf-8\"?><QueueMessage><MessageText>#{message_payload}</MessageText></QueueMessage>"
+        execute(:post, "#{queue_name}/messages", { :messagettl => ttl }, { 'Content-Type' => 'application/xml', :x_ms_version => "2009-09-19"}, payload)
+      end
+      
+      # Locks N messages (1 default) from the given queue.
+      #
+      # :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))
+        content = execute(:get, "#{queue_name}/messages", options, {:x_ms_version => "2009-09-19"})
+        doc = REXML::Document.new(content)
+        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,
+                      :dequeue_count => REXML::XPath.first(item, "DequeueCount").nil? ? nil : REXML::XPath.first(item, "DequeueCount").text.to_i,
+                      :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
+      
+      # Peeks N messages (default 1) from the given queue.
+      # 
+      # Implementation is the same of get_messages but differs on an additional parameter called :peek_only.
+      def peek(queue_name, options = {})
+        return get_messages(queue_name, {:peek_only => true}.merge(options))
+      end
+      
+      # Deletes the given message from the queue, correlating the operation with the pop_receipt
+      # in order to avoid eventually inconsistent scenarios.
+      def delete_message(queue_name, message_id, pop_receipt)
+        execute :delete, "#{queue_name}/messages/#{message_id}", { :pop_receipt => pop_receipt }
+      end
+      
+      # Marks every message on the given queue for deletion.
+      def clear_queue(queue_name)
+        execute :delete, "#{queue_name}/messages", {}, :x_ms_version => '2009-09-19'
+      end
+    end
+  end
+end

data/lib/waz/storage/base.rb

@@ -0,0 +1,70 @@
+module WAZ
+	module Storage
+    # This class is used to handle a general connection with Windows Azure Storage Account and it 
+    # should be used at least once on the application bootstrap or configuration file.
+    # 
+    # The usage is pretty simple as it's depicted on the following sample
+    #  WAZ::Storage::establish_connection!(:account_name => "my_account_name", 
+    #                                      :access_key => "your_base64_key", 
+    #                                      :use_ssl => false)
+    #
+		class Base
+			class << self
+				# Sets the basic configuration parameters to use the API on the current context
+				# required parameters are :account_name, :access_key. 
+        #
+				# All other parameters are optional.
+				def establish_connection!(options = {})
+					raise InvalidOption, :account_name unless options.keys.include? :account_name 
+					raise InvalidOption, :access_key if !options.keys.include? :use_sas_auth_only unless options.keys.include? :access_key 
+  				        raise InvalidOption, :use_sas_auth_only if !options.keys.include? :access_key unless options.keys.include? :use_sas_auth_only 
+ 					raise InvalidOption, :sharedaccesssignature if !options.keys.include? :access_key unless options.keys.include? :sharedaccesssignature and options.keys.include? :use_sas_auth_only
+  				        options[:use_ssl] = false unless options.keys.include? :use_ssl
+					(@connections ||= []) << options
+				end
+				
+        # Block Syntax
+        #
+        #  Pushes the named repository onto the context-stack,
+        #  yields a new session, and pops the context-stack.
+        #
+        #  This helps you set contextual operations like in the following sample
+        #  
+        #  Base.establish_connection(options) do
+        #   # do some operations on the given context
+        #  end
+        #  
+        #  The context is restored to the previous one (what you configured on establish_connection!)
+        #  or nil.
+        #
+        # Non-Block Syntax
+        #
+        #  Behaves exactly as establish_connection!
+				def establish_connection(options = {}) # :yields: current_context
+			    establish_connection!(options)
+			    if (block_given?)
+  				  begin 
+  				    return yield
+  				  ensure
+  				    @connections.pop() if connected?
+  				  end
+  				end
+				end
+				
+				# Returns the default connection (last set) parameters. It will raise an exception WAZ::Storage::NotConnected
+				# when there's no connection information registered.
+				def default_connection
+          raise NotConnected unless connected?
+					return @connections.last
+				end
+				
+				# Returns a value indicating whether the current connection information has been set or not.
+				def connected?
+					return false if (@connections.nil?)
+					return false if (@connections.empty?)
+					return true
+				end
+			end
+		end
+	end
+end

data/lib/waz/storage/core_service.rb

@@ -0,0 +1,122 @@
+module WAZ
+  module Storage
+    # This module is imported by the specific services that use Shared Key authentication profile. On the current implementation
+    # this module is imported from WAZ::Queues::Service and WAZ::Blobs::Service.
+    module SharedKeyCoreService
+      attr_accessor :account_name, :access_key, :use_ssl, :base_url, :type_of_service, :use_devenv, :use_sas_auth_only, :sharedaccesssignature
+      
+      # Creates an instance of the implementor service (internally used by the API).
+      def initialize(options = {})
+        # Flag to define the use of shared access signature only
+        self.use_sas_auth_only = options[:use_sas_auth_only] or false
+        self.sharedaccesssignature = options[:sharedaccesssignature] 
+
+        self.account_name = options[:account_name]
+        self.access_key = options[:access_key]
+        self.type_of_service = options[:type_of_service]        
+        self.use_ssl = options[:use_ssl] or false
+        self.use_devenv = !!options[:use_devenv]
+        self.base_url = "#{options[:type_of_service] or "blobs"}.#{options[:base_url] or "core.windows.net"}" unless self.use_devenv
+        self.base_url ||= (options[:base_url] or "core.windows.net") 
+      end
+      
+      # Generates a request based on Adam Wiggings' rest-client, including all the required headers
+      # for interacting with Windows Azure Storage API (except for Tables). This methods embeds the 
+      # authorization key signature on the request based on the given access_key.
+      def generate_request(verb, url, headers = {}, payload = nil)
+        http_headers = {}
+        headers.each{ |k, v| http_headers[k.to_s.gsub(/_/, '-')] = v} unless headers.nil?
+        http_headers.merge!("x-ms-Date" => Time.new.httpdate)
+        http_headers.merge!("Content-Length" => (payload or "").size)
+        request = {:headers => http_headers, :method => verb.to_s.downcase.to_sym, :url => url, :payload => payload}
+        request[:headers].merge!("Authorization" => "SharedKey #{account_name}:#{generate_signature(request)}") unless self.use_sas_auth_only 
+        return RestClient::Request.new(request)
+      end
+      
+      # Generates the request uri based on the resource path, the protocol, the account name and the parameters passed
+      # on the options hash. 
+      def generate_request_uri(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(/_/, '')}=#{CGI.escape(options[k].to_s)}"}.join("&") unless options.nil? or options.empty?
+        uri = "#{protocol}://#{base_url}/#{path.start_with?(account_name) ? "" : account_name }#{((path or "").start_with?("/") or path.start_with?(account_name)) ? "" : "/"}#{(path or "")}" if !self.use_devenv.nil? and self.use_devenv
+        uri ||= "#{protocol}://#{account_name}.#{base_url}#{(path or "").start_with?("/") ? "" : "/"}#{(path or "")}" 
+        if self.use_sas_auth_only 
+          uri << "?#{self.sharedaccesssignature.gsub(/\?/,'')}" 
+	else
+          uri << "?#{query_params}" if query_params
+        end        
+        return uri
+      end
+      
+      # Canonicalizes the request headers by following Microsoft's specification on how those headers have to be sorted 
+      # and which of the given headers apply to be canonicalized.
+      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
+      
+      # Creates a canonical representation of the message by combining account_name/resource_path.
+      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
+      
+      # Generates the signature based on Micosoft specs for the REST API. It includes some special headers, 
+      # the canonicalized header line and the canonical form of the message, all of the joined by \n character. Encoded with 
+      # Base64 and encrypted with SHA256 using the access_key as the seed.
+      def generate_signature(options = {})
+        return generate_signature20090919(options) if options[:headers]["x-ms-version"] == "2009-09-19"
+
+        signature = options[:method].to_s.upcase + "\x0A" +
+                     (options[:headers]["Content-MD5"] or "") + "\x0A" +
+                     (options[:headers]["Content-Type"] or "") + "\x0A" +
+                     (options[:headers]["Date"] or "")+ "\x0A"
+
+        signature += canonicalize_headers(options[:headers]) + "\x0A" unless self.type_of_service == 'table'
+        signature += canonicalize_message(options[:url])
+        signature = signature.toutf8 if(signature.respond_to? :toutf8)
+        Base64.encode64(HMAC::SHA256.new(Base64.decode64(self.access_key)).update(signature).digest)
+      end
+
+      def generate_signature20090919(options = {})
+        signature = options[:method].to_s.upcase + "\x0A" +
+                    (options[:headers]["Content-Encoding"] or "") + "\x0A" +
+                    (options[:headers]["Content-Language"] or "") + "\x0A" +
+                    (options[:headers]["Content-Length"] or "").to_s + "\x0A" +                    
+                    (options[:headers]["Content-MD5"] or "") + "\x0A" +
+                    (options[:headers]["Content-Type"] or "") + "\x0A" +
+                    (options[:headers]["Date"] or "")+ "\x0A" +
+                    (options[:headers]["If-Modified-Since"] or "")+ "\x0A" +
+                    (options[:headers]["If-Match"] or "")+ "\x0A" +
+                    (options[:headers]["If-None-Match"] or "")+ "\x0A" +                    
+                    (options[:headers]["If-Unmodified-Since"] or "")+ "\x0A" +
+                    (options[:headers]["Range"] or "")+ "\x0A" +                    
+                    canonicalize_headers(options[:headers]) + "\x0A" +
+                    canonicalize_message20090919(options[:url])
+
+        signature = signature.toutf8 if(signature.respond_to? :toutf8)
+        Base64.encode64(HMAC::SHA256.new(Base64.decode64(self.access_key)).update(signature).digest)
+      end
+      
+      def canonicalize_message20090919(url)
+        uri_component = url.gsub(/https?:\/\/[^\/]+\//i, '').gsub(/\?.*/i, '')
+        query_component = (url.scan(/\?(.*)/i).first() or []).first()
+        query_component = query_component.split('&').sort{|a, b| a <=> b}.map{ |p| CGI::unescape(p.split('=').join(':')) }.join("\n") if query_component
+        canonicalized_message = "/#{self.account_name}/#{uri_component}"
+        canonicalized_message << "\n#{query_component}" if query_component
+        return canonicalized_message
+      end
+        
+      # Generates a Windows Azure Storage call, it internally calls url generation method
+      # and the request generation message.
+      def execute(verb, path, query = {}, headers = {}, payload = nil)
+        url = generate_request_uri(path, query)
+        request = generate_request(verb, url, headers, payload)
+        request.execute()
+      end
+    end
+  end
+end