azure-storage-common 1.1.0 → 2.0.1

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

@@ -0,0 +1,135 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. 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/error'
+require 'nokogiri'
+require 'json'
+
+module Azure
+  module Core
+    module Http
+      # Public: Class for handling all HTTP response errors
+      class HTTPError < Azure::Core::Error
+
+        # Public: Detail of the response
+        #
+        # Returns an Azure::Core::Http::HttpResponse object
+        attr :http_response
+
+        # Public: The request URI
+        #
+        # Returns a String
+        attr :uri
+
+        # Public: The HTTP status code of this error
+        #
+        # Returns a Fixnum
+        attr :status_code
+
+        # Public: The type of error
+        #
+        # http://msdn.microsoft.com/en-us/library/azure/dd179357
+        #
+        # Returns a String
+        attr :type
+
+        # Public: Description of the error
+        #
+        # Returns a String
+        attr :description
+
+        # Public: Detail of the error
+        #
+        # Returns a String
+        attr :detail
+
+        # Public: The header name whose value is invalid
+        #
+        # Returns a String
+        attr :header
+
+        # Public: The invalid header value
+        #
+        # Returns a String
+        attr :header_value
+
+        # Public: Initialize an error
+        #
+        # http_response - An Azure::Core::HttpResponse
+        def initialize(http_response)
+          @http_response = http_response
+          @uri = http_response.uri
+          @status_code = http_response.status_code
+          parse_response
+          # Use reason phrase as the description if description is empty
+          @description = http_response.reason_phrase if (@description.nil? || @description.empty?) && http_response.reason_phrase
+          super("#{type} (#{status_code}): #{description}")
+        end
+
+        # Extract the relevant information from the response's body. If the response
+        # body is not an XML, we return an 'Unknown' error with the entire body as
+        # the description
+        #
+        # Returns nothing
+        def parse_response
+          if @http_response.body && @http_response.respond_to?(:headers) && @http_response.headers['Content-Type']
+            if @http_response.headers['Content-Type'].include?('xml')
+              parse_xml_response
+            elsif @http_response.headers['Content-Type'].include?('json')
+              parse_json_response
+            end
+          else
+            parse_unknown_response
+          end
+        end
+
+        def parse_xml_response
+          document = Nokogiri.Slop(@http_response.body)
+
+          @type = document.css('code').first.text if document.css('code').any?
+          @type = document.css('Code').first.text if document.css('Code').any?
+          @description = document.css('message').first.text if document.css('message').any?
+          @description = document.css('Message').first.text if document.css('Message').any?
+          @header = document.css('headername').first.text if document.css('headername').any?
+          @header = document.css('HeaderName').first.text if document.css('HeaderName').any?
+          @header_value = document.css('headervalue').first.text if document.css('headervalue').any?
+          @header_value = document.css('HeaderValue').first.text if document.css('HeaderValue').any?
+
+          # service bus uses detail instead of message
+          @detail = document.css('detail').first.text if document.css('detail').any?
+          @detail = document.css('Detail').first.text if document.css('Detail').any?
+        end
+
+        def parse_json_response
+          odata_error = JSON.parse(@http_response.body)['odata.error']
+          @type = odata_error['code']
+          @description = odata_error['message']['value']
+        end
+
+        def parse_unknown_response
+          @type = 'Unknown'
+          if @http_response.body
+            @description = "#{@http_response.body.strip}"
+          end
+        end
+
+        def inspect
+          string = "#<#{self.class.name}:#{self.object_id} "
+          fields = self.instance_variables.map{|field| "#{field}: #{self.send(field.to_s.delete("@")).inspect}"}
+          string << fields.join(", ") << ">"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. 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.
+#--------------------------------------------------------------------------
+module Azure
+  module Core
+    module Http
+      # A filter which can modify the HTTP pipeline both before and
+      # after requests/responses. Multiple filters can be nested in a
+      # "Russian Doll" model to create a compound HTTP pipeline
+      class HttpFilter
+
+        # Initialize a HttpFilter
+        #
+        # &block - An inline block which implements the filter.
+        #
+        # The inline block should take parameters |request, _next| where
+        # request is a HttpRequest and _next is an object that implements
+        # a method .call which returns an HttpResponse. The block passed
+        # to the constructor should also return HttpResponse, either as
+        # the result of calling _next.call or by customized logic.
+        #
+        def initialize(&block)
+          @block = block
+        end
+
+        # Executes the filter
+        #
+        # request - HttpRequest. The request
+        # _next   - An object that implements .call (no params)
+        #
+        # NOTE: _next is a either a subsequent HttpFilter wrapped in a
+        # closure, or the HttpRequest object's call method. Either way,
+        # it must have it's .call method executed within each filter to
+        #  complete the pipeline. _next.call should return an HttpResponse
+        # and so should this Filter.
+        def call(request, _next)
+          @block ? @block.call(request, _next) : _next.call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. 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/core/version'
+require 'azure/core/http/http_response'
+require 'azure/core/http/retry_policy'
+require 'azure/core/default'
+require 'azure/http_response_helper'
+
+module Azure
+  module Core
+    module Http
+      # Represents a HTTP request can perform synchronous queries to a
+      # HTTP server, returning a HttpResponse
+      class HttpRequest
+        include Azure::HttpResponseHelper
+        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
+
+        # Azure client which contains configuration context and http agents
+        # @return [Azure::Client]
+        attr_accessor :client
+        
+        # The http filter
+        attr_accessor :has_retry_filter
+
+        # Public: Create the HttpRequest
+        #
+        # @param method   [Symbol] The HTTP method to use (:get, :post, :put, :del, etc...)
+        # @param uri      [URI] The URI of the HTTP endpoint to query
+        # @param options_or_body  [Hash|IO|String] The request options including {:client, :body} or raw body only
+        def initialize(method, uri, options_or_body = {})
+          options ||= unless options_or_body.is_a?(Hash)
+                        {body: options_or_body}
+                      end || options_or_body || {}
+
+          @method = method
+          @uri = if uri.is_a?(String)
+                   URI.parse(uri)
+                 else
+                   uri
+                 end
+
+          @client = options[:client] || Azure
+
+          self.headers = default_headers(options[:current_time] || Time.now.httpdate).merge(options[:headers] || {})
+          self.body = options[:body]
+        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)
+        #
+        # options - The options that are used when call Azure::Core::FilteredService.call.
+        #           It can be used by retry policies to determine changes in the retry.
+        #
+        # &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, options={}, &block)
+          filter = filter || block
+          if filter
+            is_retry_policy = filter.is_a?(Azure::Core::Http::RetryPolicy)
+            filter.retry_data[:request_options] = options if is_retry_policy
+            @has_retry_filter ||= is_retry_policy
+            
+            original_call = self._method(:call)
+
+            # support 1.8.7 (define_singleton_method doesn't exist until 1.9.1)
+            filter_call = Proc.new do
+              filter.call(self, original_call)
+            end
+            k = class << self;
+              self;
+            end
+            if k.method_defined? :define_singleton_method
+              self.define_singleton_method(:call, filter_call)
+            else
+              k.send(:define_method, :call, filter_call)
+            end
+          end
+        end
+
+        # Build a default headers Hash
+        def default_headers(current_time)
+          {}.tap do |def_headers|
+            def_headers['User-Agent'] = Azure::Core::Default::USER_AGENT
+            def_headers['x-ms-date'] = current_time
+            def_headers['x-ms-version'] = '2014-02-14'
+            def_headers['DataServiceVersion'] = '1.0;NetFx'
+            def_headers['MaxDataServiceVersion'] = '3.0;NetFx'
+            def_headers['Content-Type'] = 'application/atom+xml; charset=utf-8'
+          end
+        end
+
+        def http_setup
+          @client.agents(uri)
+        end
+
+        def body=(body)
+          @body = body
+          apply_body_headers
+        end
+
+        # Sends request to HTTP server and returns a HttpResponse
+        #
+        # @return [HttpResponse]
+        def call
+          conn = http_setup
+          res = set_up_response(method.to_sym, uri, conn, headers ,body)
+
+          response = HttpResponse.new(res)
+          response.uri = uri
+          raise response.error if !response.success? && !@has_retry_filter
+          response
+        end
+
+        private
+
+        def apply_body_headers
+          return headers['Content-Length'] = '0' unless body
+
+          return apply_io_headers        if IO === body || Tempfile === body
+          return apply_string_io_headers if StringIO === body
+          return apply_miscellaneous_headers
+        end
+
+        def apply_io_headers
+          headers['Content-Length'] = body.size.to_s if body.respond_to?('size')
+          if headers['Content-Length'].nil?
+            raise ArgumentError, '\'Content-Length\' must be defined if size cannot be obtained from body IO.'
+          end
+          headers['Content-MD5'] = Digest::MD5.file(body.path).base64digest unless headers['Content-MD5']
+        end
+
+        def apply_string_io_headers
+          headers['Content-Length'] = body.size.to_s
+          unless headers['Content-MD5']
+            headers['Content-MD5'] = Digest::MD5.new.tap do |checksum|
+                                       while chunk = body.read(5242880)
+                                         checksum << chunk
+                                       end
+                                       body.rewind
+                                     end.base64digest
+          end
+        end
+
+        def apply_miscellaneous_headers
+          headers['Content-Length'] = body.size.to_s
+          headers['Content-MD5'] = Base64.strict_encode64(Digest::MD5.digest(body.to_s)) unless headers['Content-MD5']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. 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.status
+        end
+
+        # Public: Get the response reason phrase.
+        #
+        # Returns a String.
+        def reason_phrase
+          @http_response.reason_phrase
+        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?
+          @http_response.success?
+        end
+
+        # Public: Get all the response headers as a Hash.
+        #
+        # Returns a Hash.
+        def headers
+          @http_response.headers
+        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
+
+        # TODO: This needs to be deleted and HttpError needs to be refactored to not rely on HttpResponse.
+        # The dependency on knowing the internal structure of HttpResponse breaks good design principles.
+        # The only reason this class exists is because the HttpError parses the HttpResponse to produce an error msg.
+        class MockResponse
+          def initialize(code, body, headers)
+            @status = code
+            @body = body
+            @headers = headers
+            @headers.each { |k,v|
+              @headers[k] = [v] unless v.respond_to? 'first'
+            }
+          end
+          attr_accessor :status
+          attr_accessor :body
+          attr_accessor :headers
+
+          def to_hash
+            @headers
+          end
+        end
+      end
+    end
+  end
+end