azure 0.1.1 → 0.5.0

data/lib/azure/core/http/http_request.rb

@@ -0,0 +1,157 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "digest/md5"
+require "base64"
+require "net/http"
+require "time"
+
+require "azure/version"
+require "azure/core/http/http_response"
+
+module Azure
+  module Core
+    module Http
+      # Represents a HTTP request can perform synchronous queries to a 
+      # HTTP server, returning a HttpResponse 
+      class HttpRequest
+
+        alias_method :_method, :method
+
+        # The HTTP method to use (:get, :post, :put, :delete, etc...)
+        attr_accessor :method
+
+        # The URI of the HTTP endpoint to query
+        attr_accessor :uri
+
+        # The header values as a Hash
+        attr_accessor :headers
+
+        # The body of the request (IO or String)
+        attr_accessor :body
+
+        # Public: Create the HttpRequest
+        #
+        # method - Symbol. The HTTP method to use (:get, :post, :put, :del, etc...)
+        # uri    - URI. The URI of the HTTP endpoint to query
+        # body   - IO or String. The request body (optional)
+        # current_time - String. The current time as a HTTP date string
+        def initialize(method, uri, body=nil, current_time=Time.now.httpdate)
+          @method  = method
+          @uri     = uri
+          @body    = body
+          @headers = {}
+
+          default_headers current_time
+        end
+
+        # Public: Applies a HttpFilter to the HTTP Pipeline
+        #
+        # filter - Any object that responds to .call(req, _next) and 
+        #          returns a HttpResponse eg. HttpFilter, Proc, 
+        #          lambda, etc. (optional)
+        #
+        # &block - An inline block may be used instead of a filter
+        #
+        #          example:
+        #
+        #             request.with_filter do |req, _next| 
+        #               _next.call
+        #             end
+        #
+        # NOTE:
+        #
+        # The code block provided must call _next or the filter pipeline
+        # will not complete and the HTTP request will never execute
+        # 
+        def with_filter(filter=nil, &block)
+          filter = filter || block
+          if filter
+            old_impl = self._method(:call)
+            
+            # support 1.8.7 (define_singleton_method doesn't exist until 1.9.1)
+            new_impl = Proc.new do filter.call(self, old_impl) end
+            k = class << self; self; end
+            if k.method_defined? :define_singleton_method
+                self.define_singleton_method(:call, new_impl) 
+            else
+                k.send(:define_method, :call, new_impl)
+            end
+          end
+        end
+
+        # Build a default headers Hash
+        def default_headers(current_time)
+          headers["User-Agent"] = "Azure-SDK-for-Ruby/" + Azure::Version.to_s
+          headers["x-ms-date"] = current_time
+          headers["x-ms-version"] = "2012-02-12"
+          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"
+            headers["Content-Type"] = ""
+          end
+        end
+
+        # Obtain the Net::HTTP class that will handle this request
+        #
+        # Returns a subclass of Net::HTTPRequest
+        def http_request_class
+          Net::HTTP.const_get(method.to_s.capitalize)
+        rescue NameError => e
+          e.message = "#{method} is an invalid HTTP method"
+          raise
+        end
+
+
+        # Public: Sends request to HTTP server and returns a HttpResponse
+        #
+        # Returns a HttpResponse
+        def call
+          request = http_request_class.new(uri.request_uri, headers)
+          request.body = body if body
+
+          http = nil
+          if ENV['HTTP_PROXY'] || ENV['HTTPS_PROXY']
+            if ENV['HTTP_PROXY']
+              proxy_uri = URI::parse(ENV['HTTP_PROXY'])
+            else
+              proxy_uri = URI::parse(ENV['HTTPS_PROXY'])
+            end
+
+            http = Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port).new(uri.host, uri.port)
+          else
+            http = Net::HTTP.new(uri.host, uri.port)
+          end
+
+          if uri.scheme.downcase == 'https'
+            # require 'net/https'
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+
+          response = HttpResponse.new(http.request(request))
+          response.uri = uri
+          raise response.error unless response.success?
+          response
+        end
+      end
+    end
+  end
+end

data/lib/azure/core/http/http_response.rb

@@ -0,0 +1,133 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "azure/core/http/http_error"
+
+module Azure
+  module Core
+    module Http
+      # A small proxy to clean up the API of Net::HTTPResponse.
+      class HttpResponse
+
+        # Public: Initialize a new response.
+        #
+        # http_response - A Net::HTTPResponse.
+        def initialize(http_response, uri="")
+          @http_response = http_response
+          @uri = uri
+        end
+
+        attr_accessor :uri
+
+        # Public: Get the response body.
+        #
+        # Returns a String.
+        def body
+          @http_response.body
+        end
+
+        # Public: Get the response status code.
+        #
+        # Returns a Fixnum.
+        def status_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 nil|false.
+        def success?
+          (200..399).include? status_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 will return nil if the
+        # response was successful.
+        #
+        # Returns an Azure::Core::Http::HTTPError.
+        def exception
+          HTTPError.new(self) unless success?
+        end
+        
+        alias_method :error, :exception
+
+        # Since HTTP Headers are case insensitive, this class will 
+        # normalize them to lowercase. This also wraps Net::HTTPResponse 
+        # headers by returning their values as strings, not arrays, by selecting
+        # the first value from the array.
+        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
+        
+        class MockResponse
+          def initialize(code, body, headers)
+            @code = code.to_s 
+            @body = body
+            @headers = headers
+            @headers.each { |k,v|
+              @headers[k] = [v] unless v.respond_to? first 
+            } 
+          end
+          attr_accessor :code
+          attr_accessor :body
+          attr_accessor :headers
+
+          def to_hash
+            @headers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/azure/core/http/retry_policy.rb

@@ -0,0 +1,68 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "/azure/core/http/http_filter"
+
+module Azure
+  module Core
+    module Http
+    
+      # A HttpFilter implementation that handles retrying based on a 
+      # specific policy when HTTP layer errors occur
+      class RetryPolicy < HttpFilter
+    
+        def initialize(&block)
+          @block = block
+        end
+
+        attr_accessor :retry_data
+
+        # Overrides the base class implementation of call to implement 
+        # a retry loop that uses should_retry? to determine when to 
+        # break the loop
+        # 
+        # req   - HttpRequest. The HTTP request
+        # _next - HttpFilter. The next filter in the pipeline
+        def call(req, _next)
+          retry_data = {}
+          response = nil
+          begin
+            response = _next.call
+          end while should_retry?(response, retry_data)
+          response
+        end
+
+        # Determines if the HTTP request should continue retrying
+        # 
+        # response - HttpResponse. The response from the active request
+        # retry_data - Hash. Stores stateful retry data
+        #
+        # The retry_data is a Hash which can be used to store 
+        # stateful data about the request execution context (such as an 
+        # incrementing counter, timestamp, etc). The retry_data object 
+        # will be the same instance throughout the lifetime of the request.
+        #
+        # If an inline block was passed to the constructor, that block 
+        # will be used here and should return true to retry the job, or
+        # false to stop exit. If an inline block was not passed to the 
+        # constructor the method returns false.
+        #
+        # Alternatively, a subclass could override this method.
+        def should_try?(response, retry_data)
+          @block ? @block.call(response, retry_data) : false
+        end
+      end
+    end
+  end
+end

data/lib/azure/core/http/signer_filter.rb

@@ -0,0 +1,34 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "azure/core/http/http_filter"
+
+module Azure
+  module Core
+    module Http 
+      # A HttpFilter implementation that creates a authorization signature which is added to the request headers
+      class SignerFilter < HttpFilter
+        def initialize(signer)
+          @signer = signer
+        end
+
+        def call(req, _next)
+          signature = @signer.sign(req.method, req.uri, req.headers)
+          req.headers["Authorization"] = "#{@signer.name} #{signature}"
+          _next.call
+        end
+      end
+    end
+  end
+end

data/lib/azure/core/service.rb

@@ -1,43 +1,49 @@
-require "azure/request"
-require "azure/auth"
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/core/http/http_request'
 
 module Azure
   module Core
+    # A base class for Service implementations
     class Service
-      # Initialize the service.
-      #
-      # signer - The strategy to use to sign requests.
-      # auth   - Authorizer object. Defaults to Azure::Auth.new
-      def initialize(signer, auth=Azure::Auth.new)
-        @signer = signer
-        @auth = auth
-      end
 
-      # Sign a request to include the necessary authorization header.
-      #
-      # request - An Azure::Request.
-      # signer  - A signer strategy (defaults to Azure::Tables::Auth::SharedKey)
-      #
-      # Returns the signed request.
-      def sign_request(request)
-        @auth.sign(request, @signer)
+      # Create a new instance of the Service
+      # 
+      # host            - String. The hostname. (optional, Default empty)
+      def initialize(host='')
+        @host = host
       end
 
-      # Invoke the service.
-      #
-      # method - The HTTP method.
-      # uri    - The URI path for this service call.
-      # body   - The request body, if any (defaults to nil).
-      #
-      # Yields the request before signing it.
-      #
-      # Returns the Response object.
-      def call(method, uri, body=nil, request_factory=Request)
-        request = request_factory.new(method, uri, body)
+      attr_accessor :host
+
+      def call(method, uri, body=nil, headers=nil)
+        request = Core::Http::HttpRequest.new(method, uri, body)
+        request.headers.merge!(headers) if headers
+
+        request.headers['connection'] = 'keep-alive' if request.respond_to? :headers
+
         yield request if block_given?
-        sign_request(request)
-        request.request!
+
+        request.call
+      end
+
+      def generate_uri(path='', query={})
+        uri = URI.parse(File.join(host, path))
+        uri.query = URI.encode_www_form(query) unless query == nil or query.empty?
+        uri
       end
     end
   end
-end
+end