azure-multistorage 0.6.4

data/lib/azure/core/error.rb

@@ -0,0 +1,22 @@
+#-------------------------------------------------------------------------
+# # 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
+    # Public: Superclass for errors generated from this library, so people can
+    # just rescue this for generic error handling
+    class Error < StandardError
+    end
+  end
+end

data/lib/azure/core/filtered_service.rb

@@ -0,0 +1,44 @@
+#-------------------------------------------------------------------------
+# # 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/service'
+
+module Azure
+  module Core
+    # A base class for Service implementations
+    class FilteredService < Service
+
+      # Create a new instance of the FilteredService
+      # 
+      # host            - String. The hostname. (optional, Default empty)
+      def initialize(host='')
+        super(host)
+        @filters = []
+      end
+
+      attr_accessor :filters
+
+      def call(method, uri, body=nil, headers=nil)
+        super(method, uri, body, headers) do |request|
+          filters.each { |filter| request.with_filter filter } if filters
+        end
+      end
+
+      def with_filter(filter=nil, &block)
+        filter = filter || block
+        filters.push filter if filter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+#-------------------------------------------------------------------------
+# # 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_filter"
+
+module Azure
+  module Core
+    module Http 
+      # A HttpFilter implementation that displays information about the request and response for debugging
+      class DebugFilter < HttpFilter
+        def call(req, _next)
+          puts "--REQUEST-BEGIN---------------------------"
+          puts "method:", req.method, "uri:", req.uri, "headers:", req.headers, "body:", req.body
+          puts "--REQUEST-END---------------------------"
+          
+          r = _next.call
+          puts "--RESPONSE-BEGIN---------------------------"
+          puts "status_code:", r.status_code, "headers:", r.headers, "body:", r.body
+          puts "--RESPONSE-END---------------------------"
+          r
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+#-------------------------------------------------------------------------
+# # 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"
+
+module Azure
+  module Core
+    module Http
+      # Public: Class for handling all HTTP response errors
+      class HTTPError < Azure::Core::Error
+        
+        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/windowsazure/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: 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
+          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.body.include?("<")
+
+            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?
+
+            # 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?
+          else
+            @type = "Unknown"
+            if @http_response.body
+              @description = @http_response.body.strip
+            else
+              @description = @http_response.message.strip
+            end
+          end
+        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,157 @@
+#-------------------------------------------------------------------------
+# # 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/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,140 @@
+#-------------------------------------------------------------------------
+# # 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 message.
+        #
+        # Returns a String.
+        def message
+          @http_response.message
+        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