azure 0.0.0 → 0.1.0

data/lib/azure/service_runtime/role_environment_change.rb

@@ -0,0 +1,32 @@
+module Azure
+  module ServiceRuntime
+    class RoleEnvironmentChange
+    end
+
+    class RoleEnvironmentConfigurationSettingChange < RoleEnvironmentChange
+      attr_reader :configuration_setting_name
+      alias :name :configuration_setting_name
+
+      def initialize(configuration_setting_name)
+        @configuration_setting_name = configuration_setting_name
+      end
+
+      def to_s
+        @configuration_setting_name
+      end
+    end
+
+    class RoleEnvironmentTopologyChange < RoleEnvironmentChange
+      attr_reader :role_name
+      alias :name :role_name
+
+      def initialize(role_name)
+        @role_name = role_name
+      end
+
+      def to_s
+        @role_name
+      end
+    end
+  end
+end

data/lib/azure/service_runtime/role_instance.rb

@@ -0,0 +1,35 @@
+require 'azure/service_runtime/role_instance_endpoint'
+require 'azure/service_runtime/local_resource'
+
+module Azure
+  module ServiceRuntime
+    class RoleInstance
+      attr_accessor :id, :role_name, :fault_domain, :update_domain, :endpoints, :configuration_settings, :local_resources
+      alias :instance_endpoints :endpoints
+
+      def initialize(node)
+        self.id = node["id"]
+        self.fault_domain = node["faultDomain"].to_i
+        self.update_domain = node["updateDomain"].to_i
+        self.role_name = node["roleName"]
+
+        self.endpoints = node.css('Endpoints > Endpoint').inject({}) do |hash, endpoint_xml|
+          endpoint = RoleInstanceEndpoint.new(endpoint_xml)
+          hash[endpoint.name] = endpoint
+          hash
+        end
+
+        self.configuration_settings = node.css('ConfigurationSettings > ConfigurationSetting').inject({}) do |hash, setting_xml|
+          hash[setting_xml["name"]] = setting_xml["value"]
+          hash
+        end
+
+        self.local_resources = node.css('LocalResources > LocalResource').inject({}) do |hash, local_resource_xml|
+          local_resource = LocalResource.new(local_resource_xml)
+          hash[local_resource.name] = local_resource
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_runtime/role_instance_endpoint.rb

@@ -0,0 +1,14 @@
+module Azure
+  module ServiceRuntime
+    class RoleInstanceEndpoint
+      attr_accessor :name, :address, :port, :protocol
+
+      def initialize(node)
+        self.name = node["name"]
+        self.address = node["address"]
+        self.port = node["port"].to_i
+        self.protocol = node["protocol"]
+      end
+    end
+  end
+end

data/lib/azure/tables.rb

@@ -0,0 +1,215 @@
+require "azure/tables/service"
+require "azure/tables/table"
+require "azure/tables/entity"
+require "azure/tables/entities_collection"
+require "azure/tables/tables_collection"
+require "azure/atom"
+
+module Azure
+  module Tables
+    # Public: Get a list of Tables from the server.
+    #
+    # query   - Options for this query.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns an Array of Table elements.
+    def self.all(query = {}, service=Azure::Tables::Services::QueryTables.new)
+      response = service.call(query)
+      feed = Atom::Feed.load_feed(response.body)
+      collection = Azure::Tables::TablesCollection.from_entries(feed.entries, query)
+
+      collection.continuation_token(
+        response.headers["x-ms-continuation-nexttablename"]
+      )
+
+      collection
+    end
+
+    # Public: Get a single table by name. If the operation is unsuccessful, the
+    # resulting table is invalidated.
+    #
+    # name    - The name of the table.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns a Table.
+    def self.fetch(name, service=Azure::Tables::Services::FetchTable.new)
+      response = service.call(name)
+
+      if response.success?
+        Table.from_entry(Atom::Entry.load_entry(response.body))
+      else
+        Table.from_error(response.error)
+      end
+    end
+
+    # Public: Attempt to create a new table. If the operation is unsuccessful,
+    # the resulting Table object will have the error accessible through the
+    # table.error method.
+    #
+    # name    - The name of the table.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns a Table.
+    def self.create(name, service=Azure::Tables::Services::CreateTable.new)
+      response = service.call(name)
+
+      if response.success?
+        Table.from_entry(Atom::Entry.load_entry(response.body))
+      else
+        Table.from_error(response.error)
+      end
+    end
+
+    # Public: Delete a Table from the server.
+    #
+    # table   - An Azure::Tables::Table.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.delete(table, service=Azure::Tables::Services::DeleteTable.new)
+      response = service.call(table.url)
+      table.error = response.error unless response.success?
+      response.success?
+    end
+
+    # Public: Inserts a new entity in the given table. If the operation fails an
+    # error will be added to the entity.
+    #
+    # table   - An Azure::Tables::Table.
+    # entity  - An Azure::Tables::Entity.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns the entity.
+    def self.insert_entity(table, entity, service=Azure::Tables::Services::InsertEntity.new)
+      response = service.call(table.name, entity.attributes)
+
+      if response.success?
+        entity.reset(
+          Entity.from_entry(Azure::Atom::Entry.load_entry(response.body))
+        )
+        entity.etag = response.headers["etag"]
+      else
+        entity.error = response.error
+      end
+
+      entity
+    end
+
+    # Public: Replaces the attributes of an existing entity. In case of an
+    # error, the entity won't be changed and entity.error will be set.
+    #
+    # entity     - The entity to update.
+    # attributes - A Hash of attributes. This hash must contain a "PartitionKey"
+    #              and a "RowKey".
+    # force      - Force this operation even if the object is stale (optional,
+    #              defaults to false).
+    # service    - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.update_entity(entity, attributes, force=false, service=Azure::Tables::Services::ReplaceEntity.new)
+      etag = force ? Entity::FORCE_UPDATE : entity.etag
+      response = service.call(entity.url, attributes, etag)
+
+      if response.success?
+        entity.attributes.replace(attributes)
+        entity.etag = response.headers["etag"]
+      else
+        entity.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Merge new attributes into an entity. If successful, the entity
+    # will have the new attributes. In case of an error, the entity won't be
+    # changed and entity.error will be set.
+    #
+    # entity     - The entity to update.
+    # attributes - A Hash of attributes.
+    # force      - Force this operation even if the object is stale (optional,
+    #              defaults to false).
+    # service    - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.merge_entity(entity, attributes, force=false, service=Azure::Tables::Services::MergeEntity.new)
+      etag = force ? Entity::FORCE_UPDATE : entity.etag
+      response = service.call(entity.url, attributes, etag)
+
+      if response.success?
+        entity.attributes.update(attributes)
+        entity.etag = response.headers["etag"]
+      else
+        entity.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Delete an Entity. If the entity can't be deleted, entity.error
+    # will be set.
+    #
+    # entity  - The entity to delete.
+    # force   - Force this operation even if the object is stale (optional,
+    #           defaults to false).
+    # service - The backend service to implement this (optional).
+    #
+    # Returns true|false to indicate success.
+    def self.delete_entity(entity, force=false, service=Azure::Tables::Services::DeleteEntity.new)
+      etag = force ? Entity::FORCE_UPDATE : entity.etag
+      response = service.call(entity.url, etag)
+
+      if response.success?
+        entity.etag = response.headers["etag"]
+        entity.freeze
+      else
+        entity.error = response.error
+      end
+
+      response.success?
+    end
+
+    # Public: Query a table for a specific entity.
+    #
+    # table         - An Azure::Tables::Table.
+    # partition_key - The PartitionKey of the desired entity.
+    # row_key       - The RowKey of the desired entity.
+    # service       - The backend service to implement this (optional).
+    #
+    # Returns an Entity, or nil if none is found.
+    def self.query_entity(table, partition_key, row_key, query={}, service=Azure::Tables::Services::QueryEntities.new)
+      query.update(partition_key: partition_key, row_key: row_key)
+      response = service.call(table.name, query)
+
+      if response.success?
+        Entity.from_entry(Azure::Atom::Entry.load_entry(response.body))
+      else
+        nil
+      end
+    end
+
+    # Public: Query a table for entities.
+    # Options Hash keys *should* be defined using :symbols.
+    #
+    # table   - An Azure::Tables::Table.
+    # query   - A hash of query options.
+    # service - The backend service to implement this (optional).
+    #
+    # Returns an array of entities.
+    def self.query_entities(table, query={}, service=Azure::Tables::Services::QueryEntities.new)
+      response = service.call(table.name, query)
+
+      if response.success?
+        feed = Atom::Feed.load_feed(response.body)
+        collection = Azure::Tables::EntitiesCollection.from_entries(table, feed.entries, query)
+        collection.continuation_token(
+          response.headers["x-ms-continuation-nextpartitionkey"],
+          response.headers["x-ms-continuation-nextrowkey"]
+        )
+
+        collection
+      else
+        Azure::Tables::EntitiesCollection.new(table, query)
+      end
+    end
+  end
+end

data/lib/azure/tables/auth/shared_key.rb

@@ -0,0 +1,71 @@
+require "cgi"
+require "azure/configuration"
+require "azure/core/signer"
+
+module Azure
+  module Tables
+    module Auth
+      class SharedKey < Core::Signer
+        # The Azure account's name.
+        attr :account_name
+
+        # Public: Initialize the Signer.
+        #
+        # account_name - The Azure account name. Defaults to the one in the
+        #                global configuration.
+        # access_key   - The Azure access_key encoded in Base64. Defaults to the
+        #                one in the global configuration.
+        def initialize(account_name=Azure.config.account_name, access_key=Azure.config.access_key)
+          @account_name = account_name
+          super(access_key)
+        end
+
+        # Public: The name of the strategy.
+        #
+        # Returns a String.
+        def name
+          "SharedKey"
+        end
+
+        # Public: Generate a request signature.
+        #
+        # verb       - The HTTP request method.
+        # uri        - The URI of the request we're signing.
+        # headers    - A Hash of HTTP request headers.
+        #
+        # Returns a Base64 String signed with HMAC.
+        def sign(method, uri, headers)
+          super(signable_string(method, uri, headers))
+        end
+
+        # Generate the string to sign.
+        #
+        # verb       - The HTTP request method.
+        # uri        - The URI of the request we're signing.
+        # headers    - A Hash of HTTP request headers.
+        #
+        # Returns a plain text string.
+        def signable_string(method, uri, headers)
+          [
+            method.to_s.upcase,
+            headers.fetch("Content-MD5", ""),
+            headers.fetch("Content-Type", ""),
+            headers.fetch("Date") { headers.fetch("x-ms-date") },
+            canonicalized_resource(uri)
+          ].join("\n")
+        end
+
+        # Calculate the Canonicalized Resource string for a request.
+        #
+        # uri - The request's URI.
+        #
+        # Returns a String with the canonicalized resource.
+        def canonicalized_resource(uri)
+          path = "/%s%s" % [account_name, uri.path]
+          query = CGI.parse(uri.query.to_s).fetch("comp", nil)
+          [path, query].compact.join("?")
+        end
+      end
+    end
+  end
+end

data/lib/azure/tables/auth/shared_key_lite.rb

@@ -0,0 +1,30 @@
+require "azure/tables/auth/shared_key"
+
+module Azure
+  module Tables
+    module Auth
+      class SharedKeyLite < SharedKey
+        # Public: The name of the strategy.
+        #
+        # Returns a String.
+        def name
+          "SharedKeyLite"
+        end
+
+        # Generate the string to sign.
+        #
+        # verb       - The HTTP request method.
+        # uri        - The URI of the request we're signing.
+        # headers    - A Hash of HTTP request headers.
+        #
+        # Returns a plain text string.
+        def signable_string(method, uri, headers)
+          [
+            headers.fetch("Date") { headers.fetch("x-ms-date") },
+            canonicalized_resource(uri)
+          ].join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/azure/tables/entities_collection.rb

@@ -0,0 +1,66 @@
+require "azure/tables"
+
+module Azure
+  module Tables
+
+    class EntitiesCollection < Array
+
+      # Public: Create a EntitiesCollection instance.
+      #
+      # table - Azure::Tables::Table instace where entities in this class belongs to.
+      # query - A Hash with the query options passed to the server to get the feed.
+      #
+      # Returns the instance.
+      def initialize(table, query = {}, service = Azure::Tables)
+        @service = service
+        @query = query
+        @table = table
+      end
+
+      # Public: Creates an Azure::Tables::EntitiesCollection from entries feed.
+      #
+      # table   - An Azure::Tables::Table instance.
+      # entries - An array of xml entries.
+      # query   - A Hash with the query options passed to the server to get the feed.
+      #
+      # Returns an instance of Azure::Tables::EntitiesCollection.
+      def self.from_entries(table, entries, query = {}, service = Azure::Tables)
+        collection = self.new(table, query, service)
+
+        entries.each do |entry|
+          collection << Entity.from_entry(entry)
+        end
+
+        collection
+      end
+
+      # Public: Set continuation tokens for this collection
+      def continuation_token(next_partition_key, next_row_key)
+        @next_partition_key = next_partition_key
+        @next_row_key = next_row_key
+      end
+
+      # Public: Indicates if the collection is a paginated result.
+      # http://msdn.microsoft.com/en-us/library/windowsazure/dd135718
+      #
+      # Returs boolean.
+      def paginated?
+        @next_partition_key ? true : false
+      end
+
+      # Public: Returns continuation results if exists.
+      #
+      # Returns an instance of Azure::Tables::EntitiesCollection
+      def next
+        return nil if !paginated?
+
+        query = @query.merge({
+          "NextPartitionKey" => @next_partition_key,
+          "NextRowKey" => @next_row_key
+        })
+
+        @service.query_entities(@table, query)
+      end
+    end
+  end
+end