azure 0.0.0 → 0.1.0

data/lib/azure/queues/service_properties.rb

@@ -0,0 +1,152 @@
+require "azure/queues"
+require "azure/queues/uri"
+require "azure/error"
+require "uri"
+require "nokogiri"
+
+module Azure
+  module Queues
+    # Public: Representation of the Service Properties in a message queue.
+    class ServiceProperties
+      include Azure::ErrorHandler
+
+      # Public: Instantiate a ServiceProperties from an XML entry.
+      #
+      # entry - An XML::Node element.
+      #
+      # Returns a Serviceproperties.
+      def self.from_node(node)
+        new() do |s|
+          s.logging = Logging.from_node(node % "Logging")
+          s.metrics = Metrics.from_node(node % "Metrics")
+        end
+      end
+
+      # Public: Instantiate a message from an error object.
+      #
+      # error - An Azure::Error.
+      #
+      # Returns a Message.
+      def self.from_error(error)
+        message = new(nil)
+        message.error = error
+        message
+      end
+
+      attr_accessor :logging, :metrics
+
+      # Public: Constructor.
+      #
+      # queue     - The message queue
+      # service   - The Queue service to perform external calls.
+      def initialize(service=Azure::Queues)
+        @service = service
+        @logging = Logging.new
+        @metrics = Metrics.new
+        yield self if block_given?
+      end
+
+      class Logging
+        attr_accessor :version, :delete, :read, :write, :retention_policy
+
+        def initialize
+          @version = "1.0"
+          @read = false
+          @write = false
+          @delete = false
+          @retention_policy = RetentionPolicy.new
+          yield self if block_given?
+        end
+
+        # Public: Instantiate a Logging from an XML entry.
+        #
+        # entry - An XML::Node element.
+        #
+        # Returns a Logging.
+        def self.from_node(node)
+          new() do |l|
+            l.version           = (node % "Version").text
+            l.read              = (node % "Read").text == "true"
+            l.write             = (node % "Write").text == "true"
+            l.delete            = (node % "Delete").text == "true"
+            l.retention_policy  = RetentionPolicy.from_node(node % "RetentionPolicy")
+          end
+        end
+      end
+
+      class Metrics
+        attr_accessor :version, :enabled, :include_apis, :retention_policy
+
+        def initialize
+          @version = "1.0"
+          @enabled = false
+          @include_apis = false
+          @retention_policy = RetentionPolicy.new
+          yield self if block_given?
+        end
+
+        # Public: Instantiate a Metrics from an XML entry.
+        #
+        # entry - An XML::Node element.
+        #
+        # Returns a Metrics.
+        def self.from_node(node)
+          new() do |m|
+            m.version           = (node % "Version").text
+            m.enabled           = (node % "Enabled").text == "true"
+            m.include_apis      = (node % "IncludeAPIs").text == "true" unless (node % "IncludeAPIs").nil?
+            m.retention_policy  = RetentionPolicy.from_node(node % "RetentionPolicy")
+          end
+        end
+      end
+
+      class RetentionPolicy
+        attr_accessor :enabled, :days
+
+        def initialize
+          @enabled = false
+          yield self if block_given?
+        end
+
+        # Public: Instantiate a RetentionPolicy from an XML entry.
+        #
+        # entry - An XML::Node element.
+        #
+        # Returns a RetentionPolicy.
+        def self.from_node(node)
+          new() do |m|
+            m.enabled = (node % "Enabled").text == "true"
+            m.days    = (node % "Days").text unless (node % "Days").nil?
+          end
+        end
+      end
+
+      def to_xml
+        body = Nokogiri::XML::Builder.new do |xml|
+          xml.StorageServiceProperties {
+            xml.Logging {
+              xml.Version logging.version
+              xml.Delete logging.delete
+              xml.Read logging.read
+              xml.Write logging.write
+              xml.RetentionPolicy {
+                xml.Enabled logging.retention_policy.enabled
+                xml.Days logging.retention_policy.days if logging.retention_policy.enabled
+              }
+            }
+            xml.Metrics {
+              xml.Version metrics.version
+              xml.Enabled metrics.enabled
+              xml.IncludeAPIs metrics.include_apis unless metrics.include_apis.nil?
+              xml.RetentionPolicy {
+                xml.Enabled metrics.retention_policy.enabled
+                xml.Days metrics.retention_policy.days if metrics.retention_policy.enabled
+              }
+            }
+          }
+        end
+        body.to_xml
+      end
+    end
+  end
+end

data/lib/azure/queues/uri.rb

@@ -0,0 +1,78 @@
+require "azure/configuration"
+require "uri"
+
+module Azure
+  module Queues
+    module URI
+      # Public: generate the URI for the service properties
+      #
+      # query - see Azure::Services::GetServiceProperties#call documentation.
+      # host  - The host of the API.
+      #
+      # Returns a URI.
+      def self.service_properties(query={}, host=Azure.config.queue_host)
+        query.update(restype: 'service', comp: 'properties')
+        generate(host, "", query)
+      end
+
+      # Public: generate the URI for the collection of queues.
+      #
+      # query - see Azure::Services::ListQueues#call documentation.
+      # host  - The host of the API.
+      #
+      # Returns a URI.
+      def self.collection(query={}, host=Azure.config.queue_host)
+        query.update(comp: 'list', include: 'metadata')
+        generate(host, "", query)
+      end
+
+      # Public: Generate the URI for a given queue.
+      #
+      # queue_name - The name of the queue.
+      # query      - A Hash of query parameters (default: {}).
+      # host       - The host of the API.
+      #
+      # Returns a URI.
+      def self.queue(queue_name, query={}, host=Azure.config.queue_host)
+        return queue_name if name.kind_of? ::URI
+        generate(host, queue_name, query)
+      end
+
+      # Public: Generate the messages URI for the given queue.
+      #
+      # queue_name - The name of the queue.
+      # query      - A Hash of query parameters (default: {}).
+      # host       - The host of the API.
+      #
+      # Returns a URI.
+      def self.messages(queue_name, query={}, host=Azure.config.queue_host)
+        generate(host, "#{queue_name}/messages", query)
+      end
+
+      # Public: generate the URI for a given message
+      #
+      # queue_name - The name of the queue.
+      # message_id - The id of the message.
+      # query      - A Hash of query parameters (default: {}).
+      # host       - The host of the API.
+      #
+      # Returns a URI.
+      def self.message(queue_name, message_id, query={}, host=Azure.config.queue_host)
+        generate(host, "#{queue_name}/messages/#{message_id}", query)
+      end
+
+      # Utility method to generate the URI.
+      #
+      # host  - A String with the URI's host.
+      # path  - A String with the URI's path.
+      # query - A simple Hash with query parameters (default: {}).
+      #
+      # Returns a URI.
+      def self.generate(host, path, query={})
+        uri = ::URI.parse(File.join(host, path))
+        uri.query = ::URI.encode_www_form(query) unless query.empty?
+        uri
+      end
+    end
+  end
+end

data/lib/azure/request.rb

@@ -0,0 +1,102 @@
+require "digest/md5"
+require "base64"
+require "net/http"
+require "time"
+require "azure/response"
+
+module Azure
+  class Request
+    # Public: The URI we're requesting.
+    attr :uri
+
+    # Public: A Hash of request headers.
+    attr :headers
+
+    # Public: The HTTP method of the request.
+    attr :method
+
+    # Public: The request body (in Atom) or nil.
+    attr :body
+
+    # Public: Build the HTTP Request.
+    #
+    # method - The HTTP request method.
+    # uri    - The URI we'll hit.
+    # body   - The request body, or nil.
+    # clock  - An object that responds to .now and returns a Time.
+    def initialize(method, uri, body=nil, clock=Clock.new)
+      @method  = method
+      @uri     = uri
+      @body    = body
+      @headers = {}
+      @clock   = clock
+
+      calculate_headers
+    end
+
+    # Public: Make the request.
+    #
+    # ssl - Use SSL (default: false)
+    #
+    # Returns an Azure::Response.
+    def request!(ssl=false)
+      req = http_requester.new(uri.request_uri, headers)
+      req.body = body if body
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == 'https' || ssl
+        # require 'net/https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      Response.new(http.request(req))
+    end
+
+    # Build the headers Hash.
+    #
+    # Returns nothing.
+    def calculate_headers
+      headers["x-ms-date"] = @clock.now
+      headers["x-ms-version"] = "2011-08-18"
+      headers["DataServiceVersion"] = "1.0;NetFx"
+      headers["MaxDataServiceVersion"] = "2.0;NetFx"
+
+      if body
+        headers["Content-Type"]   = "application/atom+xml; charset=utf-8"
+        headers["Content-Length"] = body.bytesize.to_s
+        headers["Content-MD5"]    = Base64.strict_encode64(Digest::MD5.digest(body))
+      else
+        headers["Content-Length"] = "0"
+      end
+    end
+
+    # Obtain the Net::HTTP class that will handle this request.
+    #
+    # Returns a subclass of Net::HTTPRequest
+    def http_requester
+      Net::HTTP.const_get(method.to_s.capitalize)
+    rescue NameError => e
+      e.message = "#{method} is an invalid HTTP method"
+      raise
+    end
+
+    # Utility class to generate timestamps in a format the Azure platform likes.
+    class Clock
+      # Initialize the clock.
+      #
+      # source - Injectable dependency on the Time class.
+      def initialize(source=Time)
+        @source = source
+      end
+
+      # Calculate the time of "now", converted into something the Azure backend
+      # likes.
+      #
+      # Returns a String with the time formatted in accordance to RFC 2616.
+      def now
+        @source.now.httpdate
+      end
+    end
+  end
+end

data/lib/azure/response.rb

@@ -0,0 +1,93 @@
+require "azure/error"
+
+module Azure
+  # A small proxy to clean up the API of Net::HTTPResponse.
+  class Response
+
+    # Public: Initialize a new response.
+    #
+    # http_response - A Net::HTTPResponse.
+    def initialize(http_response)
+      @http_response = http_response
+    end
+
+    # Public: Get the response body.
+    #
+    # Returns a String.
+    def body
+      @http_response.body
+    end
+
+    # Public: Get the response status code.
+    #
+    # Returns a Fixnum.
+    def code
+      @http_response.code.to_i
+    end
+
+    # Public: Check if this response was successful. A request is considered
+    # successful if the response is in the 200 - 399 range.
+    #
+    # Returns true|false.
+    def success?
+      (200..399).include? code
+    end
+
+    # Public: Get all the response headers as a Hash.
+    #
+    # Returns a Hash.
+    def headers
+      @headers ||= HeaderHash.new(@http_response.to_hash)
+    end
+
+    # Public: Get an error that wraps this HTTP response, as long as this
+    # response was unsuccessful. This method _should not_ be called if the
+    # response was successful.
+    #
+    # Returns an Azure::HTTPError.
+    def exception
+      Azure::HTTPError.new(self)
+    end
+    alias_method :error, :exception
+
+    # HTTP Headers are case insensitive, and the Azure APIs seem to like this a
+    # lot (documenting headers in one case and sending them in another). Also
+    # this wraps Net::HTTPResponse headers by returning their values as strings,
+    # not arrays.
+    class HeaderHash < Hash
+      # Public: Initialize the header hash.
+      #
+      # headers - A Hash of headers as returned from Net::HTTPResponse#to_hash.
+      def initialize(headers)
+        super
+        headers = Hash[headers.map { |k,v| [k.downcase.freeze, v.first.freeze] }]
+        replace(headers)
+      end
+
+      # Public: Get a header's value or nil if it's not present.
+      #
+      # header - A string with the header's name.
+      #
+      # Returns a String or nil.
+      def [](header)
+        super(header.downcase)
+      end
+
+      # Public: Get a header's value or a specified default.
+      #
+      # header  - A string with the header's name.
+      # default - A default value.
+      #
+      # Yields a block where you can specify the default value.
+      #
+      # Returns a String, or the specified default.
+      def fetch(header, *default, &block)
+        if (args = default.size) > 1
+          raise ArgumentError, "wrong number of arguments(#{args + 1} for 2)"
+        end
+
+        super(header.downcase, *default, &block)
+      end
+    end
+  end
+end

data/lib/azure/service_bus.rb

@@ -0,0 +1,4 @@
+require "azure/service_bus/queues"
+require "azure/service_bus/topics"
+require "azure/service_bus/subscriptions"
+require "azure/service_bus/rules"

data/lib/azure/service_bus/auth/authorizer.rb

@@ -0,0 +1,22 @@
+require "azure/configuration"
+
+module Azure
+  module ServiceBus
+    module Auth
+      class Authorizer
+        # 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::ServiceBus::Auth::Wrap.
+        #
+        # Returns the modified request.
+        def sign(request, signer)
+          signature = signer.sign(request)
+          request.headers["Authorization"] = "#{signature}"
+          request
+        end
+      end
+    end
+  end
+end