faraday-typhoeus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93cb5577c71cc18d04be6150ccf60886529527a21b06ce229a49da67f047df98
+  data.tar.gz: 2210f5945cb6873e7a3e0f751355a4da96b4d2b60ced5d3e40fc1aa0a3f085d0
+SHA512:
+  metadata.gz: 3a1bb851c5f5bbf84176fe4f63e57480bfc35af59a90961aa1b4b2084a0adeb06f8453340c19aeb21b77690a0a255083eb82f3b23874248a03d8be6232667e2a
+  data.tar.gz: 688e444af7f0222bf5d4e1bdf04133884a565b9a507d1f600fe936915921accb9da563eb836b214b8ddf228de609405aa7094c8a47418a7fe67b3464fff3e117

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jan van der Pas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,147 @@
+# Faraday Typhoeus Adapter
+
+This is a [Faraday][faraday] adapter for the [Typhoeus][typhoeus] parallel HTTP client. It supports parallel HTTP requests and streaming.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faraday-typhoeus'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install faraday-typhoeus
+
+## Usage
+
+### Basic
+
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :typhoeus
+end
+```
+
+### Typhoeus Options
+
+You can also include options for [Typhoeus][typhoeus_options]/[Ethon][ethon_options] that will be used in every request:
+
+Note that block-style configuration for the adapter is not currently supported.
+
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :typhoeus, forbid_reuse: true, maxredirs: 1
+end
+```
+
+### Parallel Requests
+
+The adapter supports Typhoeus's parallel request functionality:
+
+```ruby
+conn = Faraday.new(...) do |f|
+  f.request  :url_encoded
+  f.response :logger
+  f.adapter  :typhoeus
+end
+
+responses = []
+
+conn.in_parallel do
+  # responses[0].body will be null here since the requests have not been 
+  # completed
+  responses = [
+    conn.get('/first'), 
+    conn.get('/second'),
+  ]
+end
+
+# after it has been completed the response information is fully available in
+# response[0].status, etc
+responses[0].body
+responses[1].body
+```
+
+### Streaming Responses
+
+The adapter supports [streamed responses](faraday_streaming) via the `on_data` option:
+
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :typhoeus
+end
+
+# Streaming
+
+chunks = []
+
+conn.get('/stream') do |req|
+  req.options.on_data proc do |chunk, received_bytes|
+    chunks << chunk
+  end
+end
+
+body = chunks.join
+
+# Server-Sent Event Polling
+
+body = nil
+
+begin
+  conn.get('/events') do |req|
+    req.options.timeout = 30
+
+    req.options.on_data = proc do |chunk|
+      # stop listening once we get some data (YMMV)
+      if chunk.start_with?('data: ')
+        body = chunk
+        :abort # abort the request, we're done
+      end
+    end
+  end
+rescue Faraday::ConnectionFailed => ex
+  raise ex unless body
+end
+```
+
+## Resources
+
+- See [Typhoeus Documentation][typhoeus] for more info.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](rubygems).
+
+### TODO
+
+- [ ] Better tests for parallel functionality (can port them over from Typhoeus)
+- [ ] Support block-based configuration like other adapters
+- [ ] Refactor the adapter a bit to look more like other Faraday 2 adapters (use `connection` etc.)
+- [ ] Compression support
+- [ ] Reason-phrase parsing support
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub][repo].
+
+## License
+
+The gem is available as open source under the terms of the [license][license].
+
+
+[faraday]: https://github.com/lostisland/faraday
+[typhoeus]: https://github.com/typhoeus/typhoeus
+[typhoeus_options]: https://github.com/typhoeus/typhoeus/blob/3544111b76b95d13da7cc6bfe4eb07921d771d93/lib/typhoeus/easy_factory.rb#L13-L39
+[ethon_options]: https://github.com/typhoeus/ethon/blob/5d9ddf8f609a6be4b5c60d55e1e338eeeb08f25f/lib/ethon/curls/options.rb#L214-L499
+[faraday_streaming]: https://lostisland.github.io/faraday/usage/streaming
+[repo]: https://github.com/dleavitt/faraday-typhoeus
+[license]: LICENSE.md
+[rubygems]: https://github.com/dleavitt/faraday-typhoeus/blob/main/rubygems

data/lib/faraday/adapter/typhoeus.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'typhoeus'
+
+module Faraday
+  class Adapter
+    # This class provides the main implementation for your adapter.
+    # There are some key responsibilities that your adapter should satisfy:
+    # * Initialize and store internally the client you chose (e.g. Net::HTTP)
+    # * Process requests and save the response (see `#call`)
+    class Typhoeus < Faraday::Adapter
+      self.supports_parallel = true
+
+      # The initialize method is lazy-called ONCE when the connection stack is
+      # built. See https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb
+      #
+      # @param app [#call] the "rack app" wrapped in middleware. See
+      #   https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb#L157
+      # @param opts [Hash] the options hash with all the options necessary for
+      #   the adapter to correctly configure itself. These are automatically
+      #   stored into `@connection_options` when you call `super`.
+      def initialize(app = nil, opts = {}, &block)
+        super(app, opts, &block)
+      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
+
+      # @param env [Faraday::Env] the environment of the request being processed
+      def call(env)
+        super
+        perform_request env
+        @app.call(env)
+
+        # NOTE: An adapter `call` MUST return the `env.response`. If
+        # `save_response` is the last line in your `call` method implementation,
+        # it will automatically return the response for you. Otherwise, you'll
+        # need to manually do so. You can do this with any (not both) of the
+        # following lines:
+        # * @app.call(env)
+        # * env.response
+        #
+        # Finally, it's good practice to rescue client-specific exceptions (e.g.
+        # Timeout, ConnectionFailed, etc...) and re-raise them as Faraday
+        # Errors. Check `Faraday::Error` for a list of all errors.
+        #
+        # rescue MyAdapterTimeout => e
+        #   # Most errors allow you to provide the original exception and optionally (if available) the response, to
+        #   # make them available outside of the middleware stack.
+        #   raise Faraday::TimeoutError, e
+        # end
+      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
+
+        if env[:request][:on_data].is_a?(Proc)
+          yielded = false
+          size = 0
+
+          req.on_body do |chunk|
+            if chunk.bytesize.positive? || size.positive?
+              yielded = true
+              size += chunk.bytesize
+
+              env[:request][:on_data].call(chunk, size)
+            end
+          end
+
+          req.on_complete do |_resp|
+            env[:request][:on_data].call(+'', 0) unless yielded
+          end
+        end
+
+        req.on_complete do |resp|
+          if resp.timed_out?
+            env[:typhoeus_timed_out] = true
+            unless parallel?(env)
+              raise Faraday::TimeoutError, 'request timed out'
+            end
+          elsif resp.response_code.zero? || ((resp.return_code != :ok) && !resp.mock?)
+            env[:typhoeus_connection_failed] = true
+            env[:typhoeus_return_message] = resp.return_message
+            unless parallel?(env)
+              raise Faraday::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(@connection_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&.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   = %i[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/lib/faraday/typhoeus/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Typhoeus
+    VERSION = '0.1.0'
+  end
+end

data/lib/faraday/typhoeus.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'adapter/typhoeus'
+require_relative 'typhoeus/version'
+
+module Faraday
+  # Main Faraday::Typhoeus adapter namespace
+  module Typhoeus
+    # Register adapter so either of the following work
+    # * conn.adapter Faraday::Adapter::Typhoeus
+    # * conn.adapter :typhoeus
+    Faraday::Adapter.register_middleware(typhoeus: Faraday::Adapter::Typhoeus)
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: faraday-typhoeus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Leavitt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: Faraday adapter for Typhoeus
+email:
+- daniel.leavitt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/faraday/adapter/typhoeus.rb
+- lib/faraday/typhoeus.rb
+- lib/faraday/typhoeus/version.rb
+homepage: https://github.com/dleavitt/faraday-typhoeus
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dleavitt/faraday-typhoeus
+  source_code_uri: https://github.com/dleavitt/faraday-typhoeus
+  changelog_uri: https://github.com/dleavitt/faraday-typhoeus
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Faraday adapter for Typhoeus
+test_files: []