waz-storage 0.5.4 → 0.5.6

data/lib/waz/blobs/blob_object.rb

@@ -80,11 +80,23 @@ module WAZ
         self.class.service_instance.delete_blob(path)
       end
       
+      # Copies the blob to the destination and returns
+      # the copied blob instance. 
+      #
+      # destination should be formed as "container/blob"
+      def copy(destination)
+        self.class.service_instance.copy_blob(self.path, destination)
+        properties = self.class.service_instance.get_blob_properties(destination)
+        return BlobObject.new(:name => destination, 
+                              :url => self.class.service_instance.generate_request_uri(destination),
+                              :content_type => properties[:content_type])
+      end
+      
       # Returns the blob path. This is specially important when simulating containers inside containers
       # by enabling the API to point to the appropiated resource.
       def path
         url.gsub(/https?:\/\/[^\/]+\//i, '').scan(/([^&]+)/i).first().first()
-      end
+      end      
     end
   end
 end

data/lib/waz/blobs/service.rb

@@ -7,16 +7,12 @@ module WAZ
       
       # Creates a container on the current Windows Azure Storage account.
       def create_container(container_name)
-        url = generate_request_uri(container_name)
-        request = generate_request("PUT", url)
-        request.execute()
+        execute :put, container_name
       end
       
       # Retrieves all the properties existing on the container.
       def get_container_properties(container_name)
-        url = generate_request_uri(container_name)
-        request = generate_request("GET", url)
-        request.execute().headers
+        execute(:get, container_name).headers
       end
       
       # Set the container properties (metadata). 
@@ -24,18 +20,15 @@ module WAZ
       # Remember that custom properties should be named as :x_ms_meta_{propertyName} in order
       # to have Windows Azure to persist them.
       def set_container_properties(container_name, properties = {})
-        url = generate_request_uri(container_name, :comp => 'metadata')
-        request = generate_request("PUT", url, properties)
-        request.execute()
+        execute :put, container_name, { :comp => 'metadata' }, properties
       end
       
       # Retrieves the value of the :x_ms_prop_publicaccess header from the
       # container properties indicating whether the container is publicly 
       # accessible or not.
       def get_container_acl(container_name)
-        url = generate_request_uri(container_name, :comp => 'acl')
-        request = generate_request("GET", url)
-        request.execute().headers[:x_ms_prop_publicaccess].downcase == true.to_s
+        headers = execute(:get, container_name, { :comp => 'acl' }).headers
+        headers[:x_ms_prop_publicaccess].downcase == true.to_s
       end
 
       # Sets the value of the :x_ms_prop_publicaccess header from the
@@ -44,16 +37,13 @@ module WAZ
       #
       # Default is _false_
       def set_container_acl(container_name, public_available = false)
-        url = generate_request_uri(container_name, :comp => 'acl')
-        request = generate_request("PUT", url, "x-ms-prop-publicaccess" => public_available.to_s)
-        request.execute()
+        execute :put, container_name, { :comp => 'acl' }, { :x_ms_prop_publicaccess => public_available.to_s }
       end
 
       # Lists all the containers existing on the current storage account.
       def list_containers(options = {})
-        url = generate_request_uri( nil, options.merge(:comp => 'list'))
-        request = generate_request("GET", url)
-        doc = REXML::Document.new(request.execute())
+        content = execute(:get, nil, options.merge(:comp => 'list'))
+        doc = REXML::Document.new(content)
         containers = []
         REXML::XPath.each(doc, '//Container/') do |item|
           containers << { :name => REXML::XPath.first(item, "Name").text,
@@ -65,16 +55,13 @@ module WAZ
 
       # Deletes the given container from the Windows Azure Storage account.
       def delete_container(container_name)
-        url = generate_request_uri(container_name)
-        request = generate_request("DELETE", url)
-        request.execute()
+        execute :delete, container_name
       end
 
       # Lists all the blobs inside the given container.
       def list_blobs(container_name)
-        url = generate_request_uri(container_name, :comp => 'list')
-        request = generate_request("GET", url)
-        doc = REXML::Document.new(request.execute())
+        content = execute(:get, container_name, { :comp => 'list' })
+        doc = REXML::Document.new(content)
         containers = []
         REXML::XPath.each(doc, '//Blob/') do |item|
           containers << { :name => REXML::XPath.first(item, "Name").text,
@@ -92,37 +79,51 @@ module WAZ
       #
       # metadata is a hash that stores all the properties that you want to add to the blob when creating it.
       def put_blob(path, payload, content_type = "application/octet-stream", metadata = {})
-        url = generate_request_uri( path)
-        request = generate_request("PUT", url, metadata.merge("Content-Type" => content_type), payload)
-        request.execute()
+        execute :put, path, nil, metadata.merge("Content-Type" => content_type), payload
       end
       
       # Retrieves a blob (content + headers) from the current path.
-      def get_blob(path)
-        url = generate_request_uri( path)
-        request = generate_request("GET", url)
-        request.execute()
+      def get_blob(path, options = {})
+        execute :get, path, options
       end
 
       # Deletes the blob existing on the current path.
       def delete_blob(path)
-        url = generate_request_uri( path)
-        request = generate_request("DELETE", url)
-        request.execute()
+        execute :delete, path
       end
             
       # Retrieves the properties associated with the blob at the given path.
-      def get_blob_properties(path)
-        url = generate_request_uri( path)
-        request = generate_request("HEAD", url)
-        request.execute().headers
+      def get_blob_properties(path, options = {})
+        execute(:head, path, options).headers
       end
 
       # Sets the properties (metadata) associated to the blob at given path.
       def set_blob_properties(path, properties ={})
-        url = generate_request_uri( path, :comp => 'metadata')
-        request = generate_request("PUT", url, properties)
-        request.execute()
+        execute :put, path, { :comp => 'metadata' }, properties
+      end
+      
+      # Copies a blob within the same account (not necessarily to the same container)
+      def copy_blob(source_path, dest_path)
+        execute :put, dest_path, nil, { :x_ms_version => "2009-04-14", :x_ms_copy_source => canonicalize_message(source_path) }
+      end
+      
+      # Adds a block to the block list of the given blob
+      def put_block(path, identifier, payload)
+        execute :put, path, { :comp => 'block', :blockid => identifier }, {'Content-Type' => "application/octet-stream"}, payload
+      end
+      
+      # Retrieves the list of blocks associated with a single blob. The list is filtered (or not) by type of blob
+      def list_blocks(path, block_list_type = 'all')
+        raise WAZ::Storage::InvalidParameterValue , {:name => :bloclisttype, :values => ['all', 'uncommitted', 'committed']} unless (block_list_type or "") =~ /all|committed|uncommitted/i
+        content = execute(:get, path, {:comp => 'blocklist'}.merge(:blocklisttype => block_list_type.downcase), { :x_ms_version => "2009-04-14" })
+        doc = REXML::Document.new(content)
+        blocks = []
+        REXML::XPath.each(doc, '//Block/') do |item|
+          blocks << { :name => REXML::XPath.first(item, "Name").text,
+                      :size => REXML::XPath.first(item, "Size").text,
+                      :committed => item.parent.name == "CommittedBlocks" }
+        end
+        return blocks
       end
     end
   end

data/lib/waz/queues/message.rb

@@ -33,7 +33,7 @@ module WAZ
         end
       end
       
-      attr_accessor :message_id, :message_text, :pop_receipt, :expiration_time, :insertion_time, :time_next_visible
+      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.
@@ -44,6 +44,7 @@ module WAZ
         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
       

data/lib/waz/queues/queue.rb

@@ -42,8 +42,11 @@ module WAZ
       class << self
         # Returns an array of the queues (WAZ::Queues::Queue) existing on the current 
         # Windows Azure Storage account.
-        def list
-          service_instance.list_queues.map do |queue|
+        # 
+        # 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
@@ -60,8 +63,8 @@ module WAZ
         # return nil shilding the user from a ResourceNotFound exception.
         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(queue_name))
+            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
@@ -76,13 +79,14 @@ module WAZ
         end
       end
       
-      attr_accessor :name, :url
+      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.
@@ -92,7 +96,7 @@ module WAZ
       
       # Retrieves the metadata headers associated with the quere.
       def metadata
-        self.class.service_instance.get_queue_metadata(self.name)
+        metadata ||= self.class.service_instance.get_queue_metadata(self.name)
       end
       
       # Sets the metadata given on the new_metadata, when overwrite passed different 

data/lib/waz/queues/service.rb

@@ -6,15 +6,25 @@ module WAZ
       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 ={})
-        url = generate_request_uri(nil, :comp => 'list')
-        request = generate_request("GET", url)
-        doc = REXML::Document.new(request.execute())
+        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|
-            queues << { :name => REXML::XPath.first(item, "QueueName").text,
-                        :url => REXML::XPath.first(item, "Url").text }
-          end
+        
+        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
       
@@ -22,9 +32,7 @@ module WAZ
       # existing metadata and given metadata differ.
       def create_queue(queue_name, metadata = {})
         begin
-          url = generate_request_uri(queue_name)
-          request = generate_request("PUT", url, metadata)
-          request.execute()
+          execute :put, queue_name, nil, metadata.merge!(:x_ms_version => '2009-09-19')
         rescue RestClient::RequestFailed
           raise WAZ::Queues::QueueAlreadyExists, queue_name if $!.http_code == 409
         end
@@ -32,23 +40,17 @@ module WAZ
       
       # Deletes the given queue from the current storage account.
       def delete_queue(queue_name)
-        url = generate_request_uri(queue_name)
-        request = generate_request("DELETE", url)
-        request.execute()
+        execute(:delete, queue_name, {}, {:x_ms_version => '2009-09-19'})
       end
       
       # Gets the given queue metadata.
       def get_queue_metadata(queue_name)
-        url = generate_request_uri(queue_name, :comp => 'metadata')
-        request = generate_request("HEAD", url)
-        request.execute().headers
+        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 = {})
-        url = generate_request_uri(queue_name, :comp => 'metadata')
-        request = generate_request("PUT", url, metadata)
-        request.execute()
+        execute(:put, queue_name, { :comp => 'metadata' }, metadata.merge!(:x_ms_version => '2009-09-19'))
       end
       
       # Enqueues a message on the current queue.
@@ -56,10 +58,8 @@ module WAZ
       # 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("#{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()
+        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.
@@ -70,13 +70,13 @@ module WAZ
       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("#{queue_name}/messages", options)
-        request = generate_request("GET", url)
-        doc = REXML::Document.new(request.execute())
+        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) }
 
@@ -98,16 +98,12 @@ module WAZ
       # 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)
-        url = generate_request_uri("#{queue_name}/messages/#{message_id}", :pop_receipt => pop_receipt)
-        request = generate_request("DELETE", url)
-        request.execute()
+        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)
-        url = generate_request_uri("#{queue_name}/messages")
-        request = generate_request("DELETE", url)
-        request.execute()
+        execute :delete, "#{queue_name}/messages", {}, :x_ms_version => '2009-09-19'
       end
     end
   end

data/lib/waz/storage/core_service.rb

@@ -19,7 +19,7 @@ module WAZ
       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 = RestClient::Request.new(:method => verb.to_s.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)}"
@@ -56,15 +56,53 @@ module WAZ
       # 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(request)
-         signature = request.method.to_s.upcase + "\x0A" +
+        return generate_signature20090919(request) if request.headers["x-ms-version"] == "2009-09-19"
+        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.access_key)).update(signature.toutf8).digest)
-       end
+        return Base64.encode64(HMAC::SHA256.new(Base64.decode64(self.access_key)).update(signature.toutf8).digest)
+      end
+      
+      
+      def generate_signature20090919(request)
+        signature = request.method.to_s.upcase + "\x0A" +
+                    (request.headers["Content-Encoding"] or "") + "\x0A" +
+                    (request.headers["Content-Language"] or "") + "\x0A" +
+                    (request.headers["Content-Length"] or "").to_s + "\x0A" +                    
+                    (request.headers["Content-MD5"] or "") + "\x0A" +
+                    (request.headers["Content-Type"] or "") + "\x0A" +
+                    (request.headers["Date"] or "")+ "\x0A" +
+                    (request.headers["If-Modified-Since"] or "")+ "\x0A" +
+                    (request.headers["If-Match"] or "")+ "\x0A" +
+                    (request.headers["If-None-Match"] or "")+ "\x0A" +                    
+                    (request.headers["If-Unmodified-Since"] or "")+ "\x0A" +
+                    (request.headers["Range"] or "")+ "\x0A" +                    
+                    canonicalize_headers(request.headers) + "\x0A" +
+                    canonicalize_message20090919(request.url)
+                            
+        return Base64.encode64(HMAC::SHA256.new(Base64.decode64(self.access_key)).update(signature.toutf8).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.downcase.split('&').sort{|a, b| a <=> b}.map{ |p| 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

data/lib/waz/storage/exceptions.rb

@@ -21,5 +21,13 @@ module WAZ
         super("You should establish connection before using the services, the connection configuration is required.")
       end
     end
+    
+    # This exception if raised when the value given for an argument doesn't fall into the permitted values. For example
+    # if values on the blocklisttype aren't [all|uncommitted|committed]
+    class InvalidParameterValue < StorageException
+      def initialize(args = {})
+        super("The value supplied for the parameter #{args[:name]} is invalid. Permitted values are #{args[:values].join(',')}")
+      end
+    end
   end
 end

data/lib/waz/storage/version.rb

@@ -3,7 +3,7 @@ module WAZ
     module VERSION #:nodoc:
       MAJOR    = '0'
       MINOR    = '5'
-      TINY     = '4' 
+      TINY     = '6' 
     end
     
     Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].compact * '.'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: waz-storage
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
+  version: 0.5.6
 platform: ruby
 authors: 
 - Johnny G. Halife
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-17 00:00:00 -03:00
+date: 2009-11-30 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency