cloudsmith-api 0.30.7 → 0.44.4

data/vendor/bundle/ruby/2.3.0/gems/typhoeus-1.3.1/lib/typhoeus/adapters/faraday.rb

@@ -0,0 +1,180 @@
+require 'faraday'
+
+module Faraday # :nodoc:
+  class Adapter # :nodoc:
+
+    # Adapter to use Faraday with Typhoeus.
+    #
+    # @example Use Typhoeus.
+    #   require 'faraday'
+    #   require 'typhoeus'
+    #   require 'typhoeus/adapters/faraday'
+    #
+    #   conn = Faraday.new(url: "www.example.com") do |faraday|
+    #     faraday.adapter :typhoeus
+    #
+    #     # You can include Typhoeus options to be used for every request
+    #     # faraday.adapter :typhoeus, forbid_reuse: true, maxredirs: 1
+    #   end
+    #
+    #   response = conn.get("/")
+    class Typhoeus < Faraday::Adapter
+      self.supports_parallel = true
+
+      (class << self; self; end).instance_eval do
+        remove_method :setup_parallel_manager if method_defined? :setup_parallel_manager
+      end
+
+      remove_method :call              if method_defined? :call
+      remove_method :perform_request   if method_defined? :perform_request
+      remove_method :request           if method_defined? :request
+      remove_method :read_body         if method_defined? :read_body
+      remove_method :configure_ssl     if method_defined? :configure_ssl
+      remove_method :configure_proxy   if method_defined? :configure_proxy
+      remove_method :configure_timeout if method_defined? :configure_timeout
+      remove_method :configure_socket  if method_defined? :configure_socket
+      remove_method :parallel?         if method_defined? :parallel?
+
+      # Initialize the Typhoeus adapter
+      #
+      # @param [ App ] app Farday app
+      # @option [ Hash ] adapter_options Typhoeus options
+      #
+      # @return [ void ]
+      def initialize(app, adapter_options = {})
+        super(app)
+        @adapter_options = adapter_options
+      end
+
+      # Setup Hydra with provided options.
+      #
+      # @example Setup Hydra.
+      #   Faraday::Adapter::Typhoeus.setup_parallel_manager
+      #   #=> #<Typhoeus::Hydra ... >
+      #
+      # @param (see Typhoeus::Hydra#initialize)
+      # @option (see Typhoeus::Hydra#initialize)
+      #
+      # @return [ Typhoeus::Hydra ] The hydra.
+      def self.setup_parallel_manager(options = {})
+        ::Typhoeus::Hydra.new(options)
+      end
+
+      dependency 'typhoeus'
+
+      # Hook into Faraday and perform the request with Typhoeus.
+      #
+      # @param [ Hash ] env The environment.
+      #
+      # @return [ void ]
+      def call(env)
+        super
+        perform_request env
+        @app.call env
+      end
+
+      private
+
+      def perform_request(env)
+        if parallel?(env)
+          env[:parallel_manager].queue request(env)
+        else
+          request(env).run
+        end
+      end
+
+      def request(env)
+        read_body env
+
+        req = typhoeus_request(env)
+
+        configure_ssl     req, env
+        configure_proxy   req, env
+        configure_timeout req, env
+        configure_socket  req, env
+
+        req.on_complete do |resp|
+          if resp.timed_out?
+            env[:typhoeus_timed_out] = true
+            unless parallel?(env)
+              raise Faraday::Error::TimeoutError, "request timed out"
+            end
+          elsif (resp.response_code == 0) || ((resp.return_code != :ok) && !resp.mock?)
+            env[:typhoeus_connection_failed] = true
+            env[:typhoeus_return_message] = resp.return_message
+            unless parallel?(env)
+              raise Faraday::Error::ConnectionFailed, resp.return_message
+            end
+          end
+
+          save_response(env, resp.code, resp.body) do |response_headers|
+            response_headers.parse resp.response_headers
+          end
+          # in async mode, :response is initialized at this point
+          env[:response].finish(env) if parallel?(env)
+        end
+
+        req
+      end
+
+      def typhoeus_request(env)
+        opts = {
+          :method => env[:method],
+          :body => env[:body],
+          :headers => env[:request_headers]
+        }.merge(@adapter_options)
+
+        ::Typhoeus::Request.new(env[:url].to_s, opts)
+      end
+
+      def read_body(env)
+        env[:body] = env[:body].read if env[:body].respond_to? :read
+      end
+
+      def configure_ssl(req, env)
+        ssl = env[:ssl]
+
+        verify_p = (ssl && ssl.fetch(:verify, true))
+
+        ssl_verifyhost = verify_p ? 2 : 0
+        req.options[:ssl_verifyhost] = ssl_verifyhost
+        req.options[:ssl_verifypeer] = verify_p
+        req.options[:sslversion] = ssl[:version]     if ssl[:version]
+        req.options[:sslcert]    = ssl[:client_cert] if ssl[:client_cert]
+        req.options[:sslkey]     = ssl[:client_key]  if ssl[:client_key]
+        req.options[:cainfo]     = ssl[:ca_file]     if ssl[:ca_file]
+        req.options[:capath]     = ssl[:ca_path]     if ssl[:ca_path]
+        client_cert_passwd_key   = [:client_cert_passwd, :client_certificate_password].detect { |name| ssl.key?(name) }
+        req.options[:keypasswd]  = ssl[client_cert_passwd_key] if client_cert_passwd_key
+      end
+
+      def configure_proxy(req, env)
+        proxy = env[:request][:proxy]
+        return unless proxy
+
+        req.options[:proxy] = "#{proxy[:uri].scheme}://#{proxy[:uri].host}:#{proxy[:uri].port}"
+
+        if proxy[:user] && proxy[:password]
+          req.options[:proxyauth] = :any
+          req.options[:proxyuserpwd] = "#{proxy[:user]}:#{proxy[:password]}"
+        end
+      end
+
+      def configure_timeout(req, env)
+        env_req = env[:request]
+        req.options[:timeout_ms] = (env_req[:timeout] * 1000).to_i             if env_req[:timeout]
+        req.options[:connecttimeout_ms] = (env_req[:open_timeout] * 1000).to_i if env_req[:open_timeout]
+      end
+
+      def configure_socket(req, env)
+        if bind = env[:request][:bind]
+          req.options[:interface] = bind[:host]
+        end
+      end
+
+      def parallel?(env)
+        !!env[:parallel_manager]
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/typhoeus-1.3.1/lib/typhoeus/easy_factory.rb

@@ -0,0 +1,180 @@
+require 'set'
+
+module Typhoeus
+
+  # This is a Factory for easies to be used in the hydra.
+  # Before an easy is ready to be added to a multi the
+  # on_complete callback to be set.
+  # This is done by this class.
+  #
+  # @api private
+  class EasyFactory
+
+    RENAMED_OPTIONS =  {
+          :auth_method => :httpauth,
+          :connect_timeout => :connecttimeout,
+          :encoding => :accept_encoding,
+          :follow_location => :followlocation,
+          :max_redirects => :maxredirs,
+          :proxy_type => :proxytype,
+          :ssl_cacert => :cainfo,
+          :ssl_capath => :capath,
+          :ssl_cert => :sslcert,
+          :ssl_cert_type => :sslcerttype,
+          :ssl_key => :sslkey,
+          :ssl_key_password => :keypasswd,
+          :ssl_key_type => :sslkeytype,
+          :ssl_version => :sslversion,
+      }
+
+    CHANGED_OPTIONS =  {
+          :disable_ssl_host_verification => :ssl_verifyhost,
+          :disable_ssl_peer_verification => :ssl_verifypeer,
+          :proxy_auth_method => :proxyauth,
+      }
+
+    REMOVED_OPTIONS =  Set.new([:cache_key_basis, :cache_timeout, :user_agent])
+
+    SANITIZE_IGNORE  = Set.new([:method, :cache_ttl, :cache])
+    SANITIZE_TIMEOUT = Set.new([:timeout_ms, :connecttimeout_ms])
+
+    # Returns the request provided.
+    #
+    # @return [ Typhoeus::Request ]
+    attr_reader :request
+
+    # Returns the hydra provided.
+    #
+    # @return [ Typhoeus::Hydra ]
+    attr_reader :hydra
+
+    # Create an easy factory.
+    #
+    # @example Create easy factory.
+    #   Typhoeus::Hydra::EasyFactory.new(request, hydra)
+    #
+    # @param [ Request ] request The request to build an easy for.
+    # @param [ Hydra ] hydra The hydra to build an easy for.
+    def initialize(request, hydra = nil)
+      @request = request
+      @hydra = hydra
+    end
+
+    # Return the easy in question.
+    #
+    # @example Return easy.
+    #   easy_factory.easy
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def easy
+      @easy ||= Typhoeus::Pool.get
+    end
+
+    # Fabricated easy.
+    #
+    # @example Prepared easy.
+    #   easy_factory.get
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def get
+      begin
+        easy.http_request(
+          request.base_url.to_s,
+          request.options.fetch(:method, :get),
+          sanitize(request.options)
+        )
+      rescue Ethon::Errors::InvalidOption => e
+        help = provide_help(e.message.match(/:\s(\w+)/)[1])
+        raise $!, "#{$!}#{help}", $!.backtrace
+      end
+      set_callback
+      easy
+    end
+
+    private
+
+    def sanitize(options)
+      # set nosignal to true by default
+      # this improves thread safety and timeout behavior
+      sanitized = {:nosignal => true}
+      request.options.each do |k,v|
+        s = k.to_sym
+        next if SANITIZE_IGNORE.include?(s)
+        if new_option = RENAMED_OPTIONS[k.to_sym]
+          warn("Deprecated option #{k}. Please use #{new_option} instead.")
+          sanitized[new_option] = v
+        # sanitize timeouts
+        elsif SANITIZE_TIMEOUT.include?(s)
+          if !v.integer?
+            warn("Value '#{v}' for option '#{k}' must be integer.")
+          end
+          sanitized[k] = v.ceil
+        else
+          sanitized[k] = v
+        end
+      end
+
+      sanitize_timeout!(sanitized, :timeout)
+      sanitize_timeout!(sanitized, :connecttimeout)
+
+      sanitized
+    end
+
+    def sanitize_timeout!(options, timeout)
+      timeout_ms = :"#{timeout}_ms"
+      if options[timeout] && options[timeout].round != options[timeout]
+        if !options[timeout_ms]
+          options[timeout_ms] = (options[timeout]*1000).ceil
+        end
+        options[timeout] = options[timeout].ceil
+      end
+      options
+    end
+
+    # Sets on_complete callback on easy in order to be able to
+    # track progress.
+    #
+    # @example Set callback.
+    #   easy_factory.set_callback
+    #
+    # @return [ Ethon::Easy ] The easy.
+    def set_callback
+      if request.streaming?
+        response = nil
+        easy.on_headers do |easy|
+          response = Response.new(Ethon::Easy::Mirror.from_easy(easy).options)
+          request.execute_headers_callbacks(response)
+        end
+        request.on_body.each do |callback|
+          easy.on_body do |chunk, easy|
+            callback.call(chunk, response)
+          end
+        end
+      else
+        easy.on_headers do |easy|
+          request.execute_headers_callbacks(Response.new(Ethon::Easy::Mirror.from_easy(easy).options))
+        end
+      end
+      request.on_progress.each do |callback|
+        easy.on_progress do |dltotal, dlnow, ultotal, ulnow, easy|
+          callback.call(dltotal, dlnow, ultotal, ulnow, response)
+        end
+      end
+      easy.on_complete do |easy|
+        request.finish(Response.new(easy.mirror.options))
+        Typhoeus::Pool.release(easy)
+        if hydra && !hydra.queued_requests.empty?
+          hydra.dequeue_many
+        end
+      end
+    end
+
+    def provide_help(option)
+      if new_option = CHANGED_OPTIONS[option.to_sym]
+        "\nPlease try #{new_option} instead of #{option}." if new_option
+      elsif REMOVED_OPTIONS.include?(option.to_sym)
+        "\nThe option #{option} was removed."
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/typhoeus-1.3.1/lib/typhoeus/request/actions.rb

@@ -0,0 +1,125 @@
+module Typhoeus
+  class Request
+
+    # Module containing logic about shortcuts to
+    # http methods. Like
+    #   Typhoeus.get("www.example.com")
+    module Actions
+
+      # Make a get request.
+      #
+      # @example Make get request.
+      #   Typhoeus.get("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def get(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :get)).run
+      end
+
+      # Make a post request.
+      #
+      # @example Make post request.
+      #   Typhoeus.post("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def post(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :post)).run
+      end
+
+      # Make a put request.
+      #
+      # @example Make put request.
+      #   Typhoeus.put("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option options :params [ Hash ] Params hash which
+      #   is attached to the base_url.
+      # @option options :body [ Hash ] Body hash which
+      #   becomes a PUT request body.
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def put(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :put)).run
+      end
+
+      # Make a delete request.
+      #
+      # @example Make delete request.
+      #   Typhoeus.delete("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def delete(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :delete)).run
+      end
+
+      # Make a head request.
+      #
+      # @example Make head request.
+      #   Typhoeus.head("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def head(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :head)).run
+      end
+
+      # Make a patch request.
+      #
+      # @example Make patch request.
+      #   Typhoeus.patch("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def patch(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :patch)).run
+      end
+
+      # Make a options request.
+      #
+      # @example Make options request.
+      #   Typhoeus.options("www.example.com")
+      #
+      # @param (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Response#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def options(base_url, options = {})
+        Request.new(base_url, options.merge(:method => :options)).run
+      end
+    end
+  end
+end