azure 0.0.0 → 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    azure (0.1.0)
+      mime-types (~> 1.0)
+      nokogiri (~> 1.5)
+      ratom (~> 0.6)
+      uuid (~> 2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    em-minitest-spec (1.1.1)
+      eventmachine
+    eventmachine (0.12.10)
+    libxml-ruby (2.3.2)
+    macaddr (1.6.1)
+      systemu (~> 2.5.0)
+    mime-types (1.18)
+    minitest (3.1.0)
+    nokogiri (1.5.4)
+    rake (0.9.2.2)
+    ratom (0.7.0)
+      libxml-ruby (~> 2.3.2)
+    systemu (2.5.1)
+    uuid (2.3.5)
+      macaddr (~> 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  azure!
+  em-minitest-spec
+  minitest (~> 3.0)
+  rake

data/README.md

@@ -0,0 +1,3 @@
+Run "rake" to run all tests.
+
+Run "gem build azure.gemspec" to build gem.

data/Rakefile

@@ -0,0 +1,81 @@
+require "rake/testtask"
+require "rubygems/package_task"
+
+gem_spec = eval(File.read("./azure.gemspec"))
+Gem::PackageTask.new(gem_spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+namespace :test do
+  Rake::TestTask.new :unit do |t|
+    t.pattern = "test/unit/**/*_test.rb"
+    t.verbose = true
+    t.libs = ["lib", "test"]
+  end
+
+  Rake::TestTask.new :integration do |t|
+    t.pattern = "test/integration/**/*_test.rb"
+    t.verbose = true
+    t.libs = ["lib", "test"]
+  end
+
+  namespace :integration do
+    def component_task(component)
+      Rake::TestTask.new component do |t|
+        t.pattern = "test/integration/#{component}/**/*_test.rb"
+        t.verbose = true
+        t.libs = ["lib", "test"]
+      end
+    end
+
+    component_task :tables
+    component_task :blobs
+    component_task :queues
+    component_task :service_bus
+
+    task :conditionally do
+      name          = ENV.fetch("AZURE_ACCOUNT_NAME",  nil)
+      key           = ENV.fetch("AZURE_ACCESS_KEY",    nil)
+      t_host        = ENV.fetch("AZURE_TABLE_HOST",    nil)
+      b_host        = ENV.fetch("AZURE_BLOB_HOST",     nil)
+      q_host        = ENV.fetch("AZURE_QUEUE_HOST",    nil)
+      acs_namespace = ENV.fetch("AZURE_ACS_NAMESPACE", nil)
+      sb_access_key = ENV.fetch("AZURE_SB_ACCESS_KEY", nil)
+      sb_issuer     = ENV.fetch("AZURE_SB_ISSUER",     nil)
+
+      if name && key && t_host && b_host && q_host && acs_namespace && sb_access_key && sb_issuer
+        Rake::Task["test:integration"].invoke
+      else
+        warn "[WARNING] Configure your environment to run the integration tests"
+      end
+    end
+  end
+
+  Rake::TestTask.new :cleanup do |t|
+    $:.unshift "lib"
+    require 'azure'
+
+    Azure.configure do |config|
+      config.access_key     = ENV.fetch("AZURE_ACCESS_KEY")
+      config.account_name   = ENV.fetch("AZURE_ACCOUNT_NAME")
+      config.table_host     = ENV.fetch("AZURE_TABLE_HOST")
+      config.blob_host      = ENV.fetch("AZURE_BLOB_HOST")
+      config.queue_host     = ENV.fetch("AZURE_QUEUE_HOST")
+
+      config.acs_namespace  = ENV.fetch("AZURE_ACS_NAMESPACE")
+      config.sb_access_key  = ENV.fetch("AZURE_SB_ACCESS_KEY")
+      config.sb_issuer      = ENV.fetch("AZURE_SB_ISSUER")
+    end
+
+    Azure::Tables.all.map(&:delete)
+    Azure::Blobs.containers.map(&:delete)
+    Azure::Queues.all.map(&:delete)
+    Azure::ServiceBus::Queues.list.map(&:delete)
+    Azure::ServiceBus::Topics.list.map(&:delete)
+  end
+end
+
+task :test => ["test:unit", "test:integration:conditionally"]
+
+task default: :test

data/azure.gemspec

@@ -1,12 +1,23 @@
-files = ["README", "LICENSE", "azure.gemspec"].map {|f| Dir[f]}.flatten
+require "date"
 
 Gem::Specification.new do |s|
-  s.name        = "azure"
-  s.version     = "0.0.0"
-  s.summary     = "Windows Azure SDK for Ruby."
-  s.description = "Access Windows Azure storage and queue services."
-  s.authors     = ["Cubox"]
-  s.email       = "dev@cuboxlabs.com"
-  s.files       = files
-  s.homepage    = "https://github.com/cubox/azure-ruby"
+  s.name    = "azure"
+  s.version = "0.1.0"
+  s.date    = Date.today.iso8601
+
+  s.authors     = ["Microsoft"]
+  s.email       = "azure@microsoft.com"
+  s.description = "Services and ruby SDKs to access the Windows Azure platform."
+  s.summary     = "Implementation of several Windows Azure SDKs in ruby."
+  s.homepage    = "http://azure.com"
+  s.files       = `git ls-files | grep -v "^examples/"`.split("\n")
+
+  s.add_runtime_dependency("uuid",       "~> 2.0")
+  s.add_runtime_dependency("ratom",      "~> 0.6")
+  s.add_runtime_dependency("nokogiri",   "~> 1.5")
+  s.add_runtime_dependency("mime-types", "~> 1.0")
+
+  s.add_development_dependency("rake")
+  s.add_development_dependency("minitest", "~> 3.0")
+  s.add_development_dependency("em-minitest-spec")
 end

data/lib/azure.rb

@@ -0,0 +1,4 @@
+require "azure/tables"
+require "azure/blobs"
+require "azure/queues"
+require "azure/service_bus"

data/lib/azure/atom.rb

@@ -0,0 +1,170 @@
+require "atom"
+require "azure/tables/types"
+
+module Azure
+  # Collection of XML::Node extensions for generating Atom feeds.
+  module Atom
+    Entry = ::Atom::Entry
+    Feed  = ::Atom::Feed
+
+    # Generates a Data Property, making sure that it's in the correct namespace
+    # (dataservices).
+    class Property < XML::Node
+
+      # Public: Set up the property.
+      #
+      # name  - The property name, without the namespace qualification.
+      # value - The property's value.
+      def initialize(name, value)
+        super("d:#{name}")
+        self << value
+      end
+
+      # Public: Set the property's value, and sets the content type based on the
+      # value's type.
+      #
+      # value - The value of the property.
+      #
+      # Returns self.
+      def <<(value)
+        self["m:type"] = Azure::Tables::Types.type_of(value)
+        super(value)
+      end
+
+      def to_xml(*)
+        self
+      end
+    end
+
+    # Represent a list of properties in the proper namespace
+    # (dataservices/metadata).
+    class PropertyList < XML::Node
+      include ::Atom::Xml::Parseable
+
+      add_extension_namespace "d", "http://schemas.microsoft.com/ado/2007/08/dataservices"
+
+      # Public: Initialize the property list.
+      #
+      # Yields the PropertyList.
+      def initialize(o=nil)
+        super("m:properties")
+
+        if o && o.is_a?(LibXML::XML::Reader)
+          o.node.children.each do |node|
+            self << node.copy(true) unless node.blank?
+          end
+        end
+
+        yield self if block_given?
+      end
+
+      # Public: Add several properties at the same time.
+      #
+      # properties - A Hash of property name => property value pairs.
+      #
+      # Returns the passed properties.
+      def merge(properties)
+        properties.each do |name, value|
+          self[name] = value
+        end
+      end
+
+      # Public: Add a property to this list. This will internally store a
+      # Atom::Nodes::Property object.
+      #
+      # property - The name of the property to be included.
+      # value    - The value of the property.
+      #
+      # Returns nothing.
+      def []=(property, value)
+        self << Property.new(property, value)
+      end
+
+      def to_xml(*)
+        self
+      end
+    end
+
+    # Represent an entry's <content/> tag, ensuring it has the correct content
+    # type and that it conforms to the Atom::Content interface so it can be used
+    # seamlessly with Atom::Entry objects.
+    class Content < XML::Node
+      include ::Atom::Xml::Parseable
+
+      add_extension_namespace "m", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
+
+      element "m:properties", class: Azure::Atom::PropertyList
+
+      # Public: Initialize the content node.
+      #
+      # Yields self.
+      def initialize(o=nil)
+        super("content")
+        self["type"] = "application/xml"
+
+        if o && o.is_a?(LibXML::XML::Reader)
+          o.read_inner_xml
+          o.read
+          parse o
+        end
+
+        yield self if block_given?
+      end
+
+      # Public: Cast this object into something Atom::Entry can understand as
+      # content. By returning itself (as a Node) the Entry won't try to escape
+      # this as CDATA.
+      #
+      # Returns self.
+      def to_xml(*)
+        self
+      end
+    end
+  end
+end
+
+# FIXME: The rAtom gem doesn't play well when you extend your classes, raising
+# weird errors, so we're monkeypatching their classes. This *sucks*.
+module Atom
+  # Public: An Atom feed, that understands the Microsoft ADO namespaces for Data
+  # services.
+  class Feed
+    add_extension_namespace "d", "http://schemas.microsoft.com/ado/2007/08/dataservices"
+    add_extension_namespace "m", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
+  end
+
+  # Public: An Atom entry, that understands the Microsoft ADO namespaces for Data
+  # services.
+  class Entry
+    add_extension_namespace "d", "http://schemas.microsoft.com/ado/2007/08/dataservices"
+    add_extension_namespace "m", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
+
+    element "content", class: Azure::Atom::Content
+
+    # Public: Generate a list of data properties to include in this Entry's
+    # content.
+    # FIXME: This method isn't very confident as getter, use content.m_properties instead.
+    #
+    # Yields a Nodes::PropertyList.
+    #
+    # Example:
+    #
+    #   entry.properties do |props|
+    #     props["one"] = 1
+    #     props["two"] = 2
+    #   end
+    #
+    # Returns the XML node for entry's <m_properties/>.
+    def properties(&block)
+      if !@content
+        @content = Azure::Atom::Content.new
+        @m_properties = Azure::Atom::PropertyList.new
+        @content << @m_properties
+      end
+
+      yield @m_properties if block_given?
+
+      @m_properties
+    end
+  end
+end

data/lib/azure/auth.rb

@@ -0,0 +1,29 @@
+require "azure/configuration"
+
+module Azure
+  class Auth
+    # The account name.
+    attr :account_name
+
+    # Public: Initialize the Auth object.
+    #
+    # account_name - A String with the Azure account's name. Defaults to the one
+    #                in the global configuration.
+    def initialize(account_name=Azure.config.account_name)
+      @account_name = account_name
+    end
+
+    # Public: Signs an HTTP request before it's made, by adding the
+    # Authorization header.
+    #
+    # request - An Azure::Request that hasn't been signed.
+    # signer  - A signing strategy, such as Azure::Table::Auth::SharedKey.
+    #
+    # Returns the modified request.
+    def sign(request, signer)
+      signature = signer.sign(request.method, request.uri, request.headers)
+      request.headers["Authorization"] = "#{signer.name} #{account_name}:#{signature}"
+      request
+    end
+  end
+end

data/lib/azure/blobs.rb

@@ -0,0 +1,620 @@
+require "nokogiri"
+require "uri"
+require "azure/blobs/service"
+require "azure/blobs/container"
+require "azure/blobs/blob"
+require "azure/blobs/uri"
+
+module Azure
+  module Blobs
+    # Public: Get a list of Containers from the server.
+    #
+    # service - The backend service to implement this (optional).
+    #
+    # Returns an Array of Container elements.
+    def self.containers(service=Azure::Blobs::Services::ListContainers.new)
+      response = service.call
+      document = Nokogiri::XML(response.body)
+      (document / "//Containers/Container").map do |node|
+        Container.from_node(node)
+      end
+    end
+
+    # Public: Try to create a new container. If the operation is unsuccessful,
+    # the resulting Container object will have the error accessible through the
+    # #error method.
+    #
+    # name       - The name of the container.
+    # metadata   - User defined metadata for this container (optional).
+    # visibility - One of Container::PRIVATE, Container::CONTAINER, or
+    #              Container::BLOB, specifying the level of visibility for
+    #              anonymouse requests to this container. (optional, defaults to
+    #              Container::PRIVATE).
+    # service    - The backend service to implement this (optional).
+    #
+    # Returns a Container.
+    def self.create_container(name, metadata={}, visibility=Container::PRIVATE, service=Azure::Blobs::Services::CreateContainer.new)
+      response = service.call(name, metadata, visibility)
+
+      if response.success?
+        Container.new(name) do |container|
+          container.visibility = visibility
+        end
+      else
+        Container.from_error(response.error)
+      end
+    end
+
+    # Public: Obtain the metadata of a container. This updates the container and
+    # changes the metadata internally if successful. If the operation fails, the
+    # container's metadata does not change, and the container is invalidated.
+    #
+    # container - An Azure::Blobs::Container.
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns a Hash.
+    def self.load_container_metadata(container, service=Azure::Blobs::Services::GetContainerMetadata.new)
+      response = service.call(container.name)
+
+      if response.success?
+        container.extract_metadata(response.headers)
+      else
+        container.error = response.error
+
+        {}
+      end
+    end
+
+    # Public: Save the current metadata of a container in the storage service.
+    # If the operation fails, the container is invalidated.
+    #
+    # container - An Azure::Blobs::Container.
+    # metadata  - User defined metadata for this container (optional).
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.save_container_metadata(container, service=Azure::Blobs::Services::SetContainerMetadata.new)
+      response = service.call(container.name, container.metadata)
+      container.error = response.error unless response.success?
+      response.success?
+    end
+
+    # Public: Delete a Container from the server. If the delete operation fails,
+    # the container is invalidated. Otherwise it's frozen.
+    #
+    # container - An Azure::Blobs::Container.
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.delete_container(container, service=Azure::Blobs::Services::DeleteContainer.new)
+      response = service.call(container.name)
+
+      if response.success?
+        container.freeze
+      else
+        container.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Creates a new Block Blob, or updates an existent one. If the
+    # request is unsuccessful, the resulting blob is invalidated.
+    #
+    # container - An Azure::Blobs::Container instance.
+    # blob_name - A String representing the Blob name.
+    # filename  - String representing a file in the file system. 64mb limit.
+    # metadata  - A Hash representing blob metadata as :name => value.
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns an instance of Azure::Blobs::BlockBlob.
+    def self.create_block_blob(container, blob_name, filename, metadata={}, service=Azure::Blobs::Services::CreateBlockBlob.new)
+
+      response = service.call(container.name, blob_name, filename, metadata)
+
+      if response.success?
+        Azure::Blobs::BlockBlob.new(blob_name, container) do |blob|
+          blob.metadata.replace(metadata)
+          blob.extract_properties(response.headers)
+        end
+      else
+        Azure::Blobs::BlockBlob.from_error(response.error)
+      end
+    end
+
+    # Public: Creates a new Page Blob, or updates an existent one. If the
+    # request is unsuccessful, the resulting blob is invalidated.
+    #
+    # container - An Azure::Blobs::Container instance.
+    # blob_name - A String representing the Blob name.
+    # size      - Size must be aligned to a 512-byte boundary. 1 TB max.
+    # metadata  - A Hash representing blob metadata as :name => value.
+    # headers   - A Hash to be passed as headers.
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns an instance of Azure::Blobs::PageBlob.
+    def self.create_page_blob(container, blob_name, size=nil, metadata={}, headers={}, service=Azure::Blobs::Services::CreatePageBlob.new)
+
+      response = service.call(container.name, blob_name, size, metadata, headers)
+
+      if response.success?
+        uri = Blobs::URI.blob(container.name, blob_name)
+        Azure::Blobs::PageBlob.new(blob_name) do |blob|
+          blob.container = container
+          blob.extract_properties(response.headers)
+        end
+      else
+        Azure::Blobs::PageBlob.from_error(response.error)
+      end
+    end
+
+    # Public: List blobs in the given container.
+    #
+    # container - An Azure::Blobs::Container instance.
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns Array.
+    def self.blobs(container, service=Azure::Blobs::Services::ListBlobs.new)
+      response = service.call(container.name)
+
+      document = Nokogiri.parse(response.body)
+      (document / "//Blobs/Blob").map do |node|
+        Blob.from_node(node) { |b| b.container = container }
+      end
+    end
+
+    # Public: Delete a blob or snapshot blob in the given container. If the operation is
+    # unsuccessful, the blob is invalidated. If not, it will be frozen.
+    #
+    # blob      - An Azure::Blobs::Blob instance.
+    # service   - The backend service to implement this (optional).
+    # snapshots - Boolean indicating if the snapshots will be deleted. False by default, which means
+    #             you will get an error if the blob has snapshots.
+    # headers   - A Hash representing user defined headers (optional).
+    #
+    # Returns true|false indicating success.
+    def self.delete_blob(blob, snapshots=false, headers={}, service=Azure::Blobs::Services::DeleteBlob.new)
+      headers["x-ms-delete-snapshots"] = "include"
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+
+      response = service.call(blob.container.name, blob.name, nil, headers)
+
+      if response.success?
+        blob.freeze
+      else
+        blob.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Get a blob from the given container. If the operation is
+    # unsuccessful, invalidates the blob.
+    #
+    # container - An Azure::Blobs::Container instance.
+    # blob_name - String representing the name of the blob to be deleted.
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns an instance of Azure::Blobs::Blob.
+    def self.get_blob(container, blob_name, service=Azure::Blobs::Services::GetBlob.new)
+      response = service.call(container.name, blob_name)
+
+      if response.success?
+        Azure::Blobs::Blob.new(blob_name, container, response.body) do |blob|
+          blob.extract_metadata(response.headers)
+          blob.extract_properties(response.headers)
+        end
+      else
+        Azure::Blobs::Blob.from_error(response.error)
+      end
+    end
+
+    # Get Properties of a Blob.
+    #
+    # blob      - An Azure::Blobs::Blob instance.
+    # headers   - A Hash representing user defined headers (optional).
+    # service   - The backend service to implement this (optional).
+    #
+    # Returns a Hash.
+    def self.load_blob_properties(blob, headers={}, service=Azure::Blobs::Services::GetBlobProperties.new)
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+      response = service.call(blob.container.name, blob.name, headers)
+
+      if response.success?
+        blob.extract_properties(response.headers)
+        blob.properties
+      else
+        blob.error = response.error
+        {}
+      end
+    end
+
+    # Set Properties of a Block or Page Blob.
+    #
+    # blob     - An Azure::Blobs::Blob instance.
+    # headers  - A Hash representing user defined headers (optional).
+    # service  - The backend service to implement this (optional).
+    #
+    # Returns boolean indicating success. Invalidate blob if operation fails.
+    def self.save_blob_properties(blob, headers={}, service=Azure::Blobs::Services::SetBlobProperties.new)
+      headers.merge(blob.properties.select {|prop, value| prop.match(/x-ms-/)})
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+      response = service.call(blob.container.name, blob.name, headers)
+      blob.error = response.error unless response.success?
+      response.success?
+    end
+
+    # Public: Replaces the blob's metadata with the metadata on the server. If
+    # the operation is unsuccessful, invalidates the blob.
+    #
+    # See http://msdn.microsoft.com/en-us/library/windowsazure/dd179350
+    #
+    # blob    - An Azure::Blobs::Blob instance.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns a Hash.
+    def self.load_blob_metadata(blob, service=Azure::Blobs::Services::GetBlobMetadata.new)
+      response = service.call(blob.container.name, blob.name, blob.lease_id)
+
+      if response.success?
+        blob.extract_metadata(response.headers)
+      else
+        blob.error = response.error
+        {}
+      end
+    end
+
+    # Public: Saves the current blob's metadata to the server, replacing any
+    # existing metadata there. If the operation is unsuccessful, invalidates the
+    # blob.
+    #
+    # See http://msdn.microsoft.com/en-us/library/windowsazure/dd179414
+    #
+    # blob    - An Azure::Blobs::Blob instance.
+    # headers - A Hash representing user defined headers (optional).
+    # service - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.save_blob_metadata(blob, service=Azure::Blobs::Services::SetBlobMetadata.new)
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+      response = service.call(blob.container.name, blob.name, blob.metadata, headers={})
+      blob.error = response.error unless response.success?
+      response.success?
+    end
+
+    # Public: Put a Block in a given Blob.
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/dd135726
+    def self.put_block(blob, block_string, blockid, headers={}, service=Azure::Blobs::Services::PutBlock.new)
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+      response = service.call(blob.container.name, blob.name, ::URI.encode(blockid), block_string)
+      blob.error = response.error if !response.success?
+      response.success?
+    end
+
+    # Public: Put Block List. Invalidates the blob if the operation fails.
+    #
+    # blob      - An instance of Azure::Blobs::Blob.
+    # block_ids - An Array with block ids to be commited.
+    # headers   - A Hash representing user defined headers (optional).
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/dd179467
+    #
+    # Returns the blob.
+    def self.put_block_list(blob, block_ids, headers={}, service=Azure::Blobs::Services::PutBlockList.new)
+
+      headers["x-ms-blob-content-type"] = blob.content_type
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+
+      blob.metadata.each do |name, value|
+        headers["x-ms-meta-#{name}"] = value
+      end
+
+      blob.properties.each do |name, value|
+        headers[name] = value unless ["etag", "last-modified", "content-md5"].include?(name)
+      end
+
+      response = service.call(blob.container.name, blob.name, block_ids, headers)
+
+      if response.success?
+        blob.properties["etag"] = response.headers["etag"]
+        blob.properties["last-modified"] = response.headers["last-modified"]
+      else
+        blob.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Update a set of bytes for the given page blob.
+    #
+    # blob       - An instance of Azure::Blobs::PageBlob.
+    # start_byte - Integer byte where start operation.
+    # end_byte   - Integer byte where end operation.
+    # stream     - String or IO.
+    # headers    - A Hash representing request headers.
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/ee691975
+    #
+    # Returns boolean indicating success.
+    def self.update_page_range(blob, start_byte, end_byte, stream, headers={}, service=Azure::Blobs::Services::PutPage.new)
+
+      headers["x-ms-page-write"] = "update"
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+
+      response = service.call(blob.container.name, blob.name, start_byte, end_byte, stream, headers)
+      if response.success?
+        blob.extract_properties(response.headers)
+        true
+      else
+        blob.error = response.error
+        false
+      end
+    end
+
+    # Public: Clear Page range.
+    #
+    # blob       - An instance of Azure::Blobs::PageBlob.
+    # start_byte - Integer byte where start operation.
+    # end_byte   - Integer byte where end operation.
+    # headers    - A Hash representing request headers.
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/ee691975
+    #
+    # Returns boolean indicating success.
+    def self.clear_page_range(blob, start_byte, end_byte, headers={}, service=Azure::Blobs::Services::PutPage.new)
+
+      headers["x-ms-page-write"] = "clear"
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+
+      response = service.call(blob.container.name, blob.name, start_byte, end_byte, nil, headers)
+      if response.success?
+        blob.extract_properties(response.headers)
+        true
+      else
+        blob.error = response.error
+        false
+      end
+    end
+
+    # Public: Get Page Range. Returns an Array with Range instances.
+    #
+    # blob       - An instance of Azure::Blobs::PageBlob.
+    # start_byte - Integer byte where start operation. (optional)
+    # end_byte   - Integer byte where end operation. (optional)
+    # headers    - A Hash representing request headers. (optional)
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/ee691973
+    #
+    # Returns Array of Range instances.
+    def self.get_page_range(blob, start_byte=nil, end_byte=nil, headers={}, service=Azure::Blobs::Services::GetPage.new)
+      response = service.call(blob.container.name, blob.name, start_byte, end_byte, headers)
+
+      if response.success?
+        document = Nokogiri::XML(response.body)
+        (document / "//PageList/PageRange").map do |node|
+          Range.new((node / "Start").text.to_i, (node / "End").text.to_i)
+        end
+      else
+        blob.error = response.error
+        false
+      end
+    end
+
+    # Public: Creates a snapshot from a given blob.
+    #
+    # blob      - An instance of Azure::Blobs::Blob.
+    # metadata  - User defined metadata for this container (optional).
+    # headers   - A Hash representing request headers. (optional)
+    #
+    # Returns an Azure::Blobs::Snapshot instance.
+    def self.create_snapshot(blob, metadata={}, headers={}, service=Azure::Blobs::Services::CreateSnapshot.new)
+
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+
+      response = service.call(blob.container.name, blob.name, metadata, headers)
+
+      if response.success?
+        Azure::Blobs::Snapshot.new(blob.name, blob.container) do |blob|
+          blob.metadata.replace(metadata)
+          blob.extract_properties(response.headers)
+        end
+      else
+        nil
+      end
+    end
+
+    # Public: Get a blob Snapshot from the given container. If the operation is
+    # unsuccessful, invalidates the blob.
+    #
+    # container   - An Azure::Blobs::Container instance.
+    # blob_name   - String representing the name of the blob to be deleted.
+    # snapshot_id - String representing the datetime uniq id of the snapshot.
+    # service     - The backend service to implement this (optional).
+    #
+    # Returns an instance of Azure::Blobs::Snapshot.
+    def self.get_snapshot(container, blob_name, snapshot_id, service=Azure::Blobs::Services::GetBlob.new)
+      response = service.call(container.name, blob_name)
+
+      if response.success?
+        Azure::Blobs::Snapshot.new(blob_name, container, response.body) do |blob|
+          blob.extract_metadata(response.headers)
+          blob.extract_properties(response.headers)
+        end
+      else
+        Azure::Blobs::Snapshot.from_error(response.error)
+      end
+    end
+
+    # Public: Delete a blob snapshot in the given container. If the operation is
+    # unsuccessful, the blob is invalidated. If not, it will be frozen.
+    #
+    # snapshot - An Azure::Blobs::Snapshot instance. Representing a Blob Snapshot.
+    # headers  - User defined headers for this operation. (optional).
+    # service  - The backend service to implement this (optional).
+    #
+    # Returns true|false indicating success.
+    def self.delete_snapshot(snapshot, headers={}, service=Azure::Blobs::Services::DeleteBlob.new)
+      headers["x-ms-lease-id"] = snapshot.lease_id if snapshot.lease_id
+
+      response = service.call(snapshot.container.name, snapshot.name, snapshot.id, headers)
+
+      if response.success?
+        snapshot.freeze
+      else
+        snapshot.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Delete a snapshots of a blob in the given container.
+    #
+    # blob    - An Azure::Blobs::Blob instance.
+    # service - The backend service to implement this (optional).
+    # headers - User defined headers for this operation. (optional).
+    #
+    # Returns true|false indicating success.
+    def self.delete_blob_snapshots(blob, headers={}, service=Azure::Blobs::Services::DeleteBlob.new)
+      headers["x-ms-delete-snapshots"] = "only"
+      headers["x-ms-lease-id"] = blob.lease_id if blob.lease_id
+
+      response = service.call(blob.container.name, blob.name, nil, headers)
+      response.success?
+    end
+
+    # Public: Copy a Blob or Snapshot.
+    #
+    # source      - An instance of Azure::Blobs::Blob or Azure::Blobs::Snapshot
+    # destination - An instance of Azure::Blobs::Container representing destination.
+    # name        - A string of the blob where source will be copied.
+    # metadata    - User defined metadata for the copied blob (optional).
+    # headers     - User defined headers for this operation. (optional).
+    #
+    # Returns an instance of Azure::Blobs::BlockBlob or PageBlob depending on the source.
+    def self.copy(source, destination, name, metadata={}, headers={}, service=Azure::Blobs::Services::CopyBlob.new)
+
+      headers["x-ms-lease-id"] = source.lease_id if source.lease_id
+
+      snapshot_id = source.is_a?(Azure::Blobs::Snapshot) ? source.id : nil
+
+      response = service.call(source.container.name,
+                              source.name,
+                              destination.name,
+                              name,
+                              snapshot_id,
+                              metadata,
+                              headers)
+
+      blob_class = Azure::Blobs::Blob
+
+      if source.is_a?(Azure::Blobs::PageBlob) || source.properties["x-ms-blob-type"] == "PageBlob"
+        blob_class = Azure::Blobs::PageBlob
+      elsif source.is_a?(Azure::Blobs::BlockBlob) || source.properties["x-ms-blob-type"] == "BlockBlob"
+        blob_class = Azure::Blobs::BlockBlob
+      end
+
+      if response.success?
+        blob_class.new(name, destination) do |blob|
+          blob.metadata.replace(metadata)
+          blob.extract_properties(response.headers)
+        end
+      else
+        blob_class.from_error(response.error)
+      end
+    end
+
+    # Public: Updates the content of a given Block Blob.
+    #
+    # blob           - An Azure::Blobs::Blob instance.
+    # io             - IO. String representing the resource on the filesystem.
+    # byte_partition - Optional. Integer representing the size of the chunks to be uploaded.
+    #
+    # Returns an array with the ids of the uploaded blocks.
+    def self.update_block_blob_content(blob, io, byte_partition=nil)
+      byte_partition ||= 4194304
+      block_ids = []
+
+      while chunk = io.read(byte_partition)
+        block_ids << Base64.strict_encode64(Digest::MD5.digest(chunk))
+        break if !self.put_block(blob, chunk, block_ids.last)
+      end
+
+      block_ids
+    end
+
+    # Public: Set Blob Service properties.
+    #
+    # properties - A hash representing the desired properties configuration for blob storage service.
+    #  {
+    #    "Logging" => {
+    #      "Version" => "1.0",
+    #      "Delete" => "true",
+    #      "Read" => "true",
+    #      "Write" => "true",
+    #      "RetentionPolicy" => {
+    #        "Enabled" => true,
+    #        "Days" => 7
+    #      }
+    #    },
+    #    "Metrics"=> {
+    #      "Version" => "1.0",
+    #      "Enabled" => "true",
+    #      "IncludeAPIs" => "false",
+    #      "RetentionPolicy" => {
+    #        "Enabled" => true,
+    #        "Days" => 7
+    #      }
+    #    }
+    #  }
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/hh452235
+    #
+    # Returns boolean indicating success.
+    def self.set_service_properties(properties, service=Azure::Blobs::Services::SetBlobServiceProperties.new)
+      xml_body = Azure::Core::Utils::StorageServiceProperties.hash_to_xml_string(properties)
+      response = service.call(xml_body)
+      response.success?
+    end
+
+    # Public: Get Blob Service properties.
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/hh452239
+    #
+    # Returns a hash with Service properties or nil if the operation fail.
+    def self.get_service_properties(service=Azure::Blobs::Services::GetBlobServiceProperties.new)
+      response = service.call
+
+      if response.success?
+        Azure::Core::Utils::StorageServiceProperties.xml_string_to_hash(response.body)
+      else
+        nil
+      end
+    end
+
+    # Public: Lease a Blob.
+    #
+    # blob      - An instance of Azure::Blobs::Blob.
+    # action    - symbol included in [:acquire, :renew, :release, :break]
+    #
+    # http://msdn.microsoft.com/en-us/library/windowsazure/ee691972
+    #
+    # Returns blob if success and blob invalidated if the operation fails.
+    def self.lease(blob, action, service=Azure::Blobs::Services::Lease.new)
+
+      lease_actions = [:acquire, :renew, :release, :break]
+
+      if !lease_actions.include?(action)
+        raise ArgumentError, "action not in the list [:acquire, :renew, :release, :break]"
+      end
+
+      response = service.call(blob.container.name, blob.name, action, blob.lease_id)
+
+      if response.success?
+        blob.extract_properties(response.headers)
+      else
+        blob.error = response.error
+      end
+    end
+  end
+end