azure 0.0.0 → 0.1.0

data/lib/azure/tables/entity.rb

@@ -0,0 +1,127 @@
+require "azure/tables/types"
+require "azure/tables"
+require "azure/error"
+
+module Azure
+  module Tables
+    # Public: Representation of a table Entity.
+    class Entity
+      # ETag to force updates/deletes.
+      FORCE_UPDATE = "*".freeze
+
+      include Azure::ErrorHandler
+
+      # Public: Returns an Entity from an Atom::Entry object.
+      #
+      # entry - Atom::Entry object representing the Entity.
+      #
+      # Returns Azure::Entity
+      def self.from_entry(entry)
+        entity = new
+
+        entity.url = URI(entry.id)
+
+        entry.content.m_properties.each do |property_node|
+          value = Types.cast(
+            property_node.content,
+            property_node.attributes["type"]
+          )
+
+          entity[property_node.name] = value
+        end
+
+        entity
+      end
+
+      # Public: Get/Set this entity's URL.
+      attr_accessor :url
+
+      # Public: Get/Set this entity's ETag for conditional updates.
+      attr_accessor :etag
+
+      # Public: Get the attributes.
+      attr :attributes
+
+      # Public: Initialize an Entity.
+      #
+      # attributes - A Hash of attributes.
+      #
+      # Yields self.
+      def initialize(attributes={}, service=Azure::Tables)
+        @attributes = attributes
+        @service = service
+        self.etag = FORCE_UPDATE
+        yield self if block_given?
+      end
+
+      # Public: Two entities are considered equal if they both have the same
+      # URI.
+      #
+      # other - An Entity.
+      #
+      # Returns true|false.
+      def ==(other)
+        url == other.url
+      end
+
+      # Public: Reset this entity to clone another's properties. This will copy
+      # everything from the other entity into this one.
+      #
+      # other - An entity.
+      #
+      # Returns self.
+      def reset(other)
+        self.url = other.url
+        self.attributes.replace(other.attributes)
+        self
+      end
+
+      # Public: Replace an entity with a new set of attributes. In case of an
+      # error, self.error will be set.
+      #
+      # attributes - A Hash of attributes.
+      #
+      # Returns true|false to indicate success.
+      def update(attributes)
+        @service.update_entity(self, attributes)
+      end
+
+      # Public: Merge new attributes into our set of attributes. In case of an
+      # error, self.error will be set.
+      #
+      # attributes - A Hash of attributes.
+      #
+      # Returns true|false to indicate success.
+      def merge(attributes)
+        @service.merge_entity(self, attributes)
+      end
+
+      # Public: Delete this entity from the service. In case of an error,
+      # self.error will be set.
+      #
+      # Returns true|false to indicate success.
+      def delete
+        @service.delete_entity(self)
+      end
+
+      # Public: Access a property on this entity.
+      #
+      # name - The property name.
+      #
+      # Returns the property value.
+      def [](name)
+        @attributes[name]
+      end
+
+      # Public: Set a property on this entity.
+      #
+      # name  - The property name.
+      # value - The value for this property.
+      #
+      # Returns the property value.
+      def []=(name, value)
+        @attributes[name] = value
+      end
+    end
+  end
+end

data/lib/azure/tables/service.rb

@@ -0,0 +1,211 @@
+require "azure/core/service"
+require "azure/core/utils/queryable"
+require "azure/tables/auth/shared_key"
+require "azure/tables/auth/shared_key_lite"
+require "azure/tables/uri"
+require "azure/atom"
+
+module Azure
+  module Tables
+    class Service < Core::Service
+      def initialize(signer=Azure::Tables::Auth::SharedKey.new)
+        super(signer)
+      end
+    end
+
+    module Services
+      # Public: Get a list of tables from the server.
+      class QueryTables < Service
+        include Core::Utils::Queryable
+
+        # Public: Invoke the service.
+        #
+        # query - A hash of options.
+        #         :filter - A string to filter results.
+        #         :top    - Returns only the top n tables from the set.
+        #
+        # To read more about supported query filters check this link.
+        # http://msdn.microsoft.com/en-us/library/windowsazure/dd894031
+        #
+        # Returns a Response.
+        def call(query)
+          uri = Tables::URI.collection
+          query.delete(:select)
+          uri.query = build_query(query)
+          super(:get, uri) do |request|
+            request.headers["DataServiceVersion"] = "2.0;NetFx"
+          end
+        end
+      end
+
+      # Public: Find a single table by name.
+      class FetchTable < Service
+        # Public: Invoke the service.
+        #
+        # name - The name of the table.
+        #
+        # Returns a Response.
+        def call(name)
+          uri = Tables::URI.table(name)
+          super(:get, uri)
+        end
+      end
+
+      # Public: Create a table.
+      class CreateTable < Service
+        # Public: Invoke the service.
+        #
+        # table_name - A String with the table name.
+        #
+        # Returns a Response.
+        def call(table_name)
+          body = Atom::Entry.new do |entry|
+            entry.properties["TableName"] = table_name
+          end
+
+          super(:post, Tables::URI.collection, body.to_xml)
+        end
+      end
+
+      # Public: Delete a table.
+      class DeleteTable < Service
+        # Public: Invoke the service.
+        #
+        # table_name - A String with the table name.
+        #
+        # Returns a Response.
+        def call(table_name)
+          super(:delete, Tables::URI.table(table_name))
+        end
+      end
+
+      # Public: Insert an entity into a table.
+      class InsertEntity < Service
+        # Public: Invoke the service.
+        #
+        # table_name - A String with the table name.
+        # attributes - A Hash of entity attributes. The hash *must* contain the
+        #              keys: "PartitionKey" and "RowKey".
+        #
+        # Returns a Response.
+        def call(table_name, attributes)
+          body = Atom::Entry.new do |entry|
+            entry.updated = Time.now.utc
+            entry.properties.merge(attributes)
+          end
+
+          super(:post, Tables::URI.entities(table_name), body.to_xml)
+        end
+      end
+
+      # Public: Replace the attributes of an existing entity.
+      class ReplaceEntity < Service
+        # Public: Invoke the service.
+        #
+        # table_name - A String with the table name.
+        # attributes - A Hash of entity attributes. The hash *must* contain the
+        #              keys: "PartitionKey" and "RowKey".
+        # etag       - The condition to perform the update. "*" will force an
+        #              unconditional update.
+        #
+        # Returns a Response.
+        def call(table_name, attributes, etag)
+          uri = Tables::URI.entities(
+            table_name,
+            attributes.fetch("PartitionKey"),
+            attributes.fetch("RowKey")
+          )
+
+          body = Atom::Entry.new do |entry|
+            entry.id = uri
+            entry.updated = Time.now.utc
+            entry.properties.merge(attributes)
+          end
+
+          super(:put, uri, body.to_xml) do |request|
+            request.headers["If-Match"] = etag
+          end
+        end
+      end
+
+      # Public: Update only certain properties of an entity.
+      class MergeEntity < Service
+        # Public: Invoke the service.
+        #
+        # uri        - The URI of the Entity we're updating.
+        # attributes - A Hash of new entity attributes.
+        # etag       - The condition to perform the update. "*" will force an
+        #              unconditional update.
+        #
+        # Returns a Response.
+        def call(uri, attributes, etag)
+          body = Atom::Entry.new do |entry|
+            entry.id = uri
+            entry.updated = Time.now.utc
+            entry.properties.merge(attributes)
+          end
+
+          super(:post, uri, body.to_xml) do |request|
+            request.headers["If-Match"] = etag
+            request.headers["X-HTTP-Method"] = "MERGE"
+          end
+        end
+      end
+
+      # Public: Delete an Entity
+      class DeleteEntity < Service
+        # Public: Invoke the service.
+        #
+        # uri  - The URI of the Entity we're deleting.
+        # etag - The condition to perform the update. "*" will force an
+        #        unconditional update.
+        #
+        # Returns a Response.
+        def call(uri, etag)
+          super(:delete, uri) do |request|
+            request.headers["If-Match"] = etag
+          end
+        end
+      end
+
+      # Public: Get entities from a given table.
+      class QueryEntities < Service
+        include Core::Utils::Queryable
+
+        # Public: Invoke the service.
+        #
+        # table_name - A String with the table name.
+        # query      - A hash of options.
+        #              :partition_key - Only get entities with this PartitionKey
+        #                               (optional, but :row_key must also be
+        #                               included).
+        #              :row_key       - Only get entities with this RowKey
+        #                               (optional, but :partition_key must also
+        #                               be included).
+        #              :select        - An array with property names. Only these
+        #                               properties are provided from the
+        #                               returned returned set of entities.
+        #              :filter        - A string to filter results.
+        #              :top           - Returns only the top n tables or entities from the set.
+        #
+        # To read more about supported query filters check this link.
+        # http://msdn.microsoft.com/en-us/library/windowsazure/dd894031
+        #
+        # Returns a Response.
+        def call(table_name, query)
+          uri = Tables::URI.entities(
+            table_name,
+            query.fetch(:partition_key, nil),
+            query.fetch(:row_key, nil)
+          )
+
+          uri.query = build_query(query)
+
+          super(:get, uri) do |request|
+            request.headers["DataServiceVersion"] = "2.0;NetFx"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/azure/tables/table.rb

@@ -0,0 +1,129 @@
+require "azure/tables"
+require "azure/tables/uri"
+require "azure/error"
+require "uri"
+
+module Azure
+  module Tables
+    # Public: Representation of a Table in the storage system.
+    class Table
+      include Azure::ErrorHandler
+
+      # Get the Table's URI.
+      #
+      # Returns a URI.
+      attr :url
+
+      # Get the Table's name.
+      #
+      # Returns a String.
+      attr :name
+
+      # Public: Instantiate a table from an Atom entry.
+      #
+      # entry - An Atom::Entry element.
+      #
+      # Returns a Table.
+      def self.from_entry(entry)
+        name = entry.content.m_properties.children.first.content
+        new(name, ::URI.parse(entry.id))
+      end
+
+      # Public: Instantiate a table from an error object.
+      #
+      # error - An Azure::Error.
+      #
+      # Returns a Table.
+      def self.from_error(error)
+        table = new(nil, nil)
+        table.error = error
+        table
+      end
+
+      # Public: Create a Table. The resulting table will be invalid if the
+      # create operation fails.
+      #
+      # name    - The name of the table.
+      # service - The Table service to perform external calls.
+      #
+      # Returns a Table.
+      def self.create(name, service=Azure::Tables)
+        service.create(name)
+      end
+
+      # Public: Find a Table by name. If no table matches the provided name, nil
+      # is returned.
+      #
+      # name    - The name of the table.
+      #
+      # Returns a Table or nil.
+      def self.[](name)
+        fetch(name) { nil }
+      end
+
+      # Public: Find a Table by name. If no table matches the provided name,
+      # execute the given block, or raise ArgumentError.
+      #
+      # name    - The name of the table.
+      # service - The Table service to perform external calls.
+      #
+      # Yields the error returned by the server in case the table wasn't found.
+      #
+      # Returns a Table.
+      # Raises ArgumentError if the table isn't found and no block is given.
+      def self.fetch(name, service=Azure::Tables, &block)
+        block ||= -> { raise ArgumentError, "Can't find Table named '#{name}'" }
+        table = service.fetch(name)
+        table.valid? ? table : block.call(table.error)
+      end
+
+      # Public: Initialize the table.
+      #
+      # name    - A String with the name of the table.
+      # url     - The URI of the table in the service.
+      # service - The Table service to perform external calls.
+      def initialize(name, url=Azure::Tables::URI.table(name), service=Azure::Tables)
+        @name = name
+        @url = url
+        @service = service
+      end
+
+      # Public: Compare two tables to see if they are the same.
+      #
+      # other - A table.
+      #
+      # Returns true|false.
+      def ==(other)
+        name == other.name
+      end
+
+      # Public: Deletes this table from the storage service.
+      #
+      # Returns true|false to indicate whether the delete was successful or not.
+      def delete
+        @service.delete(self)
+      end
+
+      # Public: Insert a new entity into this table. If the operation fails, an
+      # error will be added to the entity.
+      #
+      # entity - An Azure::Tables::Entity.
+      #
+      # Returns the entity.
+      def insert(entity)
+        @service.insert_entity(self, entity)
+      end
+
+      # Public: Query for entities in this table.
+      #
+      # Returns a list of entities.
+      def entities(query={})
+        if query.key?(:partition_key) && query.key?(:row_key)
+          @service.query_entity(self, query.delete(:partition_key), query.delete(:row_key), query)
+        else
+          @service.query_entities(self, query)
+        end
+      end
+    end
+  end
+end