gitlab-fog-azure-rm 1.9.1 → 2.0.0

data/vendor/azure-storage-ruby/common/lib/azure/core/http/http_request.rb

@@ -0,0 +1,195 @@
+#-------------------------------------------------------------------------
+# # 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 'tempfile'
+
+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/vendor/azure-storage-ruby/common/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

data/vendor/azure-storage-ruby/common/lib/azure/core/http/retry_policy.rb

@@ -0,0 +1,84 @@
+#-------------------------------------------------------------------------
+# # 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 handles retrying based on a
+      # specific policy when HTTP layer errors occur
+      class RetryPolicy < HttpFilter
+
+        def initialize(&block)
+          @block = block
+          @retry_data = {}
+        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)
+          response = nil
+          retry_data = @retry_data.dup
+          begin
+            # URI could change in the retry, e.g. secondary endpoint
+            unless retry_data[:uri].nil?
+              req.uri = retry_data[:uri]
+            end
+
+            retry_data[:error] = nil
+            response = _next.call
+          rescue
+            retry_data[:error] = $!
+          end while should_retry?(response, retry_data)
+          
+          # Assign the error when HTTP error is not thrown from the previous filter
+          retry_data[:error] = response.error if response && !response.success?
+          if retry_data[:error].nil?
+            response
+          else
+            raise retry_data[:error]
+          end
+        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_retry?(response, retry_data)
+          @block ? @block.call(response, retry_data) : false
+        end
+      end
+    end
+  end
+end

data/vendor/azure-storage-ruby/common/lib/azure/core/http/signer_filter.rb

@@ -0,0 +1,33 @@
+#-------------------------------------------------------------------------
+# # 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 creates a authorization signature which is added to the request headers
+      class SignerFilter < HttpFilter
+        def initialize(signer)
+          @signer = signer
+        end
+
+        def call(req, _next)
+          @signer.sign_request(req)
+          _next.call
+        end
+      end
+    end
+  end
+end

data/vendor/azure-storage-ruby/common/lib/azure/core/service.rb

@@ -0,0 +1,46 @@
+#-------------------------------------------------------------------------
+# # 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_request'
+
+module Azure
+  module Core
+    # A base class for Service implementations
+    class Service
+
+      # Create a new instance of the Service
+      #
+      # @param host     [String] The hostname. (optional, Default empty)
+      # @param options  [Hash] options including {:client} (optional, Default {})
+      def initialize(host='', options = {})
+        @host = host
+        @client = options[:client] || Azure
+      end
+
+      attr_accessor :host, :client
+
+      def call(method, uri, body=nil, headers={})
+        request = Core::Http::HttpRequest.new(method, uri, body: body, headers: headers, client: @client)
+        yield request if block_given?
+        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

data/vendor/azure-storage-ruby/common/lib/azure/core/signed_service.rb

@@ -0,0 +1,45 @@
+#-------------------------------------------------------------------------
+# # 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/filtered_service'
+require 'azure/core/http/signer_filter'
+require 'azure/core/auth/shared_key'
+
+module Azure
+  module Core
+    # A base class for Service implementations
+    class SignedService < FilteredService
+
+      # Create a new instance of the SignedService
+      #
+      # @param signer         [Azure::Core::Auth::Signer]. An implementation of Signer used for signing requests. (optional, Default=Azure::Core::Auth::SharedKey.new)
+      # @param account_name   [String] The account name (optional, Default=Azure.config.storage_account_name)
+      # @param options        [Hash] options
+      def initialize(signer=nil, account_name=nil, options={})
+        super('', options)
+        signer ||= Core::Auth::SharedKey.new(client.storage_account_name, client.storage_access_key)
+        @account_name = account_name || client.storage_account_name
+        @signer = signer
+        filters.unshift Core::Http::SignerFilter.new(signer) if signer
+      end
+
+      attr_accessor :account_name
+      attr_accessor :signer
+
+      def call(method, uri, body=nil, headers=nil, options={})
+        super(method, uri, body, headers, options)
+      end
+    end
+  end
+end